keybinding fixes

1 files changed, 580 insertions, 48 deletions

diff --git a/src/tui_app.zig b/src/tui_app.zig
index 788595a..a9d9a42 100644
--- a/src/tui_app.zig
+++ b/src/tui_app.zig
@@ -28,17 +28,28 @@
 //! (`firstLineChanged` near the tail via the render cache + the line-diff
 //! backstop) repaints only the dirty tail. stdout is never written directly.
 //!
-//! ## Thinking / tool deltas in P1 (deferred display, non-crashing)
+//! ## Thinking / tool / compaction display (P2)
 //!
-//! P1's minimal component set is user/assistant/input/footer. There is no
-//! dedicated thinking or collapsible tool-use component yet (P2). To avoid
-//! crashing on those blocks while keeping the loop honest:
-//!   - a Thinking block streams its deltas into a DIM status line (one
-//!     `AssistantText`-style component styled dim), and
-//!   - a ToolUse block renders a single dim `tool: <name>` status line
-//!     (name resolved at `tool_details` / `block_complete`).
-//! The full thinking component and the collapsible tool-use component are
-//! deferred to P2; this is the documented minimal stand-in.
+//! The full built-in component set is wired here:
+//!   - a Thinking block streams its deltas into a dedicated dim `Thinking`
+//!     component,
+//!   - a ToolUse block drives a `ToolUse` component (one per call) through its
+//!     `tool (?)…` -> `tool (<name>) <input json>` -> `+ <output>` progression;
+//!     the component is collapsible via a GLOBAL ctrl+o toggle (default
+//!     collapsed, showing the last 5 output lines),
+//!   - a CompactionSummary block (or a compaction provider-retry) renders a
+//!     `CompactionSummary` component.
+//!
+//! ## Tool-result correlation (no "active component")
+//!
+//! ToolResult blocks do NOT arrive via `block_start`/`block_complete`; the
+//! agent assembles them and delivers them together in the
+//! `tool_dispatch_complete` event's user `Message`. Each `ToolResultBlock`
+//! carries a `tool_use_id` linking back to its `ToolUseBlock.id`. The router
+//! therefore keeps a SECOND map, tool-call id -> *ToolUse component, populated
+//! when the tool name/id resolve; on `tool_dispatch_complete` we walk the
+//! result blocks and feed each one's text to the matching component by id.
+//! Nothing is keyed by a single "current" component (plan §6 invariant).
 
 const std = @import("std");
 const posix = std.posix;
@@ -60,6 +71,10 @@ const AssistantText = components.AssistantText;
 const UserText = components.UserText;
 const InputBox = components.InputBox;
 const Footer = components.Footer;
+const Welcome = components.Welcome;
+const Thinking = components.Thinking;
+const CompactionSummary = components.CompactionSummary;
+const ToolUse = components.ToolUse;
 const Component = component.Component;
 
 const Event = panto.Event;
