Plan M5a: local memory in 15 tasks

memoryd (files, the check, edits, journal, index, recall, serving),
the memory tools and built-in grants in brokerd, the memory block in
loopd, bxctl reindex and memory, and the device checks with memoryd.

Each task was built as a reference and gated. Each was replayed on its
own at its end state (854 to 936 tests) and mutation-checked. Each
skeleton compiles and fails its tests. Every todo comment was read
beside its signature.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

docs/plans/M5a/files/crates/brokerd/src/builtin.rs

@@ -0,0 +1,26 @@
+//! The built-in grants of `recall` and `memory` (M5a spec, section 8). Reading and writing memory
+//! is what an agent is, so no grant file can turn it off or put questions in front of it; the
+//! prompt is protected by `memoryd`, which lets only clean sessions edit identity.
+
+use proto::{Grant, GrantProblem, sha256};
+
+use crate::grants::LoadedGrant;
+
+/// Ids starting with this are the built-ins'; an owner's grant file may not use one.
+pub const RESERVED: &str = "builtin-";
+
+/// The built-in grants' text, hashed for the audit log like a grant file's bytes.
+pub const RECALL: &str = "tool = \"recall\"\nmode = \"auto\"\nmax_taint = \"secret\"\nresult_class = \"private\"\nuntrusted = false\n";
+pub const MEMORY: &str = "tool = \"memory\"\nmode = \"auto\"\nmax_taint = \"secret\"\nresult_class = \"private\"\nuntrusted = false\n";
+
+/// The sentence for an owner's grant naming a memory tool.
+pub const BUILT_IN: &str = "the policy of recall and memory is built in; remove this grant";
+
+/// The two built-in grants, `builtin-memory` and `builtin-recall`.
+pub fn grants() -> Result<Vec<LoadedGrant>, GrantProblem> {
+    // For each (id, text) of [("builtin-memory", MEMORY), ("builtin-recall", RECALL)]:
+    // `toml::from_str::<Grant>(text)` and `sha256(text.as_bytes())`, each error as a GrantProblem {
+    // file: id, line: None, problem: e.to_string() }; build LoadedGrant { id, grant, sha256 }.
+    // Collect into Result<Vec<LoadedGrant>, GrantProblem> (the first error wins).
+    todo!()
+}

docs/plans/M5a/files/crates/brokerd/src/memory_port.rs

@@ -0,0 +1,76 @@
+//! Where decided `recall` and `memory` calls go: to `memoryd` over its `brokerd` socket, with the
+//! session's state, instead of a container (M5a spec, section 8). `Routed` sends every other call
+//! to the configured runtime.
+
+use std::os::unix::net::UnixStream;
+use std::path::PathBuf;
+use std::time::Duration;
+
+use proto::{
+    Envelope, MemoryCall, Message, PROTOCOL_VERSION, ToolRequest, ToolResponse, read_frame,
+    write_frame,
+};
+
+use crate::policy::Label;
+use crate::runner::{RunError, RunOutput, RunSpec, Runtime};
+
+/// The sentence when `memoryd` cannot be reached or answers wrongly: fixed, it reaches the model.
+pub const UNREACHABLE: &str =
+    "memory is unavailable: memoryd did not answer (see docs/runbook.md#memoryd-unreachable)";
+
+/// How long `brokerd` waits for `memoryd` to answer one call.
+pub const MEMORY_WAIT: Duration = Duration::from_secs(30);
+
+/// A client of `memoryd`'s `brokerd` socket. One connection per call.
+pub struct MemoryPort {
+    socket: PathBuf,
+    wait: Duration,
+}
+
+impl MemoryPort {
+    pub fn new(socket: PathBuf, wait: Duration) -> MemoryPort {
+        MemoryPort { socket, wait }
+    }
+
+    fn ask(&self, spec: &RunSpec) -> Option<ToolResponse> {
+        // `None` at the first thing that fails. 1. A MemoryCall: request with the spec's session,
+        // call, `spec.tool().as_str()`, and `spec.arguments().canonical_json()`; taint and
+        // untrusted from `spec.state()`. 2. `UnixStream::connect(&self.socket)`, then read and
+        // write timeouts of `self.wait`. 3. `write_frame` an Envelope { v: PROTOCOL_VERSION, id:
+        // spec.call().0, final: true, msg: Message::MemoryCall(call) }. 4. `read_frame`; a
+        // Message::ToolResponse is Some(it), any other message None.
+        todo!()
+    }
+}
+
+impl Runtime for MemoryPort {
+    fn run(&self, spec: &RunSpec) -> Result<RunOutput, RunError> {
+        self.run_labelled(spec).map(|(output, _)| output)
+    }
+
+    fn run_labelled(&self, spec: &RunSpec) -> Result<(RunOutput, Option<Label>), RunError> {
+        // `self.ask(spec)`: Some(Result { content, class, untrusted, truncated }) -> Ok((RunOutput
+        // { content, truncated }, Some(Label { class, untrusted }))); Some(Failed { message }) ->
+        // Err(RunError::Failed(message)); anything else, None included ->
+        // Err(RunError::Unavailable(UNREACHABLE.to_string())).
+        todo!()
+    }
+}
+
+/// The memory tools to `memoryd`, everything else to `other`.
+pub struct Routed {
+    pub memory: MemoryPort,
+    pub other: Box<dyn Runtime>,
+}
+
+impl Runtime for Routed {
+    fn run(&self, spec: &RunSpec) -> Result<RunOutput, RunError> {
+        self.run_labelled(spec).map(|(output, _)| output)
+    }
+
+    fn run_labelled(&self, spec: &RunSpec) -> Result<(RunOutput, Option<Label>), RunError> {
+        // `spec.tool().is_memory()` -> `self.memory.run_labelled(spec)`; otherwise
+        // `self.other.run_labelled(spec)`.
+        todo!()
+    }
+}