memoryd: the Honcho worker sends conclusions, their deletions and fleet notes

Co-Authored-By: ornith-1.5-35b-a3b <agent@wntrmute.dev>
2026-09-28 13:11:51 -07:00
parent 4ebfc36c1a
commit fb05b26462
9 changed files with 790 additions and 121 deletions
@@ -0,0 +1,411 @@
+//! The worker sending memory writes (M5c spec, sections 4 and 5), stepped by hand against the fake
+//! Honcho: a conclusion made in the session's `<id>_memory` session with the agent's and the
+//! owner's peers; one deleted by the id its making got, or nothing to delete; a 404 on delete as
+//! done; an untrusted note as a fleet message from the agent; the text neutralised; one outbox
+//! across turns and edits; errors as for turns; a restart sending nothing again. Do not edit.
+
+#[path = "support/honcho.rs"]
+mod honcho;
+#[path = "support/logs.rs"]
+mod logs;
+#[path = "support/tmp.rs"]
+mod tmp;
+#[path = "support/turns.rs"]
+mod turns;
+#[path = "support/worker.rs"]
+mod worker;
+
+use bxcore::sanitize::TAGS;
+use bxcore::{SessionId, Timestamp};
+use honcho::{FakeHoncho, Mode, Request};
+use logs::assistant;
+use memoryd::honcho::edits::{MEMORY_SUFFIX, memory_session};
+use memoryd::honcho::ledger::{Action, Item, Record, Workspace};
+use memoryd::honcho::worker::{MAX_PART, Step};
+use serde_json::{Value, json};
+use turns::spoken;
+use worker::{FAST, Home};
+
+/// The id fixture 11 gives the first conclusion it makes.
+const CONCLUSION: &str = "YUBMqIqHhuJprV4o-inrg";
+
+fn sid(s: &str) -> SessionId {
+    SessionId::new(s).unwrap()
+}
+
+fn edit(id: &str, part: u32) -> Item {
+    Item::Edit {
+        id: id.to_string(),
+        part,
+    }
+}
+
+fn conclude(peer: &str, text: &str) -> Action {
+    Action::Conclude {
+        workspace: Workspace::Trusted,
+        peer: peer.to_string(),
+        session: sid("mm-a"),
+        text: text.to_string(),
+    }
+}
+
+fn unconclude(text: &str) -> Action {
+    Action::Unconclude {
+        workspace: Workspace::Trusted,
+        text: text.to_string(),
+    }
+}
+
+fn fleet(text: &str) -> Action {
+    Action::Fleet {
+        session: sid("mm-c"),
+        text: text.to_string(),
+    }
+}
+
+/// Decide `action` for `item`, as task 12 does when an edit is journalled.
+fn decide(home: &Home, item: Item, action: Action) {
+    let sync = home.sync.lock().unwrap();
+    sync.ledger()
+        .append(Record::Decided {
+            time: Timestamp::parse("2026-09-28T10:00:00.000Z").unwrap(),
+            item,
+            action,
+        })
+        .unwrap();
+}
+
+fn sent_ids(home: &Home, item: &Item) -> Option<Vec<String>> {
+    home.records().into_iter().find_map(|r| match r {
+        Record::Sent { item: i, ids, .. } if i == *item => Some(ids),
+        _ => None,
+    })
+}
+
+fn posts(fake: &FakeHoncho, suffix: &str) -> Vec<Request> {
+    fake.requests()
+        .into_iter()
+        .filter(|r| r.path.ends_with(suffix))
+        .collect()
+}
+
+#[test]
+fn the_memory_session_is_named_for_the_boxmaker_session() {
+    assert_eq!(MEMORY_SUFFIX, "_memory");
+    assert_eq!(memory_session(&sid("mm-a")), "mm-a_memory");
+}
+
+#[test]
+fn a_conclusion_goes_into_the_sessions_memory_session() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-conclude");
+    decide(&home, edit("e1", 0), conclude("kyle", "Prefers UTC."));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    let w_path = "/v3/workspaces/boxmaker0-trusted";
+    let seen: Vec<(String, Value)> = fake
+        .requests()
+        .into_iter()
+        .map(|r| (r.path, r.body.unwrap_or(Value::Null)))
+        .collect();
+    assert_eq!(
+        seen,
+        vec![
+            (
+                "/v3/workspaces".to_string(),
+                json!({ "id": "boxmaker0-trusted" })
+            ),
+            (
+                format!("{w_path}/peers"),
+                json!({ "id": "boxmaker0", "configuration": { "observe_me": false } })
+            ),
+            (format!("{w_path}/peers"), json!({ "id": "kyle" })),
+            (
+                format!("{w_path}/sessions"),
+                json!({ "id": "mm-a_memory", "peers": {
+                    "boxmaker0": { "observe_me": false, "observe_others": false },
+                    "kyle": { "observe_me": false, "observe_others": false },
+                } })
+            ),
+            (
+                format!("{w_path}/conclusions"),
+                json!({ "conclusions": [{
+                    "content": "Prefers UTC.",
+                    "observer_id": "kyle",
+                    "observed_id": "kyle",
+                    "session_id": "mm-a_memory",
+                }] })
+            ),
+        ]
+    );
+    assert_eq!(
+        sent_ids(&home, &edit("e1", 0)),
+        Some(vec![CONCLUSION.to_string()])
+    );
+    let sync = home.sync.lock().unwrap();
+    assert_eq!(
+        sync.ledger().conclusion(Workspace::Trusted, "Prefers UTC."),
+        Some((edit("e1", 0), CONCLUSION.to_string()))
+    );
+}
+
+#[test]
+fn a_replace_deletes_then_makes_and_an_undo_reverses_it() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-replace");
+    decide(&home, edit("e1", 0), conclude("kyle", "old"));
+    decide(&home, edit("e2", 0), unconclude("old"));
+    decide(&home, edit("e2", 1), conclude("kyle", "new"));
+    // The owner's undo of e2: the new deleted, the old made again.
+    decide(&home, edit("e3", 0), unconclude("new"));
+    decide(&home, edit("e3", 1), conclude("kyle", "old"));
+    let mut w = home.worker(&fake, FAST);
+    for _ in 0..5 {
+        assert_eq!(w.step(), Step::Done);
+    }
+    assert_eq!(w.step(), Step::Idle);
+    let order: Vec<(String, String)> = fake
+        .requests()
+        .into_iter()
+        .filter(|r| r.path.contains("/conclusions"))
+        .map(|r| {
+            let text = r.body.map_or(String::new(), |b| {
+                b["conclusions"][0]["content"].as_str().unwrap().to_string()
+            });
+            (r.method, text)
+        })
+        .collect();
+    let post = |t: &str| ("POST".to_string(), t.to_string());
+    let delete = ("DELETE".to_string(), String::new());
+    assert_eq!(
+        order,
+        vec![
+            post("old"),
+            delete.clone(),
+            post("new"),
+            delete,
+            post("old")
+        ]
+    );
+    // Each deletion names the id its conclusion got, and records it.
+    let deletes = fake
+        .requests()
+        .into_iter()
+        .filter(|r| r.method == "DELETE")
+        .map(|r| r.path)
+        .collect::<Vec<_>>();
+    let path = format!("/v3/workspaces/boxmaker0-trusted/conclusions/{CONCLUSION}");
+    assert_eq!(deletes, vec![path.clone(), path]);
+    // The memory session, its workspace and peers are made sure of once in this run.
+    assert_eq!(posts(&fake, "/sessions").len(), 1);
+    assert_eq!(posts(&fake, "/peers").len(), 2);
+    assert_eq!(
+        sent_ids(&home, &edit("e2", 0)),
+        Some(vec![CONCLUSION.to_string()])
+    );
+    let sync = home.sync.lock().unwrap();
+    assert_eq!(sync.ledger().conclusion(Workspace::Trusted, "new"), None);
+    assert_eq!(
+        sync.ledger().conclusion(Workspace::Trusted, "old"),
+        Some((edit("e3", 1), CONCLUSION.to_string()))
+    );
+}
+
+#[test]
+fn a_deletion_with_nothing_to_delete_is_sent_with_no_id() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-nothing");
+    decide(&home, edit("e1", 0), unconclude("never made"));
+    // A conclusion that failed is not live either.
+    decide(&home, edit("e2", 0), conclude("kyle", "refused"));
+    decide(&home, edit("e3", 0), unconclude("refused"));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    assert!(fake.requests().is_empty());
+    assert_eq!(sent_ids(&home, &edit("e1", 0)), Some(Vec::new()));
+    fake.set(Mode::Status(422));
+    assert_eq!(w.step(), Step::Done);
+    fake.set(Mode::Fixtures);
+    fake.clear();
+    assert_eq!(w.step(), Step::Done);
+    assert!(fake.requests().is_empty(), "{:?}", fake.requests());
+    assert_eq!(sent_ids(&home, &edit("e3", 0)), Some(Vec::new()));
+    assert_eq!(
+        home.lines().len(),
+        1,
+        "only the refusal: {:?}",
+        home.lines()
+    );
+}
+
+#[test]
+fn a_404_on_delete_is_done() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-404");
+    decide(&home, edit("e1", 0), conclude("kyle", "x"));
+    decide(&home, edit("e2", 0), unconclude("x"));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    fake.set(Mode::Status(404));
+    assert_eq!(w.step(), Step::Done);
+    assert_eq!(
+        sent_ids(&home, &edit("e2", 0)),
+        Some(vec![CONCLUSION.to_string()])
+    );
+    assert!(home.lines().is_empty(), "{:?}", home.lines());
+}
+
+#[test]
+fn an_untrusted_note_is_a_fleet_message_from_the_agent() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-fleet");
+    decide(&home, edit("e1", 0), fleet("The page says 3.2."));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    let seen: Vec<(String, Value)> = fake
+        .requests()
+        .into_iter()
+        .map(|r| (r.path, r.body.unwrap_or(Value::Null)))
+        .collect();
+    assert_eq!(seen.len(), 4);
+    assert_eq!(seen[0].1["configuration"]["reasoning"]["enabled"], false);
+    assert_eq!(seen[2].0, "/v3/workspaces/fleet/sessions");
+    assert_eq!(
+        seen[2].1,
+        json!({ "id": "mm-c", "peers": {
+            "boxmaker0": { "observe_me": false, "observe_others": false },
+        } })
+    );
+    assert_eq!(
+        seen[3],
+        (
+            "/v3/workspaces/fleet/sessions/mm-c/messages".to_string(),
+            json!({ "messages": [{
+                "content": "The page says 3.2.",
+                "peer_id": "boxmaker0",
+                "metadata": { "agent": "boxmaker0", "boxmaker_session": "mm-c", "edit": "e1" },
+            }] })
+        )
+    );
+    assert_eq!(sent_ids(&home, &edit("e1", 0)).map(|i| i.len()), Some(1));
+    // A long note in parts, in one batch.
+    decide(&home, edit("e2", 0), fleet(&"n".repeat(MAX_PART + 1)));
+    assert_eq!(w.step(), Step::Done);
+    let last = posts(&fake, "/messages").pop().unwrap().body.unwrap();
+    assert_eq!(last["messages"].as_array().unwrap().len(), 2);
+}
+
+#[test]
+fn a_note_too_long_for_one_batch_is_marked_failed() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-long");
+    decide(&home, edit("e1", 0), fleet(&"n".repeat(MAX_PART * 100 + 1)));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    assert!(matches!(
+        home.records().last(),
+        Some(Record::Failed { status: None, kind, .. }) if kind == "too-long"
+    ));
+    assert!(fake.requests().is_empty());
+}
+
+#[test]
+fn the_text_is_neutralised() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-neutral");
+    decide(
+        &home,
+        edit("e1", 0),
+        conclude("boxmaker0", &format!("a{}b", TAGS[0].text)),
+    );
+    decide(&home, edit("e2", 0), fleet(&format!("c{}d", TAGS[1].text)));
+    let mut w = home.worker(&fake, FAST);
+    assert_eq!(w.step(), Step::Done);
+    assert_eq!(w.step(), Step::Done);
+    let concluded = posts(&fake, "/conclusions")[0].body.clone().unwrap();
+    let content = concluded["conclusions"][0]["content"].as_str().unwrap();
+    assert!(
+        !content.contains(TAGS[0].text) && content.contains("&lt;"),
+        "{content}"
+    );
+    let message = posts(&fake, "/messages")[0].body.clone().unwrap();
+    let content = message["messages"][0]["content"].as_str().unwrap();
+    assert!(
+        !content.contains(TAGS[1].text) && content.contains("&lt;"),
+        "{content}"
+    );
+}
+
+#[test]
+fn one_outbox_in_order_across_turns_and_edits() {
+    let fake = FakeHoncho::start();
+    let mut home = Home::new("edits-order");
+    home.log(
+        "mm-a",
+        &[
+            vec![spoken("one", Some("kyle")), assistant(2, Some("a"), &[])],
+            vec![spoken("two", Some("kyle")), assistant(2, Some("b"), &[])],
+        ],
+    );
+    home.report("mm-a", 1);
+    decide(&home, edit("e1", 0), conclude("kyle", "Prefers UTC."));
+    home.report("mm-a", 2);
+    let mut w = home.worker(&fake, FAST);
+    for _ in 0..3 {
+        assert_eq!(w.step(), Step::Done);
+    }
+    let order: Vec<String> = fake
+        .requests()
+        .into_iter()
+        .filter(|r| r.path.ends_with("/messages") || r.path.ends_with("/conclusions"))
+        .map(|r| r.path)
+        .collect();
+    assert_eq!(
+        order,
+        vec![
+            "/v3/workspaces/boxmaker0-trusted/sessions/mm-a/messages".to_string(),
+            "/v3/workspaces/boxmaker0-trusted/conclusions".to_string(),
+            "/v3/workspaces/boxmaker0-trusted/sessions/mm-a/messages".to_string(),
+        ]
+    );
+    // A restart sends nothing again.
+    home.restart();
+    let fake2 = FakeHoncho::start();
+    let mut w = home.worker(&fake2, FAST);
+    assert_eq!(w.step(), Step::Idle);
+    assert!(fake2.requests().is_empty());
+}
+
+#[test]
+fn errors_as_for_turns() {
+    let fake = FakeHoncho::start();
+    let home = Home::new("edits-errors");
+    decide(&home, edit("e1", 0), conclude("kyle", "private-fact"));
+    decide(&home, edit("e2", 0), fleet("private-note"));
+    decide(&home, edit("e3", 0), conclude("kyle", "second"));
+    let mut w = home.worker(&fake, FAST);
+    fake.set(Mode::Status(503));
+    assert!(matches!(w.step(), Step::Backoff(_)));
+    fake.set(Mode::Status(422));
+    assert_eq!(w.step(), Step::Done);
+    assert!(matches!(
+        home.records().last(),
+        Some(Record::Failed { status: Some(422), kind, .. }) if kind == "status"
+    ));
+    fake.set(Mode::Status(401));
+    assert_eq!(w.step(), Step::Done, "the fleet's key refused");
+    fake.set(Mode::Fixtures);
+    assert_eq!(w.step(), Step::Done, "the trusted workspace goes on");
+    assert!(sent_ids(&home, &edit("e3", 0)).is_some());
+    assert_eq!(w.step(), Step::Idle, "the fleet note waits");
+    let lines = home.lines();
+    assert_eq!(lines.len(), 4, "{lines:?}");
+    assert!(
+        lines[2].starts_with("memoryd: part 0 of edit e1 was not sent: "),
+        "{lines:?}"
+    );
+    assert!(lines[3].contains("workspace fleet"), "{lines:?}");
+    for line in lines {
+        assert!(!line.contains("private"), "{line}");
+    }
+}
@@ -1,9 +1,9 @@
 //! The Honcho worker's other duties (M5c spec, section 5): with nothing to send it decides what
 //! `brokerd` could not answer for; after a restart nothing is sent again, and a session with a
 //! decided turn waits again (a session without one does not); a running turn is never decided;
