@d3ara1n/pi-subagent 3.2.2 → 3.3.0

package/README.md

@@ -4,7 +4,7 @@
 
 Role-based subagent orchestration for [pi](https://github.com/earendil-works/pi).
 
-Provides a `subagent_delegate` tool that lets the main model offload tasks to specialized pi child processes with configurable model roles, real-time TUI progress, and AI-generated summaries. Runs can be foreground (blocking) or background (asynchronous, collected later via `subagent_wait`/`subagent_check`, cancellable via `subagent_cancel`). A centered live view (`/subagent:view`) shows every run's activity feed as it happens, with a per-run brief page for inputs and stats; mid-run corrections can be queued into a running subagent from the view's steer editor or via `subagent_steer`.
+Provides a `subagent_delegate` tool that lets the main model offload tasks to specialized pi child processes with configurable model roles, real-time TUI progress, and AI-generated summaries. Runs can be foreground (blocking) or background (asynchronous, collected later via `subagent_check`, cancellable via `subagent_cancel`). A centered live view (`/subagent:view`) shows every run's activity feed as it happens, with a per-run brief page for inputs and stats; mid-run corrections can be queued into a running subagent from the view's steer editor or via `subagent_steer`.
 
 ## Design Philosophy
 
@@ -55,7 +55,7 @@ Observations on how main models behave with this plugin, one family per subsecti
 
 ## TUI Display
 
-- **During execution**: the task's first line with a ⏳ (or ⏸ queued) indicator, a live stream of thinking blocks and tool calls (latest 5 collapsed, everything expanded), and a usage line (elapsed/budget time, turns, tokens, peak context, cost, model). Delegates using inherited conversation are marked in the tool-call title.
+- **During execution**: the task's first line with a ⏳ (or ⏸ queued) indicator, a live stream of thinking blocks, tool calls, and steering messages (latest 5 collapsed, everything expanded), and a usage line (elapsed/budget time, turns, tokens, peak context, cost, model). Delegates using inherited conversation are marked in the tool-call title.
 - **Collapsed result**: the task's first line, then `✓` + the AI-generated summary (or the first line of the output), then the usage line — no activity replay
 - **Expanded result** (Ctrl+O): reference files, context size, the full task, the complete activity stream, the final output as rendered Markdown, and usage details
 - **Fallback trace**: when a provider error (429, quota, timeout, ...) kills a run and it is retried on the role's `fallbackRole`, a `⚠ fallback: first attempt <model> failed (<reason>)` line appears in both views — also while the retry is running (see [Fallback observability](#fallback-observability))
@@ -64,20 +64,20 @@ Observations on how main models behave with this plugin, one family per subsecti
 
 | Command | Description |
 |---------|-------------|
-| `/subagent:view` | Open the live view: a tabbed overlay with a per-run activity feed and a brief detail page (inputs, files, stats), plus modal steer input for the focused run |
+| `/subagent:view` | Open the live view: a tabbed overlay with a per-run activity feed and a brief detail page (inputs, files, stats), plus modal steer input for the focused run — doubles as the session's run archive |
 | `/subagent:doctor` | Diagnose pi invocation, model-role resolution, configuration, and role references |
 | `/subagent:status` | List background runs and their current state |
 | `/subagent:cancel <id\|all> [reason]` | Cancel a live background run (or every live run); the optional reason is recorded with the run |
 
 ### Live view (`/subagent:view`)
 
-A centered overlay covering most of the screen. A tab row across the top lists every run (icon · id · role); `Tab` cycles the focused run, and the rest of the viewport belongs to it alone — showing one of two pages, toggled with `d`.
+A centered overlay covering most of the screen. A tab row across the top lists every run (icon · id · role); `Tab` cycles the focused run forward and `Shift+Tab` backward, and the rest of the viewport belongs to it alone — showing one of two pages, toggled with `d`. Runs are ordered newest-first, and the row is windowed around the focused cell — the archive can outgrow the terminal width, but focus never scrolls off-screen.
 
-The **activity page** (default) is the run's live feed: a continuous, append-only list where each entry is static text with a state icon, and the only animated thing is the ellipsis on a running entry (`.` → `..` → `...`). Finishing freezes an entry in place — its position never changes, only the icon flips. Streamed assistant text grows in place as the run's last line and settles into plain terminal-colored text at the turn boundary. The feed is scrollable (`↑↓`, `PgUp/PgDn`, `Home`/`End`): the view pins to the end and auto-follows new entries; scrolling up unpins (a `⋮ N earlier` marker appears), and reaching the bottom again re-pins. Both foreground and background runs appear here; a foreground run stays listed while its delegate call blocks the main agent. A run leaves the view once its result is in the conversation — when the last one goes, the overlay shows a centered empty notice (with `Esc close` hinted) rather than shrinking away.
+The **activity page** (default) is the run's live feed: a continuous list with pending input pinned below current activity, where each entry is static text with a state icon, and the only animated thing is the ellipsis on a running entry (`.` → `..` → `...`). Finishing freezes an entry in place — its position never changes, only the icon flips. Streamed assistant text grows in place as the run's last line and settles into plain terminal-colored text at the turn boundary. The feed is scrollable (`↑↓`, `PgUp/PgDn`, `Home`/`End`): the view pins to the end and auto-follows new entries; scrolling up unpins (a `⋮ N earlier` marker appears), and reaching the bottom again re-pins. Both foreground and background runs appear here; a foreground run stays listed while its delegate call blocks the main agent. Background runs stay listed for the whole session — the view doubles as the session's run archive, so a run's activity and brief remain browsable even after the model has collected the result. The centered empty notice (with `Esc close` hinted) appears only when nothing has been delegated yet.
 
 The **brief page** shows the run's inputs and vitals at full width: the task and context verbatim (wrapped; head+tail elided beyond 20k chars), inherited-conversation size and truncation status when enabled (never its text), the reference file list annotated with `✓`/`·` for whether the child's tool calls actually touched each file, usage and time stats, the fallback trace, and a stderr tail on failures.
 
-Steer input is modal so keys never conflict with typing: in browse mode `s` opens the editor, `Enter` queues the message into the focused run (only while it is running) and returns to browse, `Esc` cancels and clears. The message appears immediately in the feed as an `↩ steer:` entry and is delivered to the child after its current tool batch, before its next LLM call — the run keeps its progress. `Esc` in browse mode closes the overlay.
+Steer input is modal so keys never conflict with typing: in browse mode `s` opens the editor, `Enter` queues the message into the focused run (only while it is running) and returns to browse, `Esc` cancels and clears. The message appears immediately at the bottom of the feed as an `↩ steer (queued):` entry. When the child consumes the user message, the queued marker disappears in place; the entry remains accent-colored in the history. Delivery happens after the current tool batch, before the next LLM call, without resetting the run's progress. `Esc` in browse mode closes the overlay.
 
 ## Dependencies
 
@@ -240,12 +240,12 @@ Three execution properties, kept separate:
 | Tool | Purpose | Returns to the model |
 |------|---------|---------------------|
 | `subagent_delegate(background: true)` | Start an async run | Just the id (`sub-N`) |
-| `subagent_wait(ids?, timeout?)` | Block until **all** listed runs finish (omit `ids` for all current background runs) | A per-run roll call — one `id (role): state (turns, elapsed, tokens, cost)` line per run, never the output; on timeout, the same roll call (live runs carry usage so far) under a timeout header |
+| `subagent_wait(ids?)` | Block until **all** listed runs end (omit `ids` for all current background runs) | A per-run roll call — one `id (role): state (turns, elapsed, tokens, cost)` line per run; retrieve results with `subagent_check` |
 | `subagent_check(id)` | One-shot snapshot of a single run | `queued` / `running` + current activity, elapsed/budget, and usage so far / the **full output** with a usage footer once finished / failure reason + partial output + usage on failed or cancelled. Idempotent: re-delivers the same terminal snapshot — the run stays in the registry for the whole session |
 | `subagent_steer(id, message)` | Queue a mid-run correction into one running run (typically right after a check revealed it heading down a wrong path) | Confirmation that the steer is queued — delivered after the child's current tool batch, before its next LLM call; the run keeps its progress |
 | `subagent_cancel(id, reason?)` | Kill one live (queued/running) run | Confirmation — the same roll-call line wait uses, plus a pointer to check for the partial output; the run settles as `cancelled` (warning styling, same family as timeout/budget) with the reason in its error message |
 
-Typical flow:
+Example tool calls made by the main model:
 
 ```json
 [
@@ -254,22 +254,28 @@ Typical flow:
 ]
 ```
 
-…continue other work, then:
+The main model continues its own work while these runs execute. Before each model request, the extension refreshes an inbox reminder with the status of runs whose results have not been collected. When the model needs a result from a run that has ended, it retrieves it through `subagent_check`:
 
 ```json
-{ "ids": ["sub-1", "sub-2"] }
+{ "id": "sub-1" }
 ```
 
-(call `subagent_wait`), and finally `subagent_check` each finished id to fetch its result. `subagent_check` accepts one id per call because results can be large.
+If the needed run is still queued or running, the model can wait for it through `subagent_wait`:
+
+```json
+{ "ids": ["sub-1"] }
+```
+
+Once the wait returns, the model retrieves the result through `subagent_check`. The reminder supplies status information, while check provides execution details and results; a separate check is not required before waiting. `subagent_check` accepts one id per call because results can be large; `subagent_wait` can await multiple unfinished runs together.
 
 Semantics worth knowing:
 
-- **Results are pull-only for the model.** A purple completion notice is shown to the user, but nothing delivers the result to the model or wakes it up. The notice is a pure notification in the same visual family as pi's `[compaction]` card — a `[subagent] id (role) outcome` header with the bare task preview beneath, each line truncated to the terminal width — and deliberately unlike the tool rows, so it never reads as model behavior; the result itself never appears in the notice, only in `subagent_check` (model) or `/subagent:status` (user). The model owns the collection point: `subagent_wait`, then `subagent_check` each run. The inbox reminder (below) lists runs not yet checked on the active branch on every request, but it never pushes results.
+- **Results are pull-only for the model.** A purple completion notice is shown to the user, but nothing delivers the result to the model or wakes it up. The notice is a pure notification in the same visual family as pi's `[compaction]` card — a `[subagent] id (role) outcome` header with the bare task preview beneath, each line truncated to the terminal width — and deliberately unlike the tool rows, so it never reads as model behavior; the result itself never appears in the notice, only in `subagent_check` (model) or `/subagent:status` (user). The model collects results with `subagent_check`, using `subagent_wait` when a run has not ended yet. The inbox reminder (below) lists runs not yet collected by a terminal check on the active branch on every request, but it never pushes results.
 - **Background runs survive turn cancellation** and are unaffected by a cancelled `subagent_wait` — cancelling the wait never cancels the runs; call `subagent_wait` or `subagent_check` again later.
 - **Idempotent check, session-tree delivery state:** `subagent_check` re-delivers the same terminal snapshot on every call — runs stay in the registry for the whole session, so no result can ever be stranded by branch navigation or compaction. Whether a run still needs collecting is not tracked in the registry: it derives from the session tree itself. The session is append-only, so branching back past a check entry drops it from the active path — the inbox reminder re-arms and the model simply checks again (the id still resolves; the run is still there). Branching forward to the original branch restores the check entry and silences the reminder again.
 - **Cancellation keeps the partial output.** `subagent_cancel(id, reason?)` kills the child (SIGTERM, escalating to SIGKILL) and settles the run as `cancelled` — its own stop reason in the same family as `timeout`/`budget_exceeded` (TUI warning styling ⏹, not the error-red ✗ of real failures) — with whatever it had produced. The `reason` becomes the error message verbatim, so whoever reads the partial output later via `subagent_check` — or the audit history — sees `cancelled — <reason>`; the source is distinguishable too (`user: ...` for `/subagent:cancel`, the model's own words for the tool, `session shutdown` for reaping). Cancelling does not remove the run: `subagent_check` still returns the partial output, and `subagent_wait` reports the run as `cancelled` with its usage stats.
-- **Inbox reminder:** every LLM call carries a `[background subagent runs]` system reminder listing the runs not yet checked on the active branch (queued, running, and finished-but-unchecked alike, including cancelled ones — shown as `cancelled — <reason>`), injected at a cache-stable head position. Runs missing from the list were already checked on this branch — so a finished run the model forgot to check keeps surfacing until it does. Branch navigation keeps this honest: the list derives from the session tree, not registry bookkeeping.
-- **`timeout` (seconds) is optional — omitting it is the normal usage.** `subagent_wait` blocks until every run finishes, with each run bounded by its own role timeout; subagent runs typically take minutes. Set a timeout only when the waiter must resume soon (e.g. to report progress to the user).
+- **Inbox reminder:** every LLM call carries a `[background subagent runs]` system reminder listing the runs not yet collected by a terminal check on the active branch (queued, running, and finished/failed-but-unchecked alike, including cancelled ones — shown as `cancelled — <reason>`), injected at a cache-stable head position. Only checks that returned a terminal snapshot count — a peek at a live frame never silences the inbox, so the steer flow's check → steer → check-later cycle cannot strand an outcome. Runs missing from the list were already checked on this branch — so a finished run the model forgot to check keeps surfacing until it does. Branch navigation keeps this honest: the list derives from the session tree, not registry bookkeeping.
+- **Wait has no timeout parameter.** `subagent_wait` blocks until all specified runs end. Each run's own role timeout and budgets still apply; cancelling the wait leaves the runs running.
 - Background runs share the global `maxConcurrency` gate — extra runs show up as `queued` in wait/check views.
 - **Top-level only:** nested subagents cannot delegate in the background (a subagent process exits when its task finishes, which would orphan the run).
 - The run registry lives in the pi process: a `/reload` or restart orphans in-flight background runs (their ids stop resolving). `/subagent:status` lists every registered run and its current state.
@@ -281,16 +287,16 @@ Steering queues a correction into a running subagent without killing it — the
 There are two channels into the same mechanism:
 
 - **The model** calls `subagent_steer(id, message)` — typically right after a `subagent_check` snapshot revealed the run heading down a wrong path (check → steer → check again later).
-- **The user** types into the input box of `/subagent:view`, targeting the focused run. Every accepted steer also appears in the run's activity feed as an `↩ steer:` entry, so whoever watches the view sees what was injected and when.
+- **The user** types into the input box of `/subagent:view`, targeting the focused run. Every accepted steer also appears in the run's activity feed, so whoever watches the view sees what was injected and when.
 
-Queued steers are visible in neither wait nor check results — they shape the run's subsequent behavior, not its transcript.
+Steering messages appear in the delegate, wait, check, and live-view activity streams. Pending entries use `↩ steer (queued):`, stay below current activity, and count toward the same five-item collapsed limit. Consumption removes the queued marker without moving the row; `↩ steer:` remains accent-colored in history. Expanded views retain the full activity history. This is TUI presentation only: wait's model-facing response remains a status roll call.
 
 ### Background TUI display
 
 Each tool row renders one aspect of the same decomposition the foreground row shows all at once (input · process · result · usage):
 
 - **Background subagent_delegate row = input only.** Collapsed: `▶ sub-1 <task first line>`. Expanded: plus `@file` references, context size, inherited-conversation size/truncation metadata when enabled, and the full task text. Static — the run progresses invisibly until a subagent_wait/subagent_check row picks it up.
-- **subagent_wait row = process + usage.** The input line shows the id list (or `(all)`) plus the timeout ceiling (`≤30s`) when one was given. One block per watched run: status line (`⏸ queued / ⏳ running` + id + task preview; bare, icon-free once terminal), a live activity stream (collapsed keeps the latest 5 items with a leading ellipsis; expanded shows everything) and a ticking usage bar. Once a run finishes, its process stream is replaced by a **status-only** result line (`✓ finished` / `⏲ budget-exceeded with the reason` / `⏱ timed out` / `⏹ cancelled with the reason` / `✗ <reason>`) — the output itself never appears in a subagent_wait row; expanded keeps the full process stream instead. A timed-out wait freezes the view.
+- **subagent_wait row = process + usage.** The input line shows the id list (or `(all)`). One block per watched run: status line (`⏸ queued / ⏳ running` + id + task preview; bare, icon-free once terminal), a live activity stream (collapsed keeps the latest 5 items with a leading ellipsis; expanded shows everything) and a ticking usage bar. Once a run finishes, its process stream is replaced by a **status-only** result line (`✓ finished` / `⏲ budget-exceeded with the reason` / `⏱ timed out` / `⏹ cancelled with the reason` / `✗ <reason>`) — the output itself never appears in a subagent_wait row; expanded keeps the full process stream instead.
 - **subagent_check row = the result view.** Same block shape as subagent_wait's single-run view (no id — there is only one), but the result line shows `✓ <AI summary>` (or the budget/failure reason when the run stopped early) and the expanded view renders the **full output** — subagent_check is where the conclusion lives.
 - **subagent_cancel row = confirmation only.** Collapsed: `⏹ sub-1 (worker): cancelled after 1 turn (~29s)` (or `• sub-1 (worker) already finished — nothing to cancel` for a no-op). Expanded adds the reason and the pointer to `subagent_check` — the partial output **never renders here**; it stays in the registry until a check row fetches it (layer contract: delegate = input, wait = process, cancel = intervention, check = result).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-subagent",
-  "version": "3.2.2",
+  "version": "3.3.0",
   "type": "module",
   "description": "Role-based subagent orchestration for pi — delegates tasks to specialized pi child processes with configurable model roles",
   "main": "src/index.ts",

package/src/activity.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { appendActivity, consumeSteer } from "./activity.ts";
+import { buildDisplayItems, formatDisplayItem, renderDisplayItems } from "./utils.ts";
+import type { ActivityEntry } from "./types.ts";
+
+const plain = (_color: string, text: string) => text;
+
+test("pending entries stay below internal activity and consume in place", () => {
+  const log: ActivityEntry[] = [];
+  const first = appendActivity(log, { kind: "toolCall", id: "a", status: "running" });
+  appendActivity(log, { kind: "steer", id: "s1", status: "queued", text: "correct" });
+  appendActivity(log, { kind: "steer", id: "s2", status: "queued", text: "correct" });
+  const second = appendActivity(log, { kind: "toolCall", id: "b", status: "running" });
+  assert.deepEqual(log.map((e) => e.id), ["a", "b", "s1", "s2"]);
+  assert.equal(log[first].id, "a");
+  assert.equal(log[second].id, "b");
+  const before = log.map((e) => e.id);
+  assert.equal(consumeSteer(log, { role: "assistant", content: "correct" }), false);
+  assert.equal(consumeSteer(log, { role: "user", content: "unrelated" }), false);
+  assert.equal(consumeSteer(log, { role: "user", content: [{ type: "text", text: "correct" }] }), true);
+  assert.deepEqual(log.map((e) => e.id), before);
+  assert.deepEqual(log.slice(-2).map((e) => e.status), ["done", "queued"]);
+  appendActivity(log, { kind: "thinking", id: "next", status: "running" });
+  assert.deepEqual(log.map((e) => e.id), ["a", "b", "s1", "next", "s2"]);
+  assert.equal(consumeSteer(log, { role: "user", content: "correct" }), true);
+  assert.equal(consumeSteer(log, { role: "user", content: "correct" }), false);
+});
+
+test("queued items share the visible limit and consumption changes only the marker", () => {
+  const log: ActivityEntry[] = Array.from({ length: 6 }, (_, i) => ({
+    kind: "toolCall", id: `t${i}`, toolName: `tool${i}`, status: "done",
+  }));
+  appendActivity(log, { kind: "steer", id: "s", status: "queued", text: "first\nsecond" });
+  const before = renderDisplayItems(buildDisplayItems(log), 5, plain);
+  assert.equal(before.split("\n").length, 6); // Five items plus the existing history marker.
+  assert.ok(!before.includes("tool1"));
+  assert.ok(before.endsWith("\u21a9 steer (queued): first second"));
+  consumeSteer(log, { role: "user", content: "first\nsecond" });
+  const after = renderDisplayItems(buildDisplayItems(log), 5, plain);
+  assert.equal(after, before.replace(" (queued)", ""));
+  assert.equal(buildDisplayItems(log).length, 7);
+});
+
+test("queued rendering uses status for every display type and steers retain accent", () => {
+  const color = (name: string, text: string) => `<${name}>${text}</${name}>`;
+  for (const status of ["queued", "done"] as const) {
+    assert.match(formatDisplayItem({ type: "steer", status, text: "input" }, color), /^<accent>/);
+  }
+  assert.equal(formatDisplayItem({ type: "steer", status: "done", text: "queued" }, plain), "\u21a9 steer: queued");
+  assert.match(formatDisplayItem({ type: "thinking", status: "queued" }, plain), /\(queued\)/);
+  assert.match(formatDisplayItem({ type: "toolCall", name: "read", args: {}, status: "queued" }, plain), /\(queued\)/);
+});

package/src/activity.ts

@@ -0,0 +1,23 @@
+import type { ActivityEntry } from "./types.ts";
+
+/** @internal Insert live activity before pending entries, keeping the queue at the tail. */
+export function appendActivity(log: ActivityEntry[], entry: ActivityEntry): number {
+  const queued = entry.status === "queued" ? -1 : log.findIndex((item) => item.status === "queued");
+  const index = queued < 0 ? log.length : queued;
+  log.splice(index, 0, entry);
+  return index;
+}
+
+/** @internal Match the user message actually consumed by the child, one occurrence at a time. */
+export function consumeSteer(log: ActivityEntry[], message: { role?: string; content?: unknown }): boolean {
+  if (message.role !== "user") return false;
+  const text = typeof message.content === "string"
+    ? message.content
+    : Array.isArray(message.content)
+      ? message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")
+      : undefined;
+  const entry = log.find((item) => item.kind === "steer" && item.status === "queued" && item.text === text);
+  if (!entry) return false;
+  entry.status = "done";
+  return true;
+}

package/src/index.ts

@@ -43,7 +43,7 @@ import { startSubagentRun, type RunHandle } from "./run.ts";
 import { buildInboxReminder, injectReminder } from "./reminder.ts";
 import { serializeInheritedConversation } from "./inheritance.ts";
 import { renderDelegateCall, renderDelegateResult } from "./render.ts";
-import { createViewPanel, filterDeliveredRuns } from "./view.ts";
+import { createViewPanel } from "./view.ts";
 import {
   createSteerCallRender,
   renderBackgroundDelegateCall,
@@ -60,11 +60,6 @@ import {
 
 const BACKGROUND_COMPLETION_MESSAGE_TYPE = "subagent-completion";
 
-/** Refresh ceiling for the /subagent:view delivered-ids cache (ms). The panel
- * re-renders on every animation tick (~150ms); deriving delivery from the
- * session tree is throttled so the overlay stays cheap. */
-const VIEW_DELIVERED_CACHE_MS = 1000;
-
 // ── Extension entry ────────────────────────────────────────────────
 
 export default function subagentExtension(pi: ExtensionAPI) {
@@ -184,7 +179,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
       "BACKGROUND DELEGATION:",
       "",
       "- Use it only when you have your own work this turn (including an ongoing discussion with the user) while the run executes; otherwise let the call block and return the result directly.",
-      "- Results are pull-only for the model — a completion notice is shown to the user, but nothing wakes you or delivers the result. Dispatching means owning the collection point: finish your own work, then subagent_check(id) for each result. Use subagent_wait(ids) to block until runs finish.",
+      "- When you need a background run's result, collect it with subagent_check if the run has ended; otherwise use subagent_wait, then check to collect it.",
       "- Cancel a run you no longer need with subagent_cancel(id) — the child stops and its partial output stays in the registry for subagent_check to collect.",
       "- Background delegation works only in the top-level session.",
     );
@@ -309,7 +304,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
     name: "subagent_delegate",
     label: "Delegate to subagent",
     description:
-      "Delegate a task to a specialized subagent. By default the call blocks until the run finishes and returns the final output — intermediate tool output stays out of your context. With background: true it returns an id immediately and you collect the result later with subagent_wait/subagent_check. Subagents are isolated by default; inheritConversation optionally injects a filtered snapshot of the active parent branch.",
+      "Delegate a task to a specialized subagent. By default the call blocks until the run finishes and returns the final output — intermediate tool output stays out of your context. With background: true it returns an id immediately and you collect the result later with subagent_check. Subagents are isolated by default; inheritConversation optionally injects a filtered snapshot of the active parent branch.",
     promptSnippet: "Delegate tasks to specialized subagents",
     promptGuidelines: guidelines,
 
@@ -340,7 +335,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
       background: Type.Optional(
         Type.Boolean({
           description:
-            "Non-blocking: returns an id immediately so you can do your own work (or keep discussing with the user) while the run executes — not for parallelism (several foreground calls in one turn already run concurrently). Results are pull-only for the model: a completion notice is shown to the user, but nothing delivers the result or wakes you; fetch with subagent_wait/subagent_check when your own work is done. If the next thing you'd do is wait for the result, omit this and let the call block.",
+            "Return immediately with a run id instead of waiting for the final output. Results are pull-only: a completion notice is shown to the user, but does not deliver the result to the model or wake it.",
         }),
       ),
       cwd: Type.Optional(Type.String({ description: "Working directory (defaults to current)" })),
@@ -550,7 +545,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
     name: "subagent_wait",
     label: "Wait for background subagents",
     description:
-      "Block until one or more background subagents (started via subagent_delegate with background: true) finish. Omit ids to wait for ALL current background runs. Returns a per-run roll call — one `id (role): state (turns, elapsed, tokens, cost)` line per run, never the output; fetch it afterwards with subagent_check. If timeout elapses before every run finishes, returns the same roll call (live runs carry usage so far) under a timeout header. Cancelling the wait never cancels the runs — to stop a run, use subagent_cancel(id).",
+      "Wait until all specified background subagent runs end. Omit ids to wait for all current background runs. Returns status and usage for each run; use subagent_check to retrieve results. Cancelling the wait leaves the runs running.",
     promptSnippet: "Wait for background subagents to finish",
     parameters: Type.Object({
       ids: Type.Optional(
@@ -560,12 +555,12 @@ export default function subagentExtension(pi: ExtensionAPI) {
             "Run ids returned by background delegate calls. Omit to wait for all current background runs.",
         }),
       ),
-      timeout: Type.Optional(
-        Type.Number({
-          description:
-            "Max time to wait in seconds. Subagent runs typically take minutes — omit this and let the wait block until they finish (each run's own role timeout is the ceiling); that is the normal usage. Set it only when you must resume soon, e.g. to report progress to the user.",
-        }),
-      ),
+      // Timeout is hidden from the tool schema; restore with the timeoutMs expression below.
+      // timeout: Type.Optional(
+      //   Type.Number({
+      //     description: "Max time to wait in seconds. Omit to wait until all specified runs end.",
+      //   }),
+      // ),
     }),
 
     async execute(_toolCallId, params, signal, onUpdate, _ctx) {
@@ -583,7 +578,9 @@ export default function subagentExtension(pi: ExtensionAPI) {
         );
       }
       const runs = ids.map((id) => backgroundRuns.get(id)!);
-      const timeoutMs = typeof params.timeout === "number" && params.timeout > 0 ? params.timeout * 1000 : 0;
+      // Keep the timeout machinery available while the tool exposes completion-only waiting.
+      // const timeoutMs = typeof params.timeout === "number" && params.timeout > 0 ? params.timeout * 1000 : 0;
+      const timeoutMs = 0;
 
       // ── Live mirror: forward combined snapshots into this tool row ──
       const entries = () => runs.map((r) => ({ id: r.id, role: r.role, result: r.snapshot }));
@@ -812,28 +809,13 @@ export default function subagentExtension(pi: ExtensionAPI) {
   });
 
   pi.registerCommand("subagent:view", {
-    description: "Open the live subagent activity view (watch progress, steer runs)",
+    description: "Open the subagent activity view (watch runs, steer, browse the session's archive)",
     handler: async (_args, ctx) => {
-      // Union of every known run: the background registry plus live
-      // in-flight runs (foreground delegate calls included). Dedupe by id —
-      // background runs appear in both. Terminal runs stay listed until
-      // their result is delivered (subagent_check on the active branch,
-      // derived from the session tree — same source of truth as the inbox
-      // reminder), then leave the view: it is for live watching and pending
-      // collection, not an archive. Delivery re-derivation is throttled
-      // because the panel re-renders on every animation tick.
-      const deliveredCache = { ids: new Set<string>(), at: 0 };
-      const deliveredIds = (): Set<string> => {
-        if (Date.now() - deliveredCache.at > VIEW_DELIVERED_CACHE_MS) {
-          try {
-            deliveredCache.ids = collectDeliveredIds(ctx.sessionManager.buildContextEntries());
-          } catch {
-            /* keep the previous set */
-          }
-          deliveredCache.at = Date.now();
-        }
-        return deliveredCache.ids;
-      };
+      // Union of every known run: the background registry — append-only for
+      // the whole session, the view doubles as the run archive and derives
+      // nothing from delivery state — plus live in-flight runs (foreground
+      // delegate calls included, visible only while in flight). Dedupe by
+      // id — background runs appear in both.
       const runsProvider = () => {
         const seen = new Set<string>();
         const out: RunHandle[] = [];
@@ -843,7 +825,7 @@ export default function subagentExtension(pi: ExtensionAPI) {
             out.push(r);
           }
         }
-        return filterDeliveredRuns(out, deliveredIds());
+        return out;
       };
       if (runsProvider().length === 0) {
         ctx.ui.notify("No subagent runs yet.", "info");

package/src/reminder.test.ts

@@ -143,9 +143,9 @@ describe("buildInboxReminder", () => {
     assert.ok(text.includes(`"${"x".repeat(70)}..."`));
   });
 
-  test("header explains pull-only collection semantics", () => {
+  test("header identifies results awaiting collection with check", () => {
     const text = buildInboxReminder([entry({ id: "sub-1", state: "running" })], new Set())!;
-    assert.match(text, /^\[background subagent runs — results are pull-only for the model/);
+    assert.match(text, /^\[background subagent runs — results not yet collected with subagent_check/);
     assert.match(text, /already checked on this branch\]/);
   });
 

package/src/reminder.ts

@@ -3,11 +3,12 @@
  *
  * Injected into the LLM context before every provider call via the `context`
  * event. The reminder lists every delegated run not yet delivered by a
- * subagent_check on the active branch — queued, running, and
- * finished/failed alike — so the model cannot forget about them. Delivery
- * state is derived from the session tree (see collectDeliveredIds), not
- * tracked in the registry: branching past a check re-arms the inbox,
- * branching back silences it, and compaction un-delivers naturally.
+ * subagent_check of a terminal snapshot on the active branch — queued,
+ * running, and finished/failed alike — so the model cannot forget about
+ * them. Delivery state is derived from the session tree (see
+ * collectDeliveredIds), not tracked in the registry: branching past a check
+ * re-arms the inbox, branching back silences it, and compaction un-delivers
+ * naturally.
  *
  * Cache discipline: the reminder is prepended to the FIRST user message, so
  * it sits at a stable position in the message prefix. Its content must stay
@@ -30,7 +31,7 @@ export interface InboxEntry {
 }
 
 const INBOX_HEADER =
-  "[background subagent runs — results are pull-only for the model: no completion notice wakes you. subagent_wait, then subagent_check to collect each run; a terminal check removes it from this list; runs missing here were already checked on this branch]";
+  "[background subagent runs — results not yet collected with subagent_check; a terminal check removes a run from this list; runs missing here were already checked on this branch]";
 
 /** `42s`, `3m12s`, `4m` — whole seconds, no live clocks. */
 function formatDuration(totalSec: number): string {
@@ -65,9 +66,9 @@ function inboxStatus(entry: InboxEntry): string {
  * Build the inbox reminder text, or undefined when every delegated run has
  * already been checked on the active branch (nothing to remind about —
  * inject nothing, keep the context untouched and the provider cache fully
- * stable). Queued/running runs are always listed regardless of delivery
- * state — their result is not final yet, so a past check (of a live frame)
- * never counts as delivered.
+ * stable). The state guard pins the inbox's own invariant locally — only
+ * terminal runs can ever count as delivered (collectDeliveredIds ignores
+ * live-frame checks), so a past peek at a running run never silences it.
  */
 export function buildInboxReminder(entries: Iterable<InboxEntry>, delivered: Set<string>): string | undefined {
   const rows: string[] = [];

package/src/render-async.ts

@@ -48,13 +48,11 @@ import {
   ensureElapsedTimer,
   formatFallback,
   formatInheritedConversationInput,
-  formatThinking,
+  formatDisplayItem,
   formatTimePart,
-  formatToolCall,
   formatUsageStats,
   renderDisplayItems,
   runIcon,
-  statusStyle,
   taskPreview,
   terminalResultLine,
 } from "./utils.ts";
@@ -85,12 +83,8 @@ function addActivityRows(container: Container, r: SubagentResult, fg: Fg): void
     return;
   }
   for (const item of activity) {
-    if (item.type === "thinking") {
-      container.addChild(new Text(formatThinking(item.status, fg), 0, 0));
-    } else {
-      const { prefix, color } = statusStyle(item.status, fg);
-      container.addChild(new Text(prefix + formatToolCall(item.name, item.args, color), 0, 0));
-    }
+    const row = formatDisplayItem(item, fg);
+    container.addChild(item.type === "steer" ? collapsedText(row) : new Text(row, 0, 0));
   }
 }
 
@@ -207,6 +201,8 @@ function checkEntryExpandedContainer(r: SubagentResult, fg: Fg): Container {
 
   if (state === "finished" || state === "failed") {
     container.addChild(new Text(terminalResultLine(r, fg), 0, 0));
+    container.addChild(new Spacer(1));
+    addActivityRows(container, r, fg);
     // check is the result-fetcher: the full output lives here.
     container.addChild(new Spacer(1));
     if (r.output.trim()) {

package/src/render.test.ts

@@ -1,9 +1,50 @@
-/** Tests for inherited-conversation TUI observability. */
+/** Tests for delegate and background-run TUI observability. */
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { renderBackgroundDelegateCall, renderBackgroundDelegateResult } from "./render-async.ts";
-import { renderDelegateCall } from "./render.ts";
+import { renderBackgroundDelegateCall, renderBackgroundDelegateResult, renderWaitResult, renderCheckResult } from "./render-async.ts";
+import { renderDelegateCall, renderDelegateResult } from "./render.ts";
+import type { SubagentResult } from "./types.ts";
+
+test("delegate, wait, and check preserve steer rows through consumption and completion", () => {
+  const run: SubagentResult = {
+    role: "worker", task: "task", exitCode: -1, output: "", stderr: "",
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0, contextTokens: 0 },
+    activityLog: [
+      ...Array.from({ length: 6 }, (_, i) => ({ kind: "toolCall" as const, id: `t${i}`, toolName: `tool${i}`, status: "done" as const })),
+      { kind: "steer", id: "s", status: "queued", text: "correction ".repeat(30) },
+    ],
+  };
+  const renderers = [
+    () => ({ render: renderDelegateResult, details: { results: [run] } }),
+    () => ({ render: renderWaitResult, details: { entries: [{ id: "sub-1", role: "worker", result: run }] } }),
+    () => ({ render: renderCheckResult, details: { id: "sub-1", role: "worker", result: run } }),
+  ];
+  for (const make of renderers) {
+    for (const expanded of [false, true]) {
+      for (const width of [40, 100]) {
+        const { render, details } = make();
+        const draw = () => render({ content: [], details } as any, { expanded, isPartial: true }, theme, { state: {} } as any)
+          .render(width).map((line) => line.trimEnd());
+        run.exitCode = -1;
+        run.activityLog.at(-1)!.status = "queued";
+        const pending = draw();
+        const index = pending.findIndex((line) => line.includes("steer (queued):"));
+        assert.ok(index >= 0);
+        assert.ok(expanded || !pending.join("\n").includes("tool1"));
+        run.activityLog.at(-1)!.status = "done";
+        const consumed = draw();
+        assert.equal(consumed.length, pending.length);
+        assert.ok(consumed[index].includes("steer:"));
+        assert.ok(!consumed[index].includes("(queued)"));
+        if (expanded) {
+          run.exitCode = 0;
+          assert.ok(draw().some((line) => line.includes("steer:")));
+        }
+      }
+    }
+  }
+});
 
 const theme = {
   fg: (_color: string, text: string) => text,

package/src/render.ts

@@ -16,13 +16,11 @@ import {
   ensureElapsedTimer,
   formatFallback,
   formatInheritedConversationInput,
-  formatThinking,
+  formatDisplayItem,
   formatTimePart,
-  formatToolCall,
   formatUsageStats,
   renderDisplayItems,
   runIcon,
-  statusStyle,
   taskPreview,
   terminalResultLine,
 } from "./utils.ts";
@@ -150,14 +148,8 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
       container.addChild(new Text(theme.fg("muted", runningLabel), 0, 0));
     } else {
       for (const item of displayItems) {
-        if (item.type === "thinking") {
-          container.addChild(new Text(formatThinking(item.status, fg), 0, 0));
-        } else {
-          const { prefix, color } = statusStyle(item.status, fg);
-          container.addChild(
-            new Text(prefix + formatToolCall(item.name, item.args, color), 0, 0),
-          );
-        }
+        const row = formatDisplayItem(item, fg);
+        container.addChild(item.type === "steer" ? collapsedText(row) : new Text(row, 0, 0));
       }
     }
 

package/src/spawn.ts

@@ -13,6 +13,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { appendActivity, consumeSteer } from "./activity.ts";
 import type { SubagentControl, SubagentMessage, SubagentResult } from "./types.ts";
 
 const PI_CODING_AGENT_PACKAGE = "@earendil-works/pi-coding-agent";
@@ -463,6 +464,10 @@ export async function spawnSubagent(
         }
       }
 
+      if (event.type === "message_start" && event.message && consumeSteer(result.activityLog, event.message)) {
+        emitProgress();
+      }
+
       if (event.type === "message_end" && event.message) {
         const msg = event.message as SubagentMessage;
 
@@ -481,7 +486,12 @@ export async function spawnSubagent(
               usage.totalTokens || 0,
             );
           }
-          if (!result.model && msg.model) result.model = msg.model;
+          // The child's AssistantMessage carries the bare model id with the
+          // provider in a separate field — compose the full `provider/model-id`
+          // ref so usage displays match the delegate-facing modelRef format.
+          if (!result.model && msg.model) {
+            result.model = msg.provider ? `${msg.provider}/${msg.model}` : msg.model;
+          }
           // message_end is authoritative for the latest assistant attempt. A
           // successful native retry must clear the transient error left by the
           // failed attempt instead of triggering a redundant whole-run fallback.
@@ -505,14 +515,14 @@ export async function spawnSubagent(
       // Activity log: track thinking blocks and tool calls in arrival order.
       // Both update in place so the TUI reflects real-time state.
       if (event.type === "tool_execution_start" && event.toolCallId) {
-        toolCallIndex.set(event.toolCallId, result.activityLog.length);
-        result.activityLog.push({
+        const index = appendActivity(result.activityLog, {
           kind: "toolCall",
           id: event.toolCallId,
           status: "running",
           toolName: event.toolName,
           args: event.args ?? {},
         });
+        toolCallIndex.set(event.toolCallId, index);
         // Pause the parent timeout clock while the child delegates — nested
         // subagents get their own full budget instead of racing this clock.
         // Ref-counted: concurrent subagent_delegate calls pause once and resume
@@ -540,7 +550,7 @@ export async function spawnSubagent(
       const aev = event.assistantMessageEvent;
       if (event.type === "message_update" && aev) {
         if (aev.type === "thinking_start") {
-          result.activityLog.push({
+          appendActivity(result.activityLog, {
             kind: "thinking",
             id: `thinking-${thinkingCounter++}`,
             status: "running",
@@ -559,7 +569,7 @@ export async function spawnSubagent(
           }
           emitProgress();
         } else if (aev.type === "text_start") {
-          result.activityLog.push({
+          appendActivity(result.activityLog, {
             kind: "text",
             id: `text-${textCounter++}`,
             status: "running",
@@ -714,12 +724,11 @@ export async function spawnSubagent(
         steer(message: string) {
           if (processExited || terminationRequested) return;
           sendCommand({ type: "steer", message });
-          // Mirror the steer into the activity feed so the :view overlay shows
-          // what was injected and when.
-          result.activityLog.push({
+          // Keep pending input visible until the child emits its user message.
+          appendActivity(result.activityLog, {
             kind: "steer",
             id: `steer-${steerCounter++}`,
-            status: "done",
+            status: "queued",
             text: message,
           });
           emitProgress();

package/src/types.ts

@@ -87,7 +87,7 @@ export interface SubagentRole {
 }
 
 /** Status of an individual tool call within a subagent run. */
-export type ToolStatus = "running" | "done" | "failed";
+export type ToolStatus = "queued" | "running" | "done" | "failed";
 
 /** A single entry in the real-time activity log (thinking block, tool call, streamed assistant text, or a user steer). */
 export interface ActivityEntry {
@@ -137,6 +137,7 @@ export interface SubagentMessage {
     cost?: { total?: number };
     totalTokens?: number;
   };
+  provider?: string;
   model?: string;
   stopReason?: string;
   errorMessage?: string;

package/src/utils.test.ts

@@ -910,9 +910,15 @@ describe("briefFilesUsed", () => {
 });
 
 describe("collectDeliveredIds", () => {
-  const checkEntry = (id: string) => ({
+  // A check tool result carrying a terminal snapshot (exitCode >= 0) —
+  // the shape the check tool persists into the session tree.
+  const checkEntry = (id: string, exitCode = 0) => ({
     type: "message",
-    message: { role: "toolResult", toolName: "subagent_check", details: { id, role: "worker" } },
+    message: {
+      role: "toolResult",
+      toolName: "subagent_check",
+      details: { id, role: "worker", result: { exitCode } },
+    },
   });
 
   test("collects ids from subagent_check tool results only", () => {
@@ -932,6 +938,11 @@ describe("collectDeliveredIds", () => {
     assert.deepEqual(collectDeliveredIds([checkEntry("sub-1"), checkEntry("sub-1")]), new Set(["sub-1"]));
   });
 
+  test("a check of a live frame never delivers (stale peek must not silence the inbox)", () => {
+    const entries = [checkEntry("sub-1", -1), checkEntry("sub-2")];
+    assert.deepEqual(collectDeliveredIds(entries), new Set(["sub-2"]));
+  });
+
   test("empty path means nothing delivered (branch rewound past the check)", () => {
     assert.equal(collectDeliveredIds([]).size, 0);
   });
@@ -941,6 +952,10 @@ describe("collectDeliveredIds", () => {
       { type: "message", message: { role: "toolResult", toolName: "subagent_check" } },
       { type: "message", message: { role: "toolResult", toolName: "subagent_check", details: {} } },
       { type: "message", message: { role: "toolResult", toolName: "subagent_check", details: { id: 42 } } },
+      {
+        type: "message",
+        message: { role: "toolResult", toolName: "subagent_check", details: { id: "sub-1", result: {} } },
+      },
     ];
     assert.equal(collectDeliveredIds(entries).size, 0);
   });

package/src/utils.ts

@@ -142,7 +142,8 @@ export function formatTimePart(r: {
 
 export type DisplayItem =
   | { type: "toolCall"; name: string; args: Record<string, any>; status?: ToolStatus }
-  | { type: "thinking"; status?: ToolStatus };
+  | { type: "thinking"; status?: ToolStatus }
+  | { type: "steer"; text: string; status?: ToolStatus };
 
 /**
  * Map the real-time activity log into renderable display items (in order).
@@ -151,12 +152,12 @@ export type DisplayItem =
  */
 export function buildDisplayItems(activityLog: ActivityEntry[]): DisplayItem[] {
   return activityLog
-    .filter((a) => a.kind === "thinking" || a.kind === "toolCall")
-    .map((a) =>
-      a.kind === "thinking"
-        ? { type: "thinking", status: a.status }
-        : { type: "toolCall", name: a.toolName ?? "?", args: a.args ?? {}, status: a.status },
-    );
+    .filter((a) => a.kind !== "text")
+    .map((a): DisplayItem => {
+      if (a.kind === "thinking") return { type: "thinking", status: a.status };
+      if (a.kind === "steer") return { type: "steer", text: a.text ?? "", status: a.status };
+      return { type: "toolCall", name: a.toolName ?? "?", args: a.args ?? {}, status: a.status };
+    });
 }
 
 export function shortenPath(p: string): string {
@@ -280,6 +281,24 @@ export function formatThinking(
   return fg("dim", "\u25C6 thought");
 }
 
+export function formatDisplayItem(
+  item: DisplayItem,
+  fg: (color: string, text: string) => string,
+): string {
+  const queued = item.status === "queued";
+  const marker = queued ? " (queued)" : "";
+  if (item.type === "steer") {
+    return fg("accent", `\u21a9 steer${marker}: ${oneLine(item.text)}`);
+  }
+  if (queued) {
+    const body = item.type === "thinking" ? "thinking" : formatToolCall(item.name, item.args, (_c, text) => text);
+    return fg("accent", `\u23f8 ${body}${marker}`);
+  }
+  if (item.type === "thinking") return formatThinking(item.status, fg);
+  const { prefix, color } = statusStyle(item.status, fg);
+  return prefix + formatToolCall(item.name, item.args, color);
+}
+
 export function renderDisplayItems(
   items: DisplayItem[],
   limit: number | undefined,
@@ -290,12 +309,7 @@ export function renderDisplayItems(
   let text = "";
   if (skipped > 0) text += fg("muted", `... ${skipped} earlier items\n`);
   for (const item of toShow) {
-    if (item.type === "thinking") {
-      text += `${formatThinking(item.status, fg)}\n`;
-    } else {
-      const { prefix, color } = statusStyle(item.status, fg);
-      text += `${prefix}${formatToolCall(item.name, item.args, color)}\n`;
-    }
+    text += `${formatDisplayItem(item, fg)}\n`;
   }
   return text.trimEnd();
 }
@@ -622,7 +636,7 @@ export function describeCurrentActivity(r: { activityLog: ActivityEntry[] }): st
   if (!last) return "waiting for first event";
   if (last.kind === "thinking") return last.status === "running" ? "thinking" : "thought";
   if (last.kind === "text") return last.status === "running" ? "responding" : "responded";
-  if (last.kind === "steer") return "steered — awaiting next turn";
+  if (last.kind === "steer") return last.status === "queued" ? "steer queued — awaiting delivery" : "steer received";
   return formatToolCall(last.toolName ?? "?", last.args ?? {}, (_color, text) => text);
 }
 
@@ -903,6 +917,11 @@ interface SessionEntryLike {
  * truth for delivery state: it is append-only and branch navigation rebuilds
  * the active path, so branching past a check entry un-delivers (the inbox
  * re-arms) while branching back re-delivers — no mirrored state to sync.
+ *
+ * Only checks that returned a TERMINAL snapshot count: a peek at a live
+ * frame (running/queued, exitCode -1) delivers nothing — the steer flow
+ * re-checks later — so an early check can never silence the inbox before
+ * the outcome exists.
  */
 export function collectDeliveredIds(entries: Iterable<SessionEntryLike>): Set<string> {
   const ids = new Set<string>();
@@ -910,8 +929,12 @@ export function collectDeliveredIds(entries: Iterable<SessionEntryLike>): Set<st
     if (entry.type !== "message") continue;
     const message = entry.message;
     if (!message || message.role !== "toolResult" || message.toolName !== "subagent_check") continue;
-    const id = (message.details as { id?: unknown } | undefined)?.id;
-    if (typeof id === "string" && id) ids.add(id);
+    const details = message.details as { id?: unknown; result?: { exitCode?: unknown } } | undefined;
+    if (typeof details?.id !== "string" || !details.id) continue;
+    // A malformed or live frame (exitCode -1) is not a delivery — leave the
+    // inbox armed.
+    if (typeof details.result?.exitCode !== "number" || details.result.exitCode === -1) continue;
+    ids.add(details.id);
   }
   return ids;
 }

package/src/view.test.ts

@@ -1,10 +1,6 @@
 import test from "node:test";
 import assert from "node:assert";
-import {
-  filterDeliveredRuns,
-  inheritedConversationFields,
-  sortViewRuns,
-} from "./view.ts";
+import { inheritedConversationFields, sortViewRuns, windowTabCells } from "./view.ts";
 import type { RunHandle } from "./run.ts";
 
 // ── Fakes ──────────────────────────────────────────────────────────
@@ -13,26 +9,6 @@ function fakeHandle(id: string, state: RunHandle["state"]): RunHandle {
   return { id, state } as unknown as RunHandle;
 }
 
-// ── filterDeliveredRuns ────────────────────────────────────────────
-
-test("filterDeliveredRuns drops delivered terminal runs, keeps live and undelivered", () => {
-  const running = fakeHandle("sub-1", "running");
-  const queued = fakeHandle("sub-2", "queued");
-  const finishedUndelivered = fakeHandle("sub-3", "finished");
-  const finishedDelivered = fakeHandle("sub-4", "finished");
-  const failedDelivered = fakeHandle("sub-5", "failed");
-
-  const out = filterDeliveredRuns(
-    [running, queued, finishedUndelivered, finishedDelivered, failedDelivered],
-    new Set(["sub-4", "sub-5"]),
-  );
-
-  assert.deepEqual(
-    out.map((r) => r.id),
-    ["sub-1", "sub-2", "sub-3"],
-  );
-});
-
 // ── inheritedConversationFields ────────────────────────────────────
 
 test("inheritedConversationFields returns aligned-view metadata without body text", () => {
@@ -50,15 +26,72 @@ test("inheritedConversationFields returns aligned-view metadata without body tex
 
 // ── sortViewRuns ───────────────────────────────────────────────────
 
-test("sortViewRuns ranks running before finished, each group by id", () => {
+test("sortViewRuns orders newest first by numeric id (creation order)", () => {
   const out = sortViewRuns([
-    fakeHandle("sub-3", "finished"),
     fakeHandle("sub-2", "running"),
-    fakeHandle("sub-4", "running"),
+    fakeHandle("sub-10", "finished"),
     fakeHandle("sub-1", "failed"),
+    fakeHandle("sub-9", "queued"),
   ]);
   assert.deepEqual(
     out.map((r) => r.id),
-    ["sub-2", "sub-4", "sub-1", "sub-3"],
+    ["sub-10", "sub-9", "sub-2", "sub-1"],
   );
 });
+
+test("sortViewRuns is state-agnostic — a run settling never reshuffles rows", () => {
+  const before = sortViewRuns([
+    fakeHandle("sub-1", "running"),
+    fakeHandle("sub-2", "running"),
+    fakeHandle("sub-3", "running"),
+  ]);
+  const after = sortViewRuns([
+    fakeHandle("sub-1", "running"),
+    fakeHandle("sub-2", "failed"),
+    fakeHandle("sub-3", "finished"),
+  ]);
+  assert.deepEqual(
+    after.map((r) => r.id),
+    before.map((r) => r.id),
+  );
+});
+
+// ── windowTabCells ─────────────────────────────────────────────────
+
+test("windowTabCells returns everything when the row fits", () => {
+  const cells = ["[a sub-1]", "[b sub-22]", "[c sub-333]"];
+  const win = windowTabCells(cells, 1, 100);
+  assert.deepEqual(win, { items: cells, leftClipped: false, rightClipped: false });
+});
+
+test("windowTabCells keeps the focused cell visible under a tight budget", () => {
+  const cells = ["[a sub-1 x]", "[b sub-2 y]", "[c sub-3 z]"];
+  // Cell widths with one separator space each: 13 + 12 = 25 fits the left
+  // neighbor too; the right one (13) does not fit.
+  const win = windowTabCells(cells, 1, 25);
+  assert.equal(win.leftClipped, false); // sub-1 fits on the left
+  assert.equal(win.rightClipped, true); // sub-3 does not fit
+  assert.deepEqual(win.items, [cells[0], cells[1]]);
+});
+
+test("windowTabCells clips both sides around a mid-list focus", () => {
+  const cells = ["[1]", "[22]", "[333]", "[4444]", "[55555]"];
+  // Focused cell (width 6) plus left neighbor (width 5) = 11.
+  const win = windowTabCells(cells, 2, 11);
+  assert.deepEqual(win.items, [cells[1], cells[2]]);
+  assert.equal(win.leftClipped, true);
+  assert.equal(win.rightClipped, true);
+});
+
+test("windowTabCells still returns the focused cell when it alone overflows", () => {
+  const cells = ["[tiny]", "[enormous-cell]"];
+  const win = windowTabCells(cells, 1, 3);
+  assert.deepEqual(win.items, [cells[1]]);
+  assert.equal(win.leftClipped, true);
+  assert.equal(win.rightClipped, false);
+});
+
+test("windowTabCells handles an empty list and clamps an out-of-range focus", () => {
+  assert.deepEqual(windowTabCells([], 0, 50), { items: [], leftClipped: false, rightClipped: false });
+  assert.deepEqual(windowTabCells(["[a]"], 99, 50).items, ["[a]"]);
+});

package/src/view.ts

@@ -23,8 +23,13 @@
  * Steer input is modal so keys never conflict with the editor: browse mode
  * owns navigation; `s` opens the editor (Enter sends and returns to browse,
  *    Esc cancels and clears). Esc in browse closes the overlay; Tab cycles
- *    the focused run and resets its view — page back to activity, scrolls
- *    re-pinned.
+ *    the focused run forward, Shift+Tab backward, and cycling resets its
+ *    view — page back to activity, scrolls re-pinned.
+ *
+ * The run list is the session's archive: every background run stays listed
+ * (newest first) after it settles — results remain browsable even after the
+ * model collects them, so nothing is ever derived from delivery state here.
+ * Foreground runs appear only while their delegate call is in flight.
  *
  * Layout: a centered screen overlay (overlay:true) occupying most of the
  * terminal, framed with a thin border. An embedded Editor accepts steering
@@ -53,6 +58,7 @@ import {
   briefFilesUsed,
   formatFallback,
   formatThinking,
+  formatDisplayItem,
   formatTimePart,
   formatToolCall,
   formatTokens,
@@ -110,25 +116,54 @@ function capBriefText(text: string): string {
 }
 
 /**
- * Build the display list of runs for the panel: running/queued first, then
- * finished, each group ordered by registry id.
+ * Build the display list of runs for the panel: newest first, by numeric
+ * id (creation order). Creation order never reshuffles — the archive is
+ * append-only, so rows stay put when runs settle and focus remains
+ * predictable.
  */
 export function sortViewRuns(runs: RunHandle[]): RunHandle[] {
-  const rank = (r: RunHandle) => (r.state === "running" || r.state === "queued" ? 0 : 1);
-  return [...runs].sort((a, b) => rank(a) - rank(b) || a.id.localeCompare(b.id));
+  const num = (r: RunHandle) => Number.parseInt(r.id.replace(/^sub-/, ""), 10) || 0;
+  return [...runs].sort((a, b) => num(b) - num(a));
 }
 
 /**
- * Drop terminal runs whose result is already in the conversation — delivered
- * by subagent_check on the active branch (the same session-tree source of
- * truth as the inbox reminder). Live runs and undelivered terminal runs
- * stay: the view is for live watching and pending collection, not an
- * archive.
+ * @internal — exported for testing; fits a window of tab cells around the
+ * focused one into `budget` visible columns. The archive can outgrow the
+ * row, but the focused cell never scrolls off-screen: neighbors expand
+ * outward (cheaper side first) while they fit, and clipped sides collapse
+ * to `…` markers.
  */
-export function filterDeliveredRuns(runs: RunHandle[], delivered: Set<string>): RunHandle[] {
-  return runs.filter(
-    (r) => (r.state !== "finished" && r.state !== "failed") || !delivered.has(r.id),
-  );
+export function windowTabCells(
+  cells: string[],
+  focusIdx: number,
+  budget: number,
+): { items: string[]; leftClipped: boolean; rightClipped: boolean } {
+  if (cells.length === 0) return { items: [], leftClipped: false, rightClipped: false };
+  const focus = Math.max(0, Math.min(focusIdx, cells.length - 1));
+  const widths = cells.map((c) => visibleWidth(c) + 1); // +1 separator space
+  let lo = focus;
+  let hi = focus;
+  let used = widths[focus];
+  const tryAdd = (i: number): boolean => {
+    if (i < 0 || i >= cells.length || used + widths[i] > budget) return false;
+    used += widths[i];
+    return true;
+  };
+  for (;;) {
+    const canLeft = lo > 0;
+    const canRight = hi < cells.length - 1;
+    if (!canLeft && !canRight) break;
+    const preferLeft = canLeft && (!canRight || widths[lo - 1] <= widths[hi + 1]);
+    if (preferLeft) {
+      if (tryAdd(lo - 1)) { lo--; continue; }
+      if (canRight && tryAdd(hi + 1)) { hi++; continue; }
+      break;
+    }
+    if (tryAdd(hi + 1)) { hi++; continue; }
+    if (canLeft && tryAdd(lo - 1)) { lo--; continue; }
+    break;
+  }
+  return { items: cells.slice(lo, hi + 1), leftClipped: lo > 0, rightClipped: hi < cells.length - 1 };
 }
 
 /**
@@ -205,9 +240,10 @@ export class SubagentViewPanel implements Component, Focusable {
     }, ANIMATION_INTERVAL_MS);
   }
 
-  /** Resolve the focused run by id; stable across sort-order reshuffles
-   *  (e.g. a run finishing re-ranks the list). The focused run's view state
-   *  (page + scrolls) resets only when the focused run actually changes. */
+  /** Resolve the focused run by id; stable across list changes (a
+   *  foreground run settling drops out of the registry). The focused run's
+   *  view state (page + scrolls) resets only when the focused run actually
+   *  changes. */
   private focusedRun(): RunHandle | undefined {
     const runs = sortViewRuns(this.runsProvider());
     if (runs.length === 0) {
@@ -231,15 +267,21 @@ export class SubagentViewPanel implements Component, Focusable {
     this.briefTop = 0;
   }
 
-  private cycleRun(): void {
+  private cycleRun(direction: 1 | -1): void {
     const runs = sortViewRuns(this.runsProvider());
     if (runs.length < 2) return;
     const idx = runs.findIndex((r) => r.id === this.focusId);
-    // Focus id gone from the list: fall back to the first run, same as
-    // focusedRun() — not to the second.
-    const next = idx < 0 ? runs[0] : runs[(idx + 1) % runs.length];
-    if (next.id === this.focusId) return;
-    this.focusId = next.id;
+    if (idx < 0) {
+      // Focus id gone from the list (a foreground run settled): fall back
+      // to the newest run, same as focusedRun().
+      const run = runs[0];
+      if (run.id === this.focusId) return;
+      this.focusId = run.id;
+    } else {
+      const next = runs[(idx + direction + runs.length) % runs.length];
+      if (next.id === this.focusId) return;
+      this.focusId = next.id;
+    }
     this.resetRunView();
     this.tui.requestRender();
   }
@@ -282,7 +324,11 @@ export class SubagentViewPanel implements Component, Focusable {
       return;
     }
     if (matchesKey(data, Key.tab)) {
-      this.cycleRun();
+      this.cycleRun(1);
+      return;
+    }
+    if (matchesKey(data, "shift+tab")) {
+      this.cycleRun(-1);
       return;
     }
     const ch = printableChar(data);
@@ -351,8 +397,7 @@ export class SubagentViewPanel implements Component, Focusable {
       return truncateToWidth(indent + formatThinking(e.status, fg), width);
     }
     if (e.kind === "steer") {
-      const firstLine = (e.text ?? "").trimEnd().split("\n")[0] || "";
-      return truncateToWidth(indent + fg("accent", `↩ steer: ${firstLine}`), width);
+      return truncateToWidth(indent + formatDisplayItem({ type: "steer", text: e.text ?? "", status: e.status }, fg), width);
     }
     if (e.kind === "text") {
       const buffer = e.text ?? "";
@@ -482,25 +527,30 @@ export class SubagentViewPanel implements Component, Focusable {
     const runningCount = runs.filter((r) => r.state === "running").length;
     const focused = this.focusedRun();
 
-    // ── Tab row: one cell per run; the focused one is highlighted. ──
+    // ── Tab row: one cell per run; the focused one is highlighted. The
+    // archive can outgrow the row — window the cells around the focused one
+    // so focus never scrolls off-screen; Tab/⇧Tab walk the full list.
     if (runs.length > 0) {
       // Brackets stay on every cell, focused included — the selectedBg +
       // accent highlight is the indicator, so Tab doesn't shift text.
       const cells = runs.map((r) => {
-        const isFocused = r === focused;
-        const label = `${runIcon(r.snapshot, fg)} ${r.id} ${r.role}`;
-        const styled = isFocused ? th.bg("selectedBg", fg("accent", label)) : fg("dim", label);
-        return `[${styled}]`;
+        const label = `[${runIcon(r.snapshot, fg)} ${r.id} ${r.role}]`;
+        return r === focused ? th.bg("selectedBg", fg("accent", label)) : fg("dim", label);
       });
-      lines.push(
-        row(
-          `${fg("accent", th.bold("subagents"))} ${th.fg("dim", `${runningCount} running · ${runs.length} total · Tab switch`)}  ` +
-            cells.join(th.fg("dim", " ")),
-        ),
-      );
+      const header =
+        `${fg("accent", th.bold("subagents"))} ` +
+        th.fg("dim", `${runningCount} running · ${runs.length} total`) +
+        "  ";
+      const focusIdx = Math.max(0, runs.findIndex((r) => r === focused));
+      const win = windowTabCells(cells, focusIdx, innerW - visibleWidth(header));
+      const parts: string[] = [];
+      if (win.leftClipped) parts.push(fg("dim", "…"));
+      parts.push(...win.items);
+      if (win.rightClipped) parts.push(fg("dim", "…"));
+      lines.push(row(header + parts.join(th.fg("dim", " "))));
     } else {
-      // Empty registry — every run left the view (a run disappears once its
-      // result is in the conversation). Give the state real presence — a
+      // Empty registry — nothing was delegated this session and no
+      // foreground run is in flight. Give the state real presence — a
       // full-size panel with a centered message and the close hint — and
       // fold steer mode back to browse so Esc closes immediately.
       if (this.mode === "steer") {
@@ -510,12 +560,7 @@ export class SubagentViewPanel implements Component, Focusable {
       lines.push(row(""));
       lines.push(row(fg("muted", centerText("no subagent runs", innerW))));
       lines.push(
-        row(
-          fg(
-            "dim",
-            centerText("a run leaves the view once its result is in the conversation", innerW),
-          ),
-        ),
+        row(fg("dim", centerText("start one with subagent_delegate to see it here", innerW))),
       );
       lines.push(row(""));
       lines.push(row(""));
@@ -565,7 +610,7 @@ export class SubagentViewPanel implements Component, Focusable {
           lines.push(row(fg("dim", `steer → ${label} · press s`)));
         }
         const pageKey = this.page === "activity" ? "d brief" : "d activity";
-        lines.push(row(fg("dim", `↑↓ scroll · ${pageKey} · Tab run · s steer · Esc close`)));
+        lines.push(row(fg("dim", `↑↓ scroll · ${pageKey} · Tab/⇧Tab run · s steer · Esc close`)));
       }
     }