@@ -103,20 +118,47 @@ const Entry = union(enum) {
     user: *UserText,
     /// Assistant message body (streaming text block).
     assistant: *AssistantText,
-    /// A dim status/thinking/tool/retry line (minimal P1 stand-in; not a full
-    /// component — see module docs).
+    /// A dim status/retry line (provider retries, command output, errors).
     status: *AssistantText,
+    /// Session-start banner.
+    welcome: *Welcome,
+    /// Streaming thinking block (dim).
+    thinking: *Thinking,
+    /// A tool call + result (collapsible).
+    tool: *ToolUse,
+    /// A compaction summary.
+    compaction: *CompactionSummary,
 
     fn comp(self: Entry) Component {
         return switch (self) {
             .user => |p| p.comp(),
             .assistant => |p| p.comp(),
             .status => |p| p.comp(),
+            .welcome => |p| p.comp(),
+            .thinking => |p| p.comp(),
+            .tool => |p| p.comp(),
+            .compaction => |p| p.comp(),
         };
     }
 
     fn deinit(self: Entry, alloc: std.mem.Allocator) void {
         switch (self) {
+            .welcome => |p| {
+                p.deinit();
+                alloc.destroy(p);
+            },
+            .thinking => |p| {
+                p.deinit();
+                alloc.destroy(p);
+            },
+            .tool => |p| {
+                p.deinit();
+                alloc.destroy(p);
+            },
+            .compaction => |p| {
+                p.deinit();
+                alloc.destroy(p);
+            },
             .user => |p| {
                 p.deinit();
                 alloc.destroy(p);
@@ -154,6 +196,11 @@ pub const App = struct {
     /// Per-turn block routing. Cleared at each turn boundary.
     router: TurnRouter,
 
+    /// Global tool-use collapse state (ctrl+o). Applies to EVERY tool-use
+    /// component at once (plan: collapse is a global toggle). Default true:
+    /// tool output starts collapsed to its last few lines.
+    tools_collapsed: bool = true,
+
     /// Optional sink flusher. The real terminal's engine writer is a buffered
     /// file writer that must be flushed after each frame for output to reach
     /// the tty; tests inject an in-memory writer and leave this null.
@@ -179,6 +226,7 @@ pub const App = struct {
             .input_box = input_box,
             .footer = footer,
             .router = TurnRouter.init(alloc),
+            .tools_collapsed = true,
         };
     }
 
@@ -263,6 +311,53 @@ pub const App = struct {
         try self.pushEntry(.{ .user = box });
     }
 
+    /// Spawn the session-start welcome banner. Returns it so the caller can set
+    /// its fields (version / cwd / model).
+    fn spawnWelcome(self: *App) !*Welcome {
+        const box = try self.alloc.create(Welcome);
+        box.* = Welcome.init(self.alloc);
+        try self.pushEntry(.{ .welcome = box });
+        return box;
+    }
+
+    /// Spawn a streaming thinking entry. Keyed by block index in the router.
+    fn spawnThinking(self: *App) !*Thinking {
+        const box = try self.alloc.create(Thinking);
+        box.* = Thinking.init(self.alloc);
+        try self.pushEntry(.{ .thinking = box });
+        return box;
+    }
+
+    /// Spawn a tool-use entry. Inherits the app's current global collapse state
+    /// so a tool opened while everything is collapsed starts collapsed too.
+    fn spawnTool(self: *App) !*ToolUse {
+        const box = try self.alloc.create(ToolUse);
+        box.* = ToolUse.init(self.alloc);
+        box.setCollapsed(self.tools_collapsed);
+        try self.pushEntry(.{ .tool = box });
+        return box;
+    }
+
+    /// Spawn a compaction-summary entry seeded with `summary`.
+    fn spawnCompaction(self: *App, summary: []const u8) !*CompactionSummary {
+        const box = try self.alloc.create(CompactionSummary);
+        box.* = CompactionSummary.init(self.alloc);
+        try box.setSummary(summary);
+        try self.pushEntry(.{ .compaction = box });
+        return box;
+    }
+
+    /// Toggle the global tool-use collapse state (ctrl+o) and apply it to every
+    /// tool-use component in the transcript. No "active component": we iterate
+    /// the whole list and flip each one. Requests a render.
+    pub fn toggleToolCollapse(self: *App) void {
+        self.tools_collapsed = !self.tools_collapsed;
+        for (self.transcript.items) |e| {
+            if (e == .tool) e.tool.setCollapsed(self.tools_collapsed);
+        }
+        self.scheduler.requestRender();
+    }
+
     // -- the render pump ----------------------------------------------------
 
     /// Render a frame if one is pending, feeding the footer the measured
@@ -312,15 +407,13 @@ pub const App = struct {
                         try self.router.put(b.index, .{ .assistant = box });
                     },
                     .Thinking => {
-                        // Minimal P1 stand-in: a dim streaming status line.
-                        const box = try self.spawnStatus("[thinking] ");
+                        const box = try self.spawnThinking();
                         try self.router.put(b.index, .{ .thinking = box });
                     },
                     .ToolUse => {
-                        // Minimal P1 stand-in: a dim one-line tool status. The
-                        // name is unknown at start (streamed); fill it in at
-                        // tool_details / block_complete.
-                        const box = try self.spawnStatus("tool: …");
+                        // The name is unknown at start (streamed); the component
+                        // renders `tool (?)…` until `tool_details` resolves it.
+                        const box = try self.spawnTool();
                         try self.router.put(b.index, .{ .tool = box });
                     },
                     .ToolResult => {},
@@ -330,10 +423,11 @@ pub const App = struct {
             .tool_details => |d| {
                 if (self.router.get(d.index)) |ref| switch (ref) {
                     .tool => |box| {
-                        const dim = theme.default.fg(.dim);
-                        const line = try std.fmt.allocPrint(self.alloc, "{s}tool: {s}{s}", .{ dim.open(), d.name, dim.close() });
-                        defer self.alloc.free(line);
-                        try box.setText(line);
+                        try box.setName(d.name);
+                        // Register the id -> component mapping so a later
+                        // ToolResult (out-of-band, keyed by tool_use_id) finds
+                        // this exact component.
+                        try self.router.putToolId(d.id, box);
                         self.scheduler.requestRender();
                     },
                     else => {},
@@ -346,15 +440,15 @@ pub const App = struct {
                         self.scheduler.requestRender();
                     },
                     .thinking => |box| {
-                        // Append thinking deltas (still dim — the seed kept the
-                        // dim run open; we append raw text, which renders plain
-                        // assistant style. Acceptable P1 stand-in).
                         try box.appendDelta(d.delta);
                         self.scheduler.requestRender();
                     },
-                    // Tool args stream as deltas too; P1 doesn't display the
-                    // streamed JSON args (deferred to the P2 tool component).
-                    .tool => {},
+                    .tool => |box| {
+                        // Tool args stream as deltas — they ARE the verbatim
+                        // JSON input. Accumulate them into the component.
+                        try box.appendInput(d.delta);
+                        self.scheduler.requestRender();
+                    },
                 };
             },
             .block_complete => |b| {
@@ -362,22 +456,37 @@ pub const App = struct {
                     .ToolUse => |tu| {
                         if (self.router.get(b.index)) |ref| switch (ref) {
                             .tool => |box| {
-                                const dim = theme.default.fg(.dim);
-                                const line = try std.fmt.allocPrint(self.alloc, "{s}tool: {s}{s}", .{ dim.open(), tu.name, dim.close() });
-                                defer self.alloc.free(line);
-                                try box.setText(line);
+                                // Final authoritative name + input from the
+                                // completed block (covers the case where
+                                // tool_details never fired and replaces any
+                                // partial streamed args with the final bytes).
+                                try box.setName(tu.name);
+                                try box.setInput(tu.input.items);
+                                try self.router.putToolId(tu.id, box);
                                 self.scheduler.requestRender();
                             },
                             else => {},
                         };
                     },
+                    .CompactionSummary => |cs| {
+                        _ = try self.spawnCompaction(cs.text.items);
+                        self.scheduler.requestRender();
+                    },
                     else => {},
                 }
             },
-            .message_complete => {},
+            .message_complete => |mc| {
+                // Update the footer's context-window token count with the
+                // LATEST usage (plan §6): input + cache_read + cache_write
+                // (output/reasoning excluded — not "in the window"). Latest
+                // value wins; not accumulated.
+                if (mc.usage) |u| {
+                    const ctx = u.input + u.cache_read + u.cache_write;
+                    self.footer.setContextTokens(ctx);
+                    self.scheduler.requestRender();
+                }
+            },
             .provider_retry => |info| {
-                // Preserve the existing dim retry messaging meaning as a status
-                // line in the transcript.
                 if (info.compaction) {
                     _ = try self.spawnStatus("context overflow: compacting and retrying");
                 } else {
@@ -392,8 +501,37 @@ pub const App = struct {
                 }
                 self.scheduler.requestRender();
             },
-            .tool_dispatch_start, .tool_dispatch_complete, .turn_complete => {},
+            .tool_dispatch_complete => |info| {
+                // ToolResult blocks are delivered together here as the content
+                // of the appended user message. Correlate each back to its
+                // ToolUse component by tool_use_id and feed it the result text.
+                try self.routeToolResults(info.message);
+            },
+            .tool_dispatch_start, .turn_complete => {},
+        }
+    }
+
+    /// Walk a tool-dispatch-complete user message and feed each `ToolResult`
+    /// block's text to the `ToolUse` component that issued the matching call
+    /// (looked up by `tool_use_id`). Honors the no-active-component invariant:
+    /// the correlation is purely by id.
+    fn routeToolResults(self: *App, message: panto.Message) !void {
+        var any = false;
+        for (message.content.items) |block| {
+            switch (block) {
+                .ToolResult => |tr| {
+                    const box = self.router.getToolById(tr.tool_use_id) orelse continue;
+                    // Concatenate the textual parts of the result.
+                    var text: std.ArrayList(u8) = .empty;
+                    defer text.deinit(self.alloc);
+                    try tr.appendTextInto(self.alloc, &text);
+                    try box.setOutput(text.items);
+                    any = true;
+                },
+                else => {},
+            }
         }
+        if (any) self.scheduler.requestRender();
     }
 
     /// Reset per-turn routing state. The transcript entries persist (they are
@@ -421,25 +559,45 @@ pub const App = struct {
 /// is never a single mutable "current" component.
 pub const BlockRef = union(enum) {
     assistant: *AssistantText,
-    /// Thinking block (dim status stand-in for P1).
-    thinking: *AssistantText,
-    /// Tool-use block (one-line status stand-in for P1).
-    tool: *AssistantText,
+    /// Streaming thinking block.
+    thinking: *Thinking,
+    /// Tool-use block (drives its own ToolUse component).
+    tool: *ToolUse,
 };
 
+/// Block-index -> component routing, plus a SECOND map from tool-call id ->
+/// the owning `ToolUse` component. The id map is what correlates a later
+/// `ToolResult` (delivered out-of-band in `tool_dispatch_complete`, keyed by
+/// `tool_use_id`) back to the component that issued the call — without any
+/// "active component" (plan §6).
+///
+/// The id map borrows transcript-owned `*ToolUse` pointers; both maps are
+/// cleared at each turn boundary (the transcript entries themselves persist as
+/// history). String keys are duped into an arena so they outlive the borrowed
+/// libpanto event slices.
 pub const TurnRouter = struct {
     map: std.AutoHashMap(usize, BlockRef),
+    tool_by_id: std.StringHashMap(*ToolUse),
+    id_arena: std.heap.ArenaAllocator,
 
     pub fn init(alloc: std.mem.Allocator) TurnRouter {
-        return .{ .map = std.AutoHashMap(usize, BlockRef).init(alloc) };
+        return .{
+            .map = std.AutoHashMap(usize, BlockRef).init(alloc),
+            .tool_by_id = std.StringHashMap(*ToolUse).init(alloc),
+            .id_arena = std.heap.ArenaAllocator.init(alloc),
+        };
     }
 
     pub fn deinit(self: *TurnRouter) void {
         self.map.deinit();
+        self.tool_by_id.deinit();
+        self.id_arena.deinit();
     }
 
     pub fn reset(self: *TurnRouter) void {
         self.map.clearRetainingCapacity();
+        self.tool_by_id.clearRetainingCapacity();
+        _ = self.id_arena.reset(.retain_capacity);
     }
 
     pub fn put(self: *TurnRouter, index: usize, ref: BlockRef) !void {
@@ -449,6 +607,19 @@ pub const TurnRouter = struct {
     pub fn get(self: *TurnRouter, index: usize) ?BlockRef {
         return self.map.get(index);
     }
+
+    /// Register a tool-call id -> its `ToolUse` component for result
+    /// correlation. The id is duped into the router arena (the libpanto slice
+    /// is borrowed and transient).
+    pub fn putToolId(self: *TurnRouter, id: []const u8, box: *ToolUse) !void {
+        const key = try self.id_arena.allocator().dupe(u8, id);
+        try self.tool_by_id.put(key, box);
+    }
+
+    /// Look up the `ToolUse` component that issued the call with this id.
+    pub fn getToolById(self: *TurnRouter, id: []const u8) ?*ToolUse {
+        return self.tool_by_id.get(id);
+    }
 };
 
 // ===========================================================================
@@ -467,6 +638,15 @@ pub const RunOptions = struct {
     /// status line, then cleared. See `runLoop` for the rationale.
     cmd_capture: *std.Io.Writer.Allocating,
     model_label: []const u8,
+    /// Working directory shown in the welcome banner. Borrowed for the loop.
+    cwd: []const u8,
+    /// panto version string for the welcome banner (empty = omit).
+    version: []const u8 = "",
+    /// The std.Io used to spawn `$EDITOR` for the Ctrl+G round-trip.
+    io: std.Io,
+    /// Process environment, used to resolve `$EDITOR` (and `$VISUAL`) for the
+    /// Ctrl+G round-trip. Borrowed for the loop's lifetime.
+    environ: *const std.process.Environ.Map,
 };
 
 /// Run the interactive chat loop against a real terminal until EOF / Ctrl+D /
@@ -507,6 +687,17 @@ pub fn runLoop(app: *App, term: *Terminal, opts: RunOptions) !void {
     defer term.showCursor();
 
     try app.footer.setModel(opts.model_label);
+
+    // Session-start welcome banner as the first transcript entry. cwd is read
+    // from the process; the model label comes from the run options. (Version
+    // is not threaded through the run options yet; the banner omits it.)
+    {
+        const welcome = try app.spawnWelcome();
+        try welcome.setModel(opts.model_label);
+        if (opts.cwd.len != 0) try welcome.setCwd(opts.cwd);
+        if (opts.version.len != 0) try welcome.setVersion(opts.version);
+    }
+
     app.input_box.setFocused(true);
     try app.rebuildEngineList();
     try app.renderNow();
@@ -568,6 +759,29 @@ fn handleBytes(app: *App, term: *Terminal, hs: *Handshake, bytes: []const u8, op
                     // terminal's deinit in main. Signal EOF by closing the loop.
                     return error.UserExit;
                 }
+                if (k.isCtrl('o')) {
+                    // Global collapse/expand of all tool-use components. Consume
+                    // the key (do NOT feed it to the input box) and request a
+                    // render.
+                    app.toggleToolCollapse();
+                    off += step.consumed;
+                    continue;
+                }
+                if (k.isCtrl('g')) {
+                    // Punt the editor buffer out to $EDITOR (markdown tempfile),
+                    // then read it back. Consume the key; never feed it to the
+                    // box.
+                    editInExternalEditor(app, term, opts.io, opts.environ) catch |err| {
+                        if (std.fmt.allocPrint(app.alloc, "[$EDITOR failed: {s}]", .{@errorName(err)})) |msg| {
+                            defer app.alloc.free(msg);
+                            _ = app.spawnStatus(msg) catch {};
+                        } else |_| {
+                            _ = app.spawnStatus("[$EDITOR failed]") catch {};
+                        }
+                    };
+                    off += step.consumed;
+                    continue;
+                }
                 // Feed the key to the focused input box.
                 app.input_box.comp().handleInput(bytes[off .. off + step.consumed]);
             },
@@ -622,6 +836,96 @@ fn handleNegotiation(term: *Terminal, hs: *Handshake, neg: input_mod.Negotiation
     }
 }
 
+/// Punt the input box's buffer to the user's `$EDITOR` (Ctrl+G), then read it
+/// back. Mirrors pi's editor escape hatch.
+///
+/// Flow: write the buffer to a `.md` tempfile -> drop the terminal to cooked
+/// mode + show the cursor -> spawn `$EDITOR <file>` inheriting our stdio and
+/// wait -> re-enter raw mode + hide the cursor -> read the file back into the
+/// box (trimming a single trailing newline most editors add) -> delete the
+/// tempfile -> force a full engine redraw (the child scribbled all over the
+/// screen, so the differential baseline is stale).
+///
+/// The terminal's signal/panic restore record stays armed with the ORIGINAL
+/// (cooked) termios throughout (`suspendRawMode` does not clear it), so a crash
+/// or signal while the editor is open still leaves a sane terminal. We re-enter
+/// raw mode on every return path via `defer`.
+fn editInExternalEditor(
+    app: *App,
+    term: *Terminal,
+    io: std.Io,
+    environ: *const std.process.Environ.Map,
+) !void {
+    const editor = environ.get("VISUAL") orelse environ.get("EDITOR") orelse "vi";
+
+    // Build a tempfile path: $TMPDIR (or /tmp) + a pid/nanotime-unique name.
+    const tmp_dir = environ.get("TMPDIR") orelse "/tmp";
+    const pid = std.c.getpid();
+    const nanos = std.Io.Clock.now(.awake, io).nanoseconds;
+    const path = try std.fmt.allocPrint(app.alloc, "{s}/panto-edit-{d}-{d}.md", .{
+        std.mem.trimEnd(u8, tmp_dir, "/"),
+        pid,
+        nanos,
+    });
+    defer app.alloc.free(path);
+
+    // Write the current buffer out.
+    try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = path, .data = app.input_box.buffer() });
+    defer std.Io.Dir.cwd().deleteFile(io, path) catch {};
+
+    // Split `$EDITOR` on spaces so commands with flags (e.g. "code -w") work,
+    // then append the file path as the final argv entry.
+    var argv: std.ArrayList([]const u8) = .empty;
+    defer argv.deinit(app.alloc);
+    try splitEditorArgv(app.alloc, editor, path, &argv);
+
+    // Drop to cooked mode for the child; always re-enter raw mode + force a
+    // full redraw afterward.
+    term.suspendRawMode();
+    app.flushSink();
+    defer {
+        term.resumeRawMode() catch {};
+        app.engine.forceFullRedraw();
+        app.renderNow() catch {};
+    }
+
+    var child = try std.process.spawn(io, .{
+        .argv = argv.items,
+        .stdin = .inherit,
+        .stdout = .inherit,
+        .stderr = .inherit,
+    });
+    _ = try child.wait(io);
+
+    // Read the edited file back. Cap the read so a pathological file can't OOM
+    // us; 16 MiB is far past any reasonable prompt.
+    const edited = std.Io.Dir.cwd().readFileAlloc(io, path, app.alloc, .limited(16 * 1024 * 1024)) catch |err| switch (err) {
+        else => return err,
+    };
+    defer app.alloc.free(edited);
+
+    // Trim a single trailing newline (the convention most editors add on save).
+    const trimmed = if (std.mem.endsWith(u8, edited, "\n")) edited[0 .. edited.len - 1] else edited;
+    try app.input_box.setBuffer(trimmed);
+}
+
+/// Build the argv for the `$EDITOR` spawn: split `editor` on spaces (so
+/// commands with flags like `"code -w"` work), fall back to `vi` when empty,
+/// then append `path` as the final argument. Split out as a pure helper so the
+/// arg-splitting seam is unit-testable without a PTY (the spawn + raw-mode
+/// round-trip itself is interactive-only).
+fn splitEditorArgv(
+    alloc: std.mem.Allocator,
+    editor: []const u8,
+    path: []const u8,
+    argv: *std.ArrayList([]const u8),
+) !void {
+    var it = std.mem.tokenizeScalar(u8, editor, ' ');
+    while (it.next()) |part| try argv.append(alloc, part);
+    if (argv.items.len == 0) try argv.append(alloc, "vi");
+    try argv.append(alloc, path);
+}
+
 /// Handle a submitted input line: slash command vs. model turn.
 fn handleSubmittedLine(app: *App, line: []const u8, opts: RunOptions) !void {
     if (line.len == 0) return;
@@ -776,33 +1080,38 @@ test "routeEvent: two text blocks key by index, no active-component clobber" {
     try testing.expectEqualStrings("B", h.app.router.get(1).?.assistant.buffer.items);
 }
 
-test "routeEvent: thinking deltas do not crash and stream to a status line" {
+test "routeEvent: thinking deltas stream into a dedicated Thinking component" {
     const alloc = testing.allocator;
     const h = try Harness.make(alloc);
     defer h.teardown(alloc);
 
     try h.app.routeEvent(.{ .block_start = .{ .block_type = .Thinking, .index = 0 } });
-    try h.app.routeEvent(delta(0, "reasoning"));
+    try h.app.routeEvent(delta(0, "reason"));
+    try h.app.routeEvent(delta(0, "ing"));
 
     const ref = h.app.router.get(0).?;
     try testing.expect(ref == .thinking);
-    // The status line buffer contains the seed + appended delta.
-    try testing.expect(std.mem.indexOf(u8, ref.thinking.buffer.items, "reasoning") != null);
+    try testing.expectEqualStrings("reasoning", ref.thinking.buffer.items);
 }
 
-test "routeEvent: tool block renders a minimal tool: <name> status (no crash)" {
+test "routeEvent: tool block accumulates verbatim args and resolves its name" {
     const alloc = testing.allocator;
     const h = try Harness.make(alloc);
     defer h.teardown(alloc);
 
     try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
-    // Tool args streaming as deltas must be dropped silently, not crash.
+    // Tool args stream as deltas and accumulate verbatim into the component.
     try h.app.routeEvent(delta(0, "{\"path\":"));
+    try h.app.routeEvent(delta(0, "\"x\"}"));
     try h.app.routeEvent(.{ .tool_details = .{ .index = 0, .id = "t1", .name = "read" } });
 
     const ref = h.app.router.get(0).?;
     try testing.expect(ref == .tool);
-    try testing.expect(std.mem.indexOf(u8, ref.tool.buffer.items, "tool: read") != null);
+    try testing.expect(ref.tool.name != null);
+    try testing.expectEqualStrings("read", ref.tool.name.?.items);
+    try testing.expectEqualStrings("{\"path\":\"x\"}", ref.tool.input.items);
+    // The id was registered for result correlation.
+    try testing.expect(h.app.router.getToolById("t1") == ref.tool);
 }
 
 test "routeEvent: provider_retry adds a dim status line" {
@@ -874,3 +1183,226 @@ test "maybeRender feeds the footer a frame time and respects coalescing" {
     // Footer received a frame time (>= 0).
     try testing.expect(h.app.footer.frame_ms != null);
 }
+
+test "routeEvent: tool result correlates to its ToolUse component by id" {
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    // Open a tool call, resolve its id/name, accumulate args.
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
+    try h.app.routeEvent(delta(0, "{\"q\":1}"));
+    try h.app.routeEvent(.{ .tool_details = .{ .index = 0, .id = "call-1", .name = "search" } });
+
+    // Build a tool_dispatch_complete user message carrying a ToolResult for
+    // call-1 (the out-of-band delivery path).
+    var msg: panto.Message = .{ .role = .user };
+    defer msg.deinit(alloc);
+    var parts: std.ArrayList(panto.ResultPartStored) = .empty;
+    var text: panto.TextualBlock = .empty;
+    try text.appendSlice(alloc, "the result body");
+    try parts.append(alloc, .{ .text = text });
+    const id = try alloc.dupe(u8, "call-1");
+    try msg.content.append(alloc, .{ .ToolResult = .{ .tool_use_id = id, .parts = parts } });
+
+    try h.app.routeEvent(.{ .tool_dispatch_complete = .{ .message = msg } });
+
+    // The matching component received the output.
+    const box = h.app.router.getToolById("call-1").?;
+    try testing.expect(box.output != null);
+    try testing.expectEqualStrings("the result body", box.output.?.items);
+}
+
+test "routeEvent: two concurrent tool calls route results to their OWN component by id" {
+    // The highest-risk no-active-component case (plan §6): with MULTIPLE tool
+    // calls in flight, each ToolResult must land on the component that issued
+    // the matching id — never "the" tool component. We deliberately deliver the
+    // results in the REVERSE order of the calls and assert no cross-talk.
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    // Open two tool calls at distinct block indices; resolve distinct ids.
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
+    try h.app.routeEvent(delta(0, "{\"a\":1}"));
+    try h.app.routeEvent(.{ .tool_details = .{ .index = 0, .id = "call-A", .name = "read" } });
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 1 } });
+    try h.app.routeEvent(delta(1, "{\"b\":2}"));
+    try h.app.routeEvent(.{ .tool_details = .{ .index = 1, .id = "call-B", .name = "write" } });
+
+    const box_a = h.app.router.getToolById("call-A").?;
+    const box_b = h.app.router.getToolById("call-B").?;
+    try testing.expect(box_a != box_b);
+
+    // Deliver BOTH results in ONE tool_dispatch_complete user message, in the
+    // reverse order (B before A), each carrying its own tool_use_id.
+    var msg: panto.Message = .{ .role = .user };
+    defer msg.deinit(alloc);
+    {
+        var parts_b: std.ArrayList(panto.ResultPartStored) = .empty;
+        var text_b: panto.TextualBlock = .empty;
+        try text_b.appendSlice(alloc, "result for B");
+        try parts_b.append(alloc, .{ .text = text_b });
+        try msg.content.append(alloc, .{ .ToolResult = .{ .tool_use_id = try alloc.dupe(u8, "call-B"), .parts = parts_b } });
+
+        var parts_a: std.ArrayList(panto.ResultPartStored) = .empty;
+        var text_a: panto.TextualBlock = .empty;
+        try text_a.appendSlice(alloc, "result for A");
+        try parts_a.append(alloc, .{ .text = text_a });
+        try msg.content.append(alloc, .{ .ToolResult = .{ .tool_use_id = try alloc.dupe(u8, "call-A"), .parts = parts_a } });
+    }
+    try h.app.routeEvent(.{ .tool_dispatch_complete = .{ .message = msg } });
+
+    // Each result landed on its OWN component — no clobber, no cross-talk.
+    try testing.expect(box_a.output != null);
+    try testing.expect(box_b.output != null);
+    try testing.expectEqualStrings("result for A", box_a.output.?.items);
+    try testing.expectEqualStrings("result for B", box_b.output.?.items);
+    // And the inputs were never crossed either.
+    try testing.expectEqualStrings("{\"a\":1}", box_a.input.items);
+    try testing.expectEqualStrings("{\"b\":2}", box_b.input.items);
+}
+
+test "routeEvent: an unmatched tool_use_id is ignored, matched siblings still route" {
+    // A result whose id has no live ToolUse must be skipped (orelse continue),
+    // never crash or smear onto another component.
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
+    try h.app.routeEvent(.{ .tool_details = .{ .index = 0, .id = "known", .name = "read" } });
+    const known = h.app.router.getToolById("known").?;
+
+    var msg: panto.Message = .{ .role = .user };
+    defer msg.deinit(alloc);
+    {
+        var p_unknown: std.ArrayList(panto.ResultPartStored) = .empty;
+        var t_unknown: panto.TextualBlock = .empty;
+        try t_unknown.appendSlice(alloc, "orphan");
+        try p_unknown.append(alloc, .{ .text = t_unknown });
+        try msg.content.append(alloc, .{ .ToolResult = .{ .tool_use_id = try alloc.dupe(u8, "ghost"), .parts = p_unknown } });
+
+        var p_known: std.ArrayList(panto.ResultPartStored) = .empty;
+        var t_known: panto.TextualBlock = .empty;
+        try t_known.appendSlice(alloc, "real");
+        try p_known.append(alloc, .{ .text = t_known });
+        try msg.content.append(alloc, .{ .ToolResult = .{ .tool_use_id = try alloc.dupe(u8, "known"), .parts = p_known } });
+    }
+    try h.app.routeEvent(.{ .tool_dispatch_complete = .{ .message = msg } });
+
+    try testing.expect(known.output != null);
+    try testing.expectEqualStrings("real", known.output.?.items);
+}
+
+test "toggleToolCollapse flips every tool component globally" {
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    // Two tool calls. Default collapsed == true.
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 1 } });
+    const a = h.app.router.get(0).?.tool;
+    const b = h.app.router.get(1).?.tool;
+    try testing.expect(a.collapsed and b.collapsed);
+
+    // ctrl+o equivalent: expand all.
+    h.app.toggleToolCollapse();
+    try testing.expect(!a.collapsed and !b.collapsed);
+    try testing.expect(!h.app.tools_collapsed);
+
+    // Toggle again: collapse all.
+    h.app.toggleToolCollapse();
+    try testing.expect(a.collapsed and b.collapsed);
+}
+
+test "toggleToolCollapse: a tool spawned AFTER the toggle inherits the global state" {
+    // ctrl+o is a GLOBAL mode, not a per-component flip: a tool call that opens
+    // later must adopt whatever the current global collapse state is, so the
+    // whole transcript stays consistent.
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    // Default is collapsed; flip the global mode to EXPANDED before any tool.
+    h.app.toggleToolCollapse();
+    try testing.expect(!h.app.tools_collapsed);
+
+    // A tool that opens now must be expanded to match the global mode.
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 0 } });
+    const late = h.app.router.get(0).?.tool;
+    try testing.expect(!late.collapsed);
+
+    // Flip back to collapsed; a still-later tool must open collapsed.
+    h.app.toggleToolCollapse();
+    try h.app.routeEvent(.{ .block_start = .{ .block_type = .ToolUse, .index = 1 } });
+    const later = h.app.router.get(1).?.tool;
+    try testing.expect(later.collapsed);
+    // And the earlier one flipped along with the global toggle.
+    try testing.expect(late.collapsed);
+}
+
+test "spawnWelcome shows a session-start banner entry" {
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    const w = try h.app.spawnWelcome();
+    try w.setModel("m");
+    try testing.expectEqual(@as(usize, 1), h.app.transcript.items.len);
+    try testing.expect(h.app.transcript.items[0] == .welcome);
+}
+
+test "routeEvent: compaction summary block spawns a compaction entry" {
+    const alloc = testing.allocator;
+    const h = try Harness.make(alloc);
+    defer h.teardown(alloc);
+
+    var cs: panto.TextualBlock = .empty;
+    defer cs.deinit(alloc);
+    try cs.appendSlice(alloc, "old turns summarized");
+    try h.app.routeEvent(.{ .block_complete = .{
+        .index = 0,
+        .block = .{ .CompactionSummary = .{ .text = cs } },
+    } });
+
+    try testing.expectEqual(@as(usize, 1), h.app.transcript.items.len);
+    try testing.expect(h.app.transcript.items[0] == .compaction);
+}
+
+test "splitEditorArgv: splits flags, appends the path, and falls back to vi" {
+    const alloc = testing.allocator;
+
+    // Bare editor name: [editor, path].
+    {
+        var argv: std.ArrayList([]const u8) = .empty;
+        defer argv.deinit(alloc);
+        try splitEditorArgv(alloc, "nvim", "/tmp/panto-edit-1.md", &argv);
+        try testing.expectEqual(@as(usize, 2), argv.items.len);
+        try testing.expectEqualStrings("nvim", argv.items[0]);
+        try testing.expectEqualStrings("/tmp/panto-edit-1.md", argv.items[1]);
+    }
+
+    // Editor with flags: each space-delimited token is its own argv entry,
+    // then the path is last (e.g. "code -w" -> [code, -w, path]).
+    {
+        var argv: std.ArrayList([]const u8) = .empty;
+        defer argv.deinit(alloc);
+        try splitEditorArgv(alloc, "code -w", "/tmp/x.md", &argv);
+        try testing.expectEqual(@as(usize, 3), argv.items.len);
+        try testing.expectEqualStrings("code", argv.items[0]);
+        try testing.expectEqualStrings("-w", argv.items[1]);
+        try testing.expectEqualStrings("/tmp/x.md", argv.items[2]);
+    }
+
+    // Empty editor string: falls back to vi, then the path.
+    {
+        var argv: std.ArrayList([]const u8) = .empty;
+        defer argv.deinit(alloc);
+        try splitEditorArgv(alloc, "", "/tmp/y.md", &argv);
+        try testing.expectEqual(@as(usize, 2), argv.items.len);
+        try testing.expectEqualStrings("vi", argv.items[0]);
+        try testing.expectEqualStrings("/tmp/y.md", argv.items[1]);
+    }
+}