-//! actions of later tasks wait; a ledger that cannot be written stops it; no log line holds a
-//! turn's text. Then `memoryd` itself: a reported turn reaches Honcho, woken at once, and a key
-//! that cannot be read stops the start. Do not edit.
+//! a retraction waits (nothing decides one); a ledger that cannot be written stops it; no log
+//! line holds a turn's text. Then `memoryd` itself: a reported turn reaches Honcho, woken at
+//! once, and a key that cannot be read stops the start. Do not edit.

 #[path = "support/brokerd.rs"]
 mod brokerd;
@@ -150,15 +150,17 @@ fn a_restart_never_decides_a_running_turn() {
 }

 #[test]
-fn actions_of_later_tasks_wait() {
+fn a_retraction_waits() {
+    // Nothing decides a retraction any more (M5c spec, section 4, 2026-09-28): one in the
+    // ledger is neither sent nor failed.
    let fake = FakeHoncho::start();
    let mut home = Home::new("worker-later");
-    let conclude = r#"{"type":"decided","time":"2026-09-28T10:00:00.000Z","item":{"type":"edit","id":"2026-09-28-0001","part":0},"action":{"type":"conclude","workspace":"trusted","peer":"kyle","session":"mm-a","text":"a fact"}}"#;
-    std::fs::write(home.ledger_path(), format!("{conclude}\n")).unwrap();
+    let retract = r#"{"type":"decided","time":"2026-09-28T10:00:00.000Z","item":{"type":"edit","id":"2026-09-28-0001","part":0},"action":{"type":"retract","session":"mm-a","text":"a note"}}"#;
+    std::fs::write(home.ledger_path(), format!("{retract}\n")).unwrap();
    home.restart();
    let mut w = home.worker(&fake, FAST);
    assert_eq!(w.step(), Step::Idle);
-    assert_eq!(home.records().len(), 1, "the conclusion was failed or sent");
+    assert_eq!(home.records().len(), 1, "the retraction was failed or sent");
    assert!(fake.requests().is_empty());
 }

@@ -1,6 +1,7 @@
 //! A fake Honcho for tests, on 127.0.0.1 and a port of its own: it answers each request from the
-//! responses recorded from rift (`tests/fixtures/honcho/`), by method and path, and records every
-//! request, body included. It can be set to answer every request with a status instead, or to
+//! responses recorded from rift (`tests/fixtures/honcho/`), by method and path (a batch of
+//! messages or conclusions answered with as many as it asked for, up to the two recorded), and
+//! records every request, body included. It can be set to answer every request with a status instead, or to
 //! answer nothing. Stopped, and its held connections released, when dropped; every wait has a
 //! deadline. Do not edit.

@@ -214,8 +215,13 @@ fn answer(request: &Request, made: &Mutex<HashSet<String>>) -> (u16, String) {
        }
        ("POST", ["v3", "workspaces", _, "sessions"]) => fixture("06-session-create.json"),
        ("POST", ["v3", "workspaces", _, "sessions", _, "messages"]) => {
-            fixture("08-messages-add-batch.json")
+            first(fixture("08-messages-add-batch.json"), request, "messages")
        }
+        ("POST", ["v3", "workspaces", _, "conclusions"]) => first(
+            fixture("11-conclusions-create-batch.json"),
+            request,
+            "conclusions",
+        ),
        ("DELETE", ["v3", "workspaces", _, "conclusions", _]) if again => {
            fixture("16-conclusion-delete-again.json")
        }
@@ -226,6 +232,19 @@ fn answer(request: &Request, made: &Mutex<HashSet<String>>) -> (u16, String) {
    }
 }

+/// A recorded batch answer cut to as many items as the request's `field` holds (the recorded ones
+/// hold two), so that one message or conclusion gets one id.
+fn first(recorded: (u16, String), request: &Request, field: &str) -> (u16, String) {
+    let asked = request
+        .body
+        .as_ref()
+        .and_then(|b| b[field].as_array())
+        .map_or(0, Vec::len);
+    let mut items: Vec<Value> = serde_json::from_str(&recorded.1).unwrap();
+    items.truncate(asked);
+    (recorded.0, Value::Array(items).to_string())
+}
+
 fn serve(mut stream: TcpStream, shared: &Shared) {
    let _ = stream.set_read_timeout(Some(Duration::from_secs(10)));
    let Some(request) = read_request(&mut stream) else {