litany 0.0.6

A git-backed agent harness
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! The §3.3 **bounded transcript projection** through the production
//! executor (bl-d5fa): with a `tool_output:` policy in hand, each
//! captured stream is bounded before the result envelope is rendered
//! around it, while the diagnostic `output.json` keeps the full bytes.
//! The head+tail split itself is pinned by `super::super::bound`'s own
//! tests; here the subject is the wiring — streams bounded
//! independently, envelope structure never capped, record complete.

use super::super::{OUTPUT_FILE, STEP_TOOLS_SUBDIR, ToolCall, ToolExecutor, ToolOutputRecord};
use super::fixtures::{FixedClock, HarnessRoot, StepDir, driver_target};
use crate::config::ToolOutputBound;
use crate::prompt::tool::SpawnTool;
use serde_json::json;
use std::sync::atomic::AtomicBool;

fn small_bound() -> Option<ToolOutputBound> {
    Some(ToolOutputBound {
        head_bytes: 8,
        tail_bytes: 8,
    })
}

/// An oversized stdout is projected head+tail with the honest marker —
/// stating bytes, lines, and the workspace-relative record path — while
/// `output.json` keeps every byte and the envelope header survives.
#[test]
fn oversized_stdout_is_bounded_and_the_record_keeps_it_all() {
    let root = HarnessRoot::new();
    root.install(
        "chatty",
        r#"printf 'AAAAAAA\n%s\nZZZZZZZ\n' "midmidmidmidmid""#,
    );
    let clock = FixedClock::default();
    let step = StepDir::new();
    let exec = SpawnTool::new(root.path(), &clock, driver_target());
    let outcome = exec
        .execute(
            ToolCall {
                id: "toolu_big",
                name: "chatty",
                input: &json!({}),
            },
            &step.path,
            &AtomicBool::new(false),
            small_bound(),
        )
        .unwrap();
    let content = String::from_utf8(outcome.content).unwrap();
    // The envelope header is structure, never capped.
    assert!(content.starts_with("Exit code: 0\n"));
    // Head and tail survive; the middle is gone.
    assert!(content.contains("AAAAAAA\n"));
    assert!(content.ends_with("ZZZZZZZ\n"));
    assert!(!content.contains("midmid"));
    // The marker is honest: byte/line counts and the record's
    // workspace-relative home (byte counts only — no tokenizer here).
    assert!(content.contains(
        "[... stdout truncated: 32 bytes / 3 lines total; showing the first \
         8 and last 8 bytes; full record: steps/convid/001/tools/toolu_big/output.json ...]"
    ));
    // The diagnostic layer lost nothing.
    let dir = step.path.join(STEP_TOOLS_SUBDIR).join("toolu_big");
    let record: ToolOutputRecord =
        serde_json::from_slice(&std::fs::read(dir.join(OUTPUT_FILE)).unwrap()).unwrap();
    assert_eq!(record.stdout, "AAAAAAA\nmidmidmidmidmid\nZZZZZZZ\n");
}

/// The streams are bounded independently: a small stdout rides
/// untouched next to a bounded stderr, and the `--- stderr ---` marker
/// — envelope structure — is never part of what gets capped.
#[test]
fn streams_are_bounded_independently_around_the_envelope() {
    let root = HarnessRoot::new();
    root.install(
        "warns",
        r#"printf 'ok\n'; printf 'EE-head\n%s\nEE-tail\n' "wall-of-warnings" 1>&2; exit 3"#,
    );
    let clock = FixedClock::default();
    let step = StepDir::new();
    let exec = SpawnTool::new(root.path(), &clock, driver_target());
    let outcome = exec
        .execute(
            ToolCall {
                id: "toolu_w",
                name: "warns",
                input: &json!({}),
            },
            &step.path,
            &AtomicBool::new(false),
            small_bound(),
        )
        .unwrap();
    assert!(outcome.is_error);
    let content = String::from_utf8(outcome.content).unwrap();
    assert!(content.starts_with("Exit code: 3\nok\n--- stderr ---\n"));
    assert!(content.contains("[... stderr truncated:"));
    assert!(!content.contains("wall-of-warnings"));
    assert!(content.ends_with("EE-tail\n"));
}

/// No `tool_output:` policy in the governing workflow — the projection
/// is the capture, byte for byte, marker-free (the pre-bl-d5fa shape).
#[test]
fn without_a_policy_the_projection_is_unbounded() {
    let root = HarnessRoot::new();
    root.install(
        "plain",
        r#"printf '%s\n' "0123456789012345678901234567890123456789""#,
    );
    let clock = FixedClock::default();
    let step = StepDir::new();
    let exec = SpawnTool::new(root.path(), &clock, driver_target());
    let outcome = exec
        .execute(
            ToolCall {
                id: "toolu_p",
                name: "plain",
                input: &json!({}),
            },
            &step.path,
            &AtomicBool::new(false),
            None,
        )
        .unwrap();
    let content = String::from_utf8(outcome.content).unwrap();
    assert_eq!(
        content,
        "Exit code: 0\n0123456789012345678901234567890123456789\n"
    );
}