Move session persistence into the Agent; collapse CLI plumbing

The Agent now owns its Conversation and a SessionStore, and persists
everything it generates as turns progress. Embedders get persistence for
free; the CLI no longer drives the session log.

libpanto:
- Agent.init takes a SessionStore + optional Conversation to adopt (resume
  path). Agent owns/tears down the conversation; turn-driving methods drop
  the *Conversation param and operate on self.conversation.
- New Agent methods: submitUserMessage (adds+persists the user prompt
  immediately), addSystemMessage(text, mode), runStep persists the turn on
  every exit path (incl. partial turns on error), compactAndPersist for the
  explicit /compact path. Auto-compaction persists its window via runStep's
  tail.
- turn_persist.zig: DiskMessage mapping moved out of the CLI; reads usage
  off Message.usage (no per-message-usage list). System mode rides on
  DiskMessage.mode, derived from the System block.
- NullStore is now an allocator-bearing struct (frees consumed messages per
  the store-consumes-messages contract).
- Tests: in-memory CapturingStore round-trip + NullStore turn test.

panto CLI:
- Delete src/session_persist.zig. REPL is submitUserMessage + runStep.
- Reorder construction: store -> registry -> agent -> bootstrap -> seed/
  reconcile system prompt through the agent -> load extensions.
- command.Context drops conv/session_mgr; commands reach ctx.agent.
- system_prompt seed/reconcile call agent.addSystemMessage.
- CLIReceiver is display-only (per_message_usage removed).

Phases 3-5 of docs/pluggable-session-store.md. Behavior preserved; full
build + test suite green.

1 files changed, 0 insertions, 153 deletions

