proto: memory, the arguments of recall and memory and eight message kinds

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)
2026-09-25 16:41:35 -07:00
parent 861ff7d06a
commit 964bd99b12
15 changed files with 616 additions and 1 deletions
@@ -0,0 +1,113 @@
+//! The eight memory messages against byte-exact fixtures, each refusing an unknown key (M5a spec,
+//! section 7). Do not edit these or the fixtures.
+
+use proto::{
+    CallId, DataClass, Empty, Envelope, MemoryAdmin, MemoryAdminReply, MemoryBlockReply,
+    MemoryCall, MemoryCommand, Message, Reindexed, SessionId, SessionUpdated, ToolRequest,
+};
+
+const SESSION: &str = "mm-r0000000000000000000000001";
+
+fn fixture(name: &str) -> String {
+    let path = format!("{}/tests/fixtures/wire/{name}", env!("CARGO_MANIFEST_DIR"));
+    let text = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("{path}: {e}"));
+    text.trim_end_matches('\n').to_string()
+}
+
+/// The fixture must decode to `msg`, `msg` must encode to exactly the fixture's bytes, and the
+/// body must refuse an extra key.
+fn check(name: &str, id: u64, msg: Message) {
+    let want = Envelope {
+        v: 1,
+        id,
+        r#final: true,
+        msg,
+    };
+    let text = fixture(name);
+    let got: Envelope = serde_json::from_str(&text).unwrap_or_else(|e| panic!("{name}: {e}"));
+    assert_eq!(got, want, "{name}: decoded value");
+    assert_eq!(
+        serde_json::to_string(&want).unwrap(),
+        text,
+        "{name}: encoded bytes"
+    );
+    let extra = text.replacen("\"body\":{", "\"body\":{\"extra\":1,", 1);
+    assert!(
+        serde_json::from_str::<Envelope>(&extra).is_err(),
+        "{name}: an unknown key is refused"
+    );
+}
+
+#[test]
+fn the_eight_messages() {
+    check("memory_block.json", 1, Message::MemoryBlock(Empty {}));
+    check(
+        "memory_block_reply.json",
+        1,
+        Message::MemoryBlockReply(MemoryBlockReply {
+            text: "# soul.md\nYou are Boxmaker.\n\n# memory.md (0 of 2,200 characters)\n(empty)\n\n# user.md (0 of 1,375 characters)\n(empty)".to_string(),
+        }),
+    );
+    check(
+        "session_updated.json",
+        1,
+        Message::SessionUpdated(SessionUpdated {
+            session: SessionId::new(SESSION).unwrap(),
+        }),
+    );
+    check(
+        "memory_call.json",
+        3,
+        Message::MemoryCall(MemoryCall {
+            request: ToolRequest {
+                session: SessionId::new(SESSION).unwrap(),
+                call: CallId(3),
+                tool: "memory".to_string(),
+                arguments: r#"{"action":"note","text":"example.org says March."}"#.to_string(),
+            },
+            taint: DataClass::Private,
+            untrusted: true,
+        }),
+    );
+    check("reindex.json", 1, Message::Reindex(Empty {}));
+    check(
+        "reindexed.json",
+        1,
+        Message::Reindexed(Reindexed {
+            logs: 42,
+            records: 1208,
+            notes: 7,
+        }),
+    );
+    check(
+        "memory_admin.json",
+        1,
+        Message::MemoryAdmin(MemoryAdmin {
+            command: MemoryCommand::Undo,
+            arg: "2026-09-24-0007".to_string(),
+        }),
+    );
+    check(
+        "memory_admin_reply.json",
+        1,
+        Message::MemoryAdminReply(MemoryAdminReply {
+            text: "undone: 2026-09-24-0007".to_string(),
+        }),
+    );
+}
+
+#[test]
+fn every_command_has_its_name() {
+    for (command, name) in [
+        (MemoryCommand::Log, "log"),
+        (MemoryCommand::Undo, "undo"),
+        (MemoryCommand::Pending, "pending"),
+        (MemoryCommand::Accept, "accept"),
+        (MemoryCommand::Reject, "reject"),
+    ] {
+        assert_eq!(
+            serde_json::to_string(&command).unwrap(),
+            format!("\"{name}\"")
+        );
+    }
+}