yog 0.0.66

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! The §11 recency fact (`Agent::last_action_unix`, bl-cad5): the newest of the
//! tip commit timestamp, the newest `messages/` entry mtime and the latest
//! step's `response.json` mtime. Proven end-to-end through
//! [`GitTree::from_repo`], because the whole point is that the fact is gathered
//! at snapshot time — a unit test of the fold alone would not show that.

use super::fixture::Fixture;
use super::mtime;
use crate::git_tree::{Agent, GitTree};
use std::fs;

fn agent_of(tree: &GitTree, id: &str) -> Agent {
    tree.agents
        .iter()
        .find(|a| a.agent_id == id)
        .expect("the enumerated agent")
        .clone()
}

/// Write one committed-transcript entry into `agents/<id>/messages/`.
fn write_message(fx: &Fixture, id: &str, name: &str) -> std::path::PathBuf {
    let dir = fx.path.join("agents").join(id).join("messages");
    fs::create_dir_all(&dir).unwrap();
    let path = dir.join(name);
    fs::write(&path, "from a peer\n").unwrap();
    path
}

#[test]
fn a_delivered_message_is_an_action_even_though_it_commits_nothing() {
    // A message file lands by rename into `messages/` — no commit moves, so the
    // tip timestamp cannot see it. The recency fact must.
    let fx = Fixture::new();
    let id = "20260801T120000Z-msg";
    fx.build_agent(id, "wait for mail");
    let msg = write_message(&fx, id, "001-peer.md");
    let agent = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(agent.last_action_unix, mtime(&msg));
    assert!(agent.last_action_unix >= agent.tip_timestamp_unix);
}

#[test]
fn the_live_streaming_tail_is_an_action() {
    // The harness rewrites `steps/<id>/<NNN>/response.json` as tokens arrive;
    // the step commits only when the turn ends. Mid-stream, the tail's mtime is
    // the only evidence the conversation is moving at all.
    let fx = Fixture::new();
    let id = "20260801T120100Z-strm";
    fx.build_agent(id, "start streaming");
    fx.write_response_events(
        id,
        2,
        &[r#"{"type":"content_delta","index":0,"delta":{"text_delta":"mid"}}"#],
    );
    let tail = fx.path.join("steps").join(id).join("002/response.json");
    let agent = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(agent.last_action_unix, mtime(&tail));
    assert!(agent.last_action_unix >= agent.tip_timestamp_unix);
}

#[test]
fn the_newest_of_the_three_wins() {
    // Both off-commit signals present: the later one is the answer.
    let fx = Fixture::new();
    let id = "20260801T120200Z-both";
    fx.build_agent(id, "mail then tokens");
    write_message(&fx, id, "001-peer.md");
    fx.write_response_events(id, 1, &[r#"{"type":"end"}"#]);
    let tail = fx.path.join("steps").join(id).join("001/response.json");
    let agent = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(agent.last_action_unix, mtime(&tail));
}

#[test]
fn with_nothing_but_commits_the_tip_is_the_last_action() {
    // Three empty cases at once: an agent whose only step wrote a request but
    // no response tail, an empty `messages/` directory, and (the child) an
    // agent with no `steps/` directory at all. Each contributes nothing, so the
    // tip stands — no special case, just a max over zeroes.
    let fx = Fixture::new();
    let id = "20260801T120300Z-quiet";
    fx.build_agent(id, "say nothing");
    fs::create_dir_all(fx.path.join("agents").join(id).join("messages")).unwrap();
    let child = format!("{id}-k-1");
    fx.build_child(id, &child);
    let tree = GitTree::from_repo(&fx.path).unwrap();
    let root = agent_of(&tree, id);
    assert_eq!(root.last_action_unix, root.tip_timestamp_unix);
    let kid = agent_of(&tree, &child);
    assert_eq!(kid.last_action_unix, kid.tip_timestamp_unix);
}

/// The landed-message **count** (§5.1 #12, bl-915e), off the same readdir the
/// recency fact above rides: what §7.2's pending echo reconciles against. Zero
/// for an agent with no transcript directory at all — the general path with no
/// inputs, which is what a just-written branch has.
#[test]
fn the_message_count_rides_the_same_directory_walk_as_the_recency_fact() {
    let fx = Fixture::new();
    let id = "20260801T120000Z-count";
    fx.build_agent(id, "count me");
    let bare = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(bare.messages, 0, "no messages/ directory is no messages");

    write_message(&fx, id, "001-user.md");
    write_message(&fx, id, "002-peer.md");
    let two = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(two.messages, 2);
    assert!(
        two.last_action_unix >= bare.last_action_unix,
        "and the recency fact still comes off the same walk"
    );
    assert!(!two.in_memory(), "a derived agent always has a tip");
}

/// The count is the counter's **high-water**, not a file count (bl-fde5): a
/// compaction deletes entries below the surviving counter, and the
/// messages-ever-landed fact must not go down with the files — the §7.2 echo's
/// passed-the-baseline predicate has no reading for a shrinking count. A stray
/// non-message entry moves the recency mtime (it is a write into the
/// directory) but never the count (it is not a message that landed).
#[test]
fn the_message_count_survives_a_compaction_and_ignores_stray_entries() {
    let fx = Fixture::new();
    let id = "20260801T120400Z-hiwater";
    fx.build_agent(id, "compact me");
    write_message(&fx, id, "001-user.md");
    write_message(&fx, id, "002-m.json");
    write_message(&fx, id, "003-tool.json");
    let before = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(before.messages, 3);

    // The compactor deletes the leading span; the counter's high-water stands.
    let dir = fx.path.join("agents").join(id).join("messages");
    fs::remove_file(dir.join("001-user.md")).unwrap();
    fs::remove_file(dir.join("002-m.json")).unwrap();
    let after = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(
        after.messages, 3,
        "one file on disk, three messages ever landed"
    );

    // A stray subdirectory is a write, not a landing.
    fs::create_dir_all(dir.join("scratch")).unwrap();
    let stray = agent_of(&GitTree::from_repo(&fx.path).unwrap(), id);
    assert_eq!(stray.messages, 3, "the stray entry is not a message");
}