diff --git a/src/session_persist.zig b/src/session_persist.zig
deleted file mode 100644
index d5349bc..0000000
--- a/src/session_persist.zig
+++ /dev/null
@@ -1,153 +0,0 @@
-//! Session-log persistence helpers shared between the REPL loop
-//! (`main.zig`) and slash-command handlers (e.g. `compaction.zig`).
-//!
-//! These were previously private to `main.zig`. They were lifted into
-//! their own module so that command handlers living outside the root
-//! source file can reuse them without depending on `main.zig` (which,
-//! being the executable root, can't be imported as a normal module).
-
-const std = @import("std");
-const panto = @import("panto");
-
-/// Append a single user-prompt message to the session log.
-pub fn appendUserPromptToSession(
-    alloc: std.mem.Allocator,
-    mgr: *panto.session_manager.SessionManager,
-    text: []const u8,
-    provider: []const u8,
-    model: []const u8,
-) !void {
-    const blocks = try alloc.alloc(panto.session_manager.DiskContentBlock, 1);
-    blocks[0] = .{ .text = .{ .text = try alloc.dupe(u8, text) } };
-    _ = try mgr.appendMessage(
-        .{ .role = .user, .content = blocks },
-        provider,
-        model,
-    );
-}
-
-/// After the agent loop has driven a turn to completion, persist every
-/// new in-memory message at index `>= start_index` to the session log.
-///
-/// Each in-memory message is mapped to disk:
-///   - assistant → assistant entry with provider/model/stop_reason metadata
-///     and Usage (from `per_message_usage`, one slot per assistant message in
-///     completion order).
-///   - user (with ToolResult blocks) → user entry stamped with provider/model.
-///
-/// `stop_reason` is recorded as `"stop"` for now; surfacing the real wire
-/// value requires plumbing it through the Receiver vtable (future work,
-/// separate from token plumbing).
-pub fn persistTurn(
-    alloc: std.mem.Allocator,
-    mgr: *panto.session_manager.SessionManager,
-    conv: *const panto.conversation.Conversation,
-    start_index: usize,
-    provider: []const u8,
-    model: []const u8,
-    per_message_usage: []const ?panto.session_manager.Usage,
-) !void {
-    var batch_messages: std.ArrayList(panto.session_manager.DiskMessage) = .empty;
-    defer batch_messages.deinit(alloc);
-    var batch_providers: std.ArrayList(?[]const u8) = .empty;
-    defer batch_providers.deinit(alloc);
-    var batch_models: std.ArrayList(?[]const u8) = .empty;
-    defer batch_models.deinit(alloc);
-
-    var i = start_index;
-    var assistant_seen: usize = 0;
-    while (i < conv.messages.items.len) : (i += 1) {
-        const msg = conv.messages.items[i];
-        const blocks = try alloc.alloc(panto.session_manager.DiskContentBlock, msg.content.items.len);
-        var allocated: usize = 0;
-        errdefer {
-            for (blocks[0..allocated]) |b| b.deinit(alloc);
-            alloc.free(blocks);
-        }
-        for (msg.content.items) |block| {
-            blocks[allocated] = try panto.session.contentBlockToDisk(alloc, block);
-            allocated += 1;
-        }
-        if (msg.role == .assistant and hasToolUseWithoutFollowingResults(conv, i)) {
-            for (blocks[0..allocated]) |b| b.deinit(alloc);
-            alloc.free(blocks);
-            continue;
-        }
-        switch (msg.role) {
-            .system => {
-                // Mid-turn system messages aren't a thing in pantograph today.
-                // Treat as harmless and persist verbatim, sans stamps.
-                try batch_messages.append(alloc, .{ .role = .system, .content = blocks });
-                try batch_providers.append(alloc, null);
-                try batch_models.append(alloc, null);
-            },
-            .user => {
-                try batch_messages.append(alloc, .{ .role = .user, .content = blocks });
-                try batch_providers.append(alloc, provider);
-                try batch_models.append(alloc, model);
-            },
-            .assistant => {
-                // Pair this assistant message with its usage, if the
-                // receiver captured one for this position. (A turn
-                // ending in a stream error can have fewer usage entries
-                // than assistant messages; treat as null and move on.)
-                const usage: ?panto.session_manager.Usage = if (assistant_seen < per_message_usage.len)
-                    per_message_usage[assistant_seen]
-                else
-                    null;
-                assistant_seen += 1;
-                try batch_messages.append(alloc, .{
-                    .role = .assistant,
-                    .content = blocks,
-                    .provider = try alloc.dupe(u8, provider),
-                    .model = try alloc.dupe(u8, model),
-                    .stop_reason = try alloc.dupe(u8, "stop"),
-                    .usage = usage,
-                });
-                try batch_providers.append(alloc, null);
-                try batch_models.append(alloc, null);
-            },
-        }
-    }
-    try mgr.appendMessagesAtomic(batch_messages.items, batch_providers.items, batch_models.items);
-}
-
-/// Persist a compaction to the session log. The agent rewrote the
-/// in-memory conversation to `[system..., summary, kept-suffix...]`; the
-/// superseded prefix stays on disk untouched. We append everything from
-/// the compaction summary onward as fresh entries: the summary message
-/// (carrying the `compactionSummary` block) followed by the duplicated
-/// kept-verbatim suffix. On replay, the latest summary resets effective
-/// context, so the duplicated suffix is what survives.
-///
-/// Usage is not threaded through here: the duplicated entries are replays
-/// of already-sized turns, and the summary itself isn't an assistant turn.
-pub fn persistCompaction(
-    alloc: std.mem.Allocator,
-    mgr: *panto.session_manager.SessionManager,
-    conv: *const panto.conversation.Conversation,
-    provider: []const u8,
-    model: []const u8,
-) !void {
-    const start = panto.conversation.latestCompactionIndex(conv.messages.items) orelse return;
-    try persistTurn(alloc, mgr, conv, start, provider, model, &.{});
-}
-
-pub fn hasToolUseWithoutFollowingResults(conv: *const panto.conversation.Conversation, index: usize) bool {
-    const msg = conv.messages.items[index];
-    for (msg.content.items) |block| {
-        if (block != .ToolUse) continue;
-        if (index + 1 >= conv.messages.items.len) return true;
-        const next = conv.messages.items[index + 1];
-        if (next.role != .user) return true;
-        var found = false;
-        for (next.content.items) |next_block| {
-            if (next_block == .ToolResult and std.mem.eql(u8, next_block.ToolResult.tool_use_id, block.ToolUse.id)) {
-                found = true;
-                break;
-            }
-        }
-        if (!found) return true;
-    }
-    return false;
-}