pi-jar 0.1.3 → 0.1.4

package/src/activity-view.ts

@@ -1,11 +1,12 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import type { DelegateRegistry, DelegateRun, SubagentRecord } from "./delegate.ts";
+import { duration, leafTodos, type DelegateRegistry, type DelegateRun, type SubagentRecord, type TranscriptEntry } from "./delegate.ts";
 import { safeLine } from "./diff-view.ts";
 import { icon, withIcon } from "./icons.ts";
 import { describe, elapsed, type ShellJob, type ShellManager } from "./shells.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 import { ACTIVE_STATES, cleanText } from "./status.ts";
+import type { Todo } from "./tasks.ts";
 
 /** What to select when the view opens. */
 export type ActivityTarget = { kind: "subagent" | "shell"; id: string };
@@ -25,11 +26,18 @@ type Entry =
   | { kind: "shell"; id: string; status: Status; label: string; job: Omit<ShellJob, "lines"> }
   | { kind: "role"; id: string; status: Status; label: string; role: ActivityRole };
 type Item = Entry | { kind: "header"; label: string };
+type Focus = "list" | "transcript" | "input";
 
 const COLOR: Record<Status, string> = { running: "accent", pending: "dim", success: "success", error: "error", stopped: "dim" };
 const ACTIONS = [{ key: "x" }, { key: "f" }] as const;
 const SHELL_TAIL = 400;
 const MAX_TASK_CHARS = 8000;
+/** Expanded tool output shows at most this many wrapped rows; the rest is summarized. */
+const MAX_OUTPUT_ROWS = 80;
+const MAX_ARGS_ROWS = 12;
+const LIVE_ROWS = 4;
+const MAX_DRAFT = 2000;
+const SPINNER = ["◐", "◓", "◑", "◒"];
 
 /** Left-pane rows: a header per non-empty section, then its entries. */
 function collect(sources: ActivitySources): Item[] {
@@ -60,39 +68,165 @@ function collect(sources: ActivitySources): Item[] {
 }
 
 /** `head` stays pinned above the scrolling `body`, so following a transcript never hides who is running and how. */
-interface Details { head: string[]; body: string[] }
+interface Details {
+  head: string[];
+  body: readonly string[];
+  /** Styles one body line; applied to the visible window only, so a 400-line shell tail costs a screenful. */
+  format?: (line: string) => string;
+}
+
+/**
+ * One collapsible piece of a subagent's details. `key` is stable across renders (the transcript entry
+ * itself, or a per-run object), so expansion state and cached rows survive live updates.
+ */
+interface Block {
+  key: object;
+  /** Changes whenever the block's content does. */
+  rev: string;
+  expandable: boolean;
+  /** Expanded unless the user toggled it. */
+  open: boolean;
+  /** Rows for the given state, without the two-column gutter. */
+  rows(expanded: boolean, width: number): string[];
+}
+
+const wrap = (text: string, width: number) => {
+  const rows: string[] = [];
+  for (const raw of text.split("\n")) for (const line of wrapTextWithAnsi(safeLine(raw), Math.max(1, width))) rows.push(line);
+  return rows;
+};
+const firstLine = (text: string) => { const end = text.indexOf("\n"); return end < 0 ? text : text.slice(0, end); };
+const lineCount = (text: string) => { let count = 1; for (let index = text.indexOf("\n"); index >= 0; index = text.indexOf("\n", index + 1)) count++; return count; };
+const clipped = (rows: string[], limit: number, fg: Fg) => rows.length <= limit ? rows : [...rows.slice(0, limit), fg("dim", `… ${rows.length - limit} more lines`)];
+
+function todoRows(todos: readonly Todo[], width: number, fg: Fg): string[] {
+  const counts = new Map<string, { done: number; total: number }>();
+  for (const todo of todos) if (todo.parentId) {
+    const count = counts.get(todo.parentId) ?? { done: 0, total: 0 };
+    count.total++;
+    if (todo.done) count.done++;
+    counts.set(todo.parentId, count);
+  }
+  return todos.map((todo) => {
+    const indent = todo.parentId ? "    " : "  ";
+    const count = counts.get(todo.id);
+    const suffix = count ? fg("dim", ` (${count.done}/${count.total})`) : "";
+    const room = Math.max(1, width - indent.length - 2 - (count ? `${count.done}/${count.total}`.length + 3 : 0));
+    const title = truncateToWidth(safeLine(todo.title), room);
+    if (todo.status === "completed") return fg("success", `${indent}✔ `) + fg("dim", "\x1b[9m" + title + "\x1b[29m") + suffix;
+    if (todo.status === "in_progress") return fg("accent", `${indent}◼ ${title}`) + suffix;
+    return fg("muted", `${indent}☐ ${title}`) + suffix;
+  });
+}
+
+/** Per-run keys for the blocks that are not transcript entries. */
+const runKeys = new WeakMap<DelegateRun, { task: object; todos: object; live: object; report: object }>();
+const keysOf = (run: DelegateRun) => {
+  let keys = runKeys.get(run);
+  if (!keys) { keys = { task: {}, todos: {}, live: {}, report: {} }; runKeys.set(run, keys); }
+  return keys;
+};
+
+function entryBlock(entry: TranscriptEntry, fg: Fg): Block {
+  if (entry.kind === "tool") {
+    const glyph = entry.status === "running" ? fg("accent", "●") : entry.status === "error" ? fg("error", "✖") : fg("success", "✔");
+    const took = entry.endedAt !== undefined ? fg("dim", ` · ${duration(entry.endedAt - entry.startedAt)}`) : fg("dim", " · running");
+    return {
+      key: entry, rev: `${entry.rev}`, expandable: true, open: false,
+      rows(expanded, width) {
+        const head = fg("dim", expanded ? "▾ " : "▸ ") + glyph + " " + fg("accent", entry.name) + (entry.hint ? " " + fg("muted", safeLine(entry.hint)) : "") + took;
+        if (!expanded) return [truncateToWidth(head, width)];
+        const rows = [truncateToWidth(head, width)];
+        if (entry.args && entry.args !== JSON.stringify(entry.hint)) rows.push(...clipped(wrap(entry.args, width - 4).map((line) => fg("dim", "    " + line)), MAX_ARGS_ROWS, fg));
+        if (entry.output) rows.push(...clipped(wrap(entry.output, width - 4).map((line) => fg(entry.status === "error" ? "error" : "muted", "    " + line)), MAX_OUTPUT_ROWS, fg));
+        else rows.push(fg("dim", entry.status === "running" ? "    (running…)" : "    (no output)"));
+        return rows;
+      }
+    };
+  }
+  const multi = entry.text.length > 60 || entry.text.includes("\n");
+  const [mark, tone] = entry.kind === "steer" ? ["› you: ", "accent"] : entry.kind === "note" ? ["! ", "warning"] : ["◆ ", "text"];
+  return {
+    key: entry, rev: `${entry.rev}`, expandable: multi, open: false,
+    rows(expanded, width) {
+      const chevron = multi ? fg("dim", expanded ? "▾ " : "▸ ") : "  ";
+      if (!expanded || !multi) {
+        const more = lineCount(entry.text) > 1 ? fg("dim", ` +${lineCount(entry.text) - 1} lines`) : "";
+        return [truncateToWidth(chevron + fg(tone, mark + safeLine(firstLine(entry.text))), Math.max(1, width - visibleWidth(more))) + more];
+      }
+      return [chevron + fg(tone, mark.trimEnd()), ...wrap(entry.text, width - 4).map((line) => fg(tone === "text" ? "text" : tone, "    " + line))];
+    }
+  };
+}
+
+/** Everything under a subagent's pinned head: its task, checklist, transcript, live text and report. */
+function subagentBlocks(run: DelegateRun, fg: Fg): Block[] {
+  const keys = keysOf(run);
+  const blocks: Block[] = [{
+    key: keys.task, rev: "task", expandable: true, open: false,
+    rows(expanded, width) {
+      if (!expanded) return [truncateToWidth(fg("dim", "▸ TASK  ") + fg("text", safeLine(firstLine(run.task))), width)];
+      return [fg("dim", "▾ TASK"), ...wrap(run.task.slice(0, MAX_TASK_CHARS), width - 4).map((line) => fg("text", "    " + line))];
+    }
+  }];
+  if (run.todos.length) {
+    const leaves = leafTodos(run.todos);
+    const done = leaves.filter((todo) => todo.done).length;
+    blocks.push({
+      key: keys.todos, rev: run.todos.map((todo) => todo.id + todo.status).join(), expandable: true, open: true,
+      rows(expanded, width) {
+        const head = fg("dim", (expanded ? "▾ " : "▸ ") + "TASKS ") + fg(done === leaves.length ? "success" : "accent", `${done}/${leaves.length} done`);
+        return expanded ? [head, ...todoRows(run.todos, width - 2, fg).map((row) => "  " + row)] : [head];
+      }
+    });
+  }
+  if (!run.transcript.length && !run.live) blocks.push({ key: keys.live, rev: "empty", expandable: false, open: true, rows: () => [fg("dim", "  (nothing yet)")] });
+  // Once finished, the last message is the report shown below: list it once.
+  const reported = !!run.output && run.state !== "working" && run.state !== "queued";
+  let last = -1;
+  if (reported) for (let index = run.transcript.length - 1; index >= 0 && last < 0; index--) if (run.transcript[index]!.kind === "text") last = index;
+  for (let index = 0; index < run.transcript.length; index++) if (index !== last) blocks.push(entryBlock(run.transcript[index]!, fg));
+  if (run.live) {
+    const live = run.live;
+    blocks.push({
+      // The text itself is the revision (it is capped, so its length stops changing); only a tail is wrapped.
+      key: keys.live, rev: live, expandable: false, open: true,
+      rows: (_expanded, width) => [fg("accent", "  ✎ writing…"),
+        ...wrap(live.slice(-Math.max(200, width * (LIVE_ROWS + 1))), width - 4).slice(-LIVE_ROWS).map((line) => fg("muted", "    " + line))]
+    });
+  }
+  if (reported) {
+    blocks.push({
+      key: keys.report, rev: run.output, expandable: true, open: true,
+      rows(expanded, width) {
+        const head = fg("dim", (expanded ? "▾ " : "▸ ") + "REPORT");
+        return expanded ? [head, ...wrap(run.output, width - 4).map((line) => fg("text", "    " + line))] : [head];
+      }
+    });
+  }
+  return blocks;
+}
 
-function subagentDetails(run: DelegateRun, status: Status, width: number, fg: Fg): Details {
+function subagentHead(run: DelegateRun, status: Status, width: number, fg: Fg): string[] {
   const facts = [
     run.startedAt !== undefined ? elapsed({ startedAt: run.startedAt, endedAt: run.endedAt }) : "",
-    `${run.tools} tool${run.tools === 1 ? "" : "s"}`, `${run.turns} turn${run.turns === 1 ? "" : "s"}`, `$${run.cost.toFixed(3)}`
+    `${run.tools} tool${run.tools === 1 ? "" : "s"}`, `${run.turns} turn${run.turns === 1 ? "" : "s"}`, `$${run.cost.toFixed(3)}`,
+    run.filesEdited.length ? `${run.filesEdited.length} edited` : "", run.steered ? `steered ${run.steered}×` : ""
   ].filter(Boolean);
   const head = [
     fg("accent", [run.name, run.role, run.model].filter(Boolean).join(" · ")),
     fg(COLOR[status], withIcon(status, status === "stopped" ? "stopped" : run.state)) + fg("dim", " · " + facts.join(" · "))
   ];
-  if (run.activity) head.push(fg("muted", run.activity));
+  // A turning glyph on the 1 s tick: a long tool call or a slow model still looks alive.
+  if (run.activity) head.push(fg("muted", (run.state === "working" ? SPINNER[Math.floor(Date.now() / 1000) % SPINNER.length] + " " : "") + run.activity));
   if (run.error && status !== "stopped") for (const line of wrapTextWithAnsi(safeLine(run.error), width).slice(0, 2)) head.push(fg("error", line));
-  const body = ["", fg("dim", "TASK")];
-  for (const raw of run.task.slice(0, MAX_TASK_CHARS).split("\n")) for (const line of wrapTextWithAnsi(safeLine(raw), width)) body.push(fg("text", line));
-  body.push("", fg("dim", "── transcript ──"));
-  if (!run.log.length) body.push(fg("dim", "(nothing yet)"));
-  for (const entry of run.log) {
-    const tone = entry.startsWith("▸ ") ? "accent" : "muted";
-    for (const line of wrapTextWithAnsi(entry, width)) body.push(fg(tone, line));
-  }
-  if (run.output) {
-    body.push("", fg("dim", "── report ──"));
-    for (const raw of run.output.split("\n")) for (const line of wrapTextWithAnsi(safeLine(raw), width)) body.push(fg("text", line));
-  }
-  return { head, body };
+  return head;
 }
 
 function shellDetails(job: Omit<ShellJob, "lines">, output: readonly string[], width: number, fg: Fg): Details {
   const head = [fg("accent", safeLine(describe(job))), fg("muted", "$ " + cleanText(job.command, 400)), fg("dim", withIcon("folder", safeLine(job.cwd)))];
-  const body = ["", ...output.map((line) => fg("muted", truncateToWidth(safeLine(line), width)))];
-  if (!output.length) body.push(fg("dim", "(no output yet)"));
-  return { head, body };
+  if (!output.length) return { head, body: ["", fg("dim", "(no output yet)")] };
+  return { head, body: ["", ...output], format: (line) => line && fg("muted", truncateToWidth(safeLine(line), width)) };
 }
 
 function roleDetails(role: ActivityRole, status: Status, width: number, fg: Fg): Details {
@@ -103,7 +237,8 @@ function roleDetails(role: ActivityRole, status: Status, width: number, fg: Fg):
 
 /**
  * Overlay: subagents, shells and other extensions' teammates on the left; the selected one's live
- * details on the right, following new output until scrolled up. x stops a subagent or kills a shell.
+ * details on the right, following new output until scrolled up. For subagents the details are
+ * collapsible blocks (task, checklist, each tool call, text, report) and `s` steers the run.
  */
 export async function openActivityView(ctx: ExtensionContext, sources: ActivitySources, initial?: ActivityTarget): Promise<void> {
   if (!ctx.hasUI || ctx.mode !== "tui") return;
@@ -124,8 +259,18 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
     let listTop = 0;
     let width = 80;
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
+    let pinnedRows = 0;
     let timer: NodeJS.Timeout | undefined;
     let closed = false;
+    let focus: Focus = "list";
+    let draft = "";
+    let inputRow = -1;
+    // Subagent body layout of the last render: which block starts at which body row.
+    let blocks: Block[] = [];
+    let offsets: number[] = [];
+    const cursors = new Map<string, object>();
+    const toggled = new WeakMap<object, boolean>();
+    const rowCache = new WeakMap<object, { sig: string; rows: string[] }>();
     const fg: Fg = (color, text) => theme.fg(color as never, text);
     const shells = sources.shells;
     const previous = shells?.onChange;
@@ -140,6 +285,19 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
       if (shells) shells.onChange = previous;
     };
     const close = () => { cleanup(); done(); };
+    const selected = (): Entry | undefined => { const item = items[at]; return item && item.kind !== "header" ? item : undefined; };
+    const steerable = () => { const item = selected(); return item?.kind === "subagent" && item.record.run.state === "working"; };
+    const isOpen = (block: Block) => block.expandable ? toggled.get(block.key) ?? block.open : true;
+    /** Rows of one block, rebuilt only when its content, state or width changed. */
+    const rowsOf = (block: Block, bodyWidth: number) => {
+      const expanded = isOpen(block);
+      const sig = `${block.rev}|${expanded}|${bodyWidth}`;
+      const cached = rowCache.get(block.key);
+      if (cached?.sig === sig) return cached.rows;
+      const rows = block.rows(expanded, bodyWidth);
+      rowCache.set(block.key, { sig, rows });
+      return rows;
+    };
     // Rows reorder live (finished subagents sink, old ones drop off): keep the selection by identity.
     const refresh = () => {
       const current = items[at];
@@ -155,6 +313,7 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
       for (let index = at + delta; index >= 0 && index < items.length; index += delta) {
         if (items[index]!.kind === "header") continue;
         at = index; follow = true; scroll = 0;
+        if (focus === "input") focus = "list";
         return;
       }
     };
@@ -164,25 +323,83 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
       // Scrolling up pauses follow; scrolling back down to the end resumes it.
       follow = delta > 0 && scroll >= maxScroll;
     };
+    const cursorIndex = () => {
+      const item = selected();
+      const key = item?.kind === "subagent" ? cursors.get(item.id) : undefined;
+      const index = key ? blocks.findIndex((block) => block.key === key) : -1;
+      return index >= 0 ? index : blocks.length - 1;
+    };
+    const setCursor = (index: number) => {
+      const item = selected();
+      if (item?.kind !== "subagent" || !blocks.length) return;
+      const target = Math.max(0, Math.min(blocks.length - 1, index));
+      cursors.set(item.id, blocks[target]!.key);
+      follow = false;
+      // Keep the block's first row in view.
+      const row = offsets[target] ?? 0;
+      if (row < scroll) scroll = row;
+      else if (row >= scroll + bodyRows) scroll = Math.min(maxScroll, row - bodyRows + 1);
+    };
+    const toggle = (index: number) => {
+      const block = blocks[index];
+      if (!block?.expandable) return;
+      toggled.set(block.key, !isOpen(block));
+      setCursor(index);
+    };
     const stopSelected = () => {
-      const item = items[at];
-      if (!item || item.kind === "header" || item.kind === "role" || (item.status !== "running" && item.status !== "pending")) return;
+      const item = selected();
+      if (!item || item.kind === "role" || (item.status !== "running" && item.status !== "pending")) return;
       try {
         if (item.kind === "subagent") sources.subagents.stop(item.id);
         else shells?.kill(item.id);
       } catch (error) { ctx.ui.notify("pi-jar: " + (error instanceof Error ? error.message : String(error)), "error"); }
     };
+    const send = () => {
+      const item = selected();
+      const text = draft.trim();
+      if (!text || item?.kind !== "subagent") return;
+      if (sources.subagents.steer(item.id, text)) { draft = ""; focus = "transcript"; follow = true; cursors.delete(item.id); }
+      else ctx.ui.notify("pi-jar: that subagent is not taking messages (it is not working)", "warning");
+    };
+    const input = (data: string) => {
+      if (matchesKey(data, Key.escape)) { focus = "transcript"; return; }
+      if (matchesKey(data, Key.enter)) { send(); return; }
+      if (matchesKey(data, Key.backspace) || data === "\x7f" || data === "\b") { draft = draft.slice(0, -1); return; }
+      // Typed or pasted text: drop terminal sequences and control characters; line breaks become spaces.
+      const text = stripTerminalSequences(data).replace(/[\r\n\t]+/g, " ").replace(/[\x00-\x1f\x7f]/g, "");
+      if (text) draft = (draft + text).slice(0, MAX_DRAFT);
+    };
     const component = {
       invalidate() {},
       dispose: cleanup,
       handleInput(data: string) {
+        if (focus === "input") { input(data); tui.requestRender(); return; }
+        const item = selected();
+        const subagent = item?.kind === "subagent";
+        if (focus === "transcript") {
+          if (matchesKey(data, Key.escape) || matchesKey(data, Key.tab) || matchesKey(data, Key.left) || data === "h") focus = "list";
+          else if (data === "q") return close();
+          else if (matchesKey(data, Key.up) || data === "k") setCursor(cursorIndex() - 1);
+          else if (matchesKey(data, Key.down) || data === "j") setCursor(cursorIndex() + 1);
+          else if (matchesKey(data, Key.enter) || data === " ") toggle(cursorIndex());
+          else if (matchesKey(data, Key.pageUp)) scrollBy(-Math.max(1, bodyRows - 2));
+          else if (matchesKey(data, Key.pageDown)) scrollBy(Math.max(1, bodyRows - 2));
+          else if (data === "f" || data === "G") follow = true;
+          else if (data === "s" && steerable()) focus = "input";
+          else if (data === "x") stopSelected();
+          else return;
+          tui.requestRender();
+          return;
+        }
         if (matchesKey(data, Key.escape) || data === "q") return close();
         if (matchesKey(data, Key.up) || data === "k") move(-1);
         else if (matchesKey(data, Key.down) || data === "j") move(1);
+        else if (subagent && (matchesKey(data, Key.tab) || matchesKey(data, Key.right) || data === "l" || matchesKey(data, Key.enter))) focus = "transcript";
         else if (matchesKey(data, Key.pageUp)) scrollBy(-Math.max(1, bodyRows - 2));
         else if (matchesKey(data, Key.pageDown)) scrollBy(Math.max(1, bodyRows - 2));
         else if (data === "f" || data === "G") follow = true;
         else if (matchesKey(data, Key.enter)) follow = !follow;
+        else if (data === "s" && steerable()) focus = "input";
         else if (data === "x") stopSelected();
         else return;
         tui.requestRender();
@@ -196,31 +413,92 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
           const index = listTop + row;
           if (!items[index] || items[index].kind === "header") return;
           if (index !== at) { at = index; follow = true; scroll = 0; }
+          focus = "list";
+          tui.requestRender();
+          return { handled: true, focus: true };
+        }
+        if (row >= pinnedRows && row < layout.rows && blocks.length && selected()?.kind === "subagent") {
+          // A click on a block's first row expands or collapses it; any other row just points the cursor at it.
+          const line = scroll + row - pinnedRows;
+          let index = -1;
+          for (let block = 0; block < offsets.length && offsets[block]! <= line; block++) index = block;
+          if (index < 0) return;
+          focus = "transcript";
+          if (offsets[index] === line) toggle(index); else setCursor(index);
           tui.requestRender();
           return { handled: true, focus: true };
         }
+        if (inputRow >= 0 && event.y === inputRow && steerable()) { focus = "input"; tui.requestRender(); return { handled: true, focus: true }; }
         const action = ACTIONS[event.y - layout.footerTop];
-        if (action) { component.handleInput(action.key); return { handled: true }; }
+        if (action) { const previousFocus = focus; focus = "list"; component.handleInput(action.key); focus = previousFocus; return { handled: true }; }
       },
       render(available: number): string[] {
         width = Math.max(24, available);
-        const rows = contentRows(6 + ACTIONS.length, 6);
         refresh();
-        const picked = items[at];
-        const item = picked && picked.kind !== "header" ? picked : undefined;
+        const item = selected();
+        const subagent = item?.kind === "subagent" ? item : undefined;
+        if (!subagent && focus !== "list") focus = "list";
+        if (focus === "input" && !steerable()) focus = "transcript";
         const listWidth = sidebarWidth(width, 20, 34);
         const bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
         const entries = items.filter((entry): entry is Entry => entry.kind !== "header");
-        const details = !item ? { head: [fg("dim", "Nothing to show.")], body: [] }
-          : item.kind === "subagent" ? subagentDetails(item.record.run, item.status, bodyWidth, fg)
+        // Footer: the two actions, the steering input for subagents, then key hints.
+        const actions = optionList(theme, [item?.kind === "shell" ? "Kill the selected shell" : item?.kind === "role" ? "Stop (teammates from other extensions are read-only)" : "Stop the selected subagent",
+          "Follow the latest output"], -1, ACTIONS.map((action) => action.key));
+        const stoppable = item?.kind === "subagent" ? item.status === "running" || item.status === "pending" : item?.kind === "shell" && item.status === "running";
+        if (!stoppable) actions[0] = fg("dim", stripTerminalSequences(actions[0]!));
+        const footer = [...actions];
+        if (subagent) {
+          const room = Math.max(4, width - 16);
+          footer.push(focus === "input"
+            ? fg("accent", "› steer: ") + fg("text", truncateToWidth(draft.length > room ? "…" + draft.slice(-room + 1) : draft, room)) + fg("accent", "█")
+            : fg("dim", steerable() ? "› s  steer this subagent (type a message, Enter sends)" : "› steering works while a subagent is running"));
+        }
+        footer.push(fg("dim", focus === "input" ? `type a message · ${withIcon("enter", "send")} · ${withIcon("esc", "cancel")}`
+          : focus === "transcript" ? `↑↓ step · ${withIcon("enter", "expand")} · tab list · s steer · ${withIcon("esc", "back")}`
+          : `↑↓ select · ${subagent ? "tab transcript" : "PgUp/PgDn scroll"} · ${withIcon("enter", subagent ? "open" : "follow")} · ${withIcon("esc", "close")}`));
+        const rows = contentRows(3 + footer.length, 6);
+        const details: Details | undefined = !item || item.kind === "subagent" ? undefined
           : item.kind === "shell" ? shellDetails(item.job, shells?.output(item.id, SHELL_TAIL) ?? [], bodyWidth, fg)
           : roleDetails(item.role, item.status, bodyWidth, fg);
+        const head = !item ? [fg("dim", "Nothing to show.")] : item.kind === "subagent" ? subagentHead(item.record.run, item.status, bodyWidth, fg) : details!.head;
         // Narrow terminals drop the list: a pager row above the pinned facts says what is selected.
         const pinned = [...(!listWidth && item ? [fg("accent", `‹ ${entries.indexOf(item) + 1}/${entries.length} ${withIcon(item.status, item.label)} ›`)] : []),
-          ...details.head].slice(0, rows - 1);
+          ...head].slice(0, rows - 1);
+        pinnedRows = pinned.length;
         bodyRows = rows - pinned.length;
-        maxScroll = Math.max(0, details.body.length - bodyRows);
-        scroll = follow ? maxScroll : Math.min(scroll, maxScroll);
+        let body: string[];
+        if (subagent) {
+          blocks = subagentBlocks(subagent.record.run, fg);
+          const blockRows = blocks.map((block) => rowsOf(block, bodyWidth - 2));
+          offsets = [];
+          let total = 0;
+          for (const block of blockRows) { offsets.push(total); total += block.length; }
+          // A blank row separates the pinned head from the blocks.
+          offsets = offsets.map((offset) => offset + 1);
+          total += 1;
+          maxScroll = Math.max(0, total - bodyRows);
+          scroll = follow ? maxScroll : Math.min(scroll, maxScroll);
+          // Only the visible window gets its gutter: long transcripts cost nothing off-screen.
+          const cursor = focus === "transcript" ? cursorIndex() : -1;
+          body = scroll === 0 ? [""] : [];
+          for (let index = 0; index < blocks.length && body.length < bodyRows; index++) {
+            const start = offsets[index]!;
+            const rowsInBlock = blockRows[index]!;
+            if (start + rowsInBlock.length <= scroll) continue;
+            for (let line = Math.max(0, scroll - start); line < rowsInBlock.length && body.length < bodyRows; line++) {
+              body.push((line === 0 && index === cursor ? fg("accent", "❯ ") : "  ") + rowsInBlock[line]!);
+            }
+          }
+        } else {
+          blocks = [];
+          offsets = [];
+          const lines = details?.body ?? [];
+          maxScroll = Math.max(0, lines.length - bodyRows);
+          scroll = follow ? maxScroll : Math.min(scroll, maxScroll);
+          body = lines.slice(scroll, scroll + bodyRows);
+          if (details?.format) body = body.map(details.format);
+        }
         if (at >= 0 && at < listTop) listTop = items[at - 1]?.kind === "header" ? at - 1 : at;
         if (at >= listTop + rows) listTop = at - rows + 1;
         listTop = Math.max(0, Math.min(listTop, items.length - rows));
@@ -228,18 +506,13 @@ export async function openActivityView(ctx: ExtensionContext, sources: ActivityS
           if (entry.kind === "header") return fg("dim", truncateToWidth(entry.label, listWidth));
           const active = listTop + offset === at;
           const glyph = icon(entry.status);
-          return fg(active ? "accent" : "muted", active ? "▌" : " ") + fg(COLOR[entry.status], glyph + " ")
+          return fg(active ? "accent" : "muted", active ? (focus === "list" ? "▌" : "▏") : " ") + fg(COLOR[entry.status], glyph + " ")
             + fg(active ? "accent" : "muted", truncateToWidth(entry.label, Math.max(1, listWidth - 2 - visibleWidth(glyph))));
         }) : [];
         const running = entries.filter((entry) => entry.status === "running").length;
-        const stoppable = item?.kind === "subagent" ? item.status === "running" || item.status === "pending" : item?.kind === "shell" && item.status === "running";
-        const actions = optionList(theme, [item?.kind === "shell" ? "Kill the selected shell" : item?.kind === "role" ? "Stop (teammates from other extensions are read-only)" : "Stop the selected subagent",
-          "Follow the latest output"], -1, ACTIONS.map((action) => action.key));
-        if (!stoppable) actions[0] = fg("dim", stripTerminalSequences(actions[0]!));
-        const footer = [...actions, fg("dim", `↑↓ select · PgUp/PgDn scroll · ${withIcon("enter", "follow")} · ${withIcon("esc", "close")}`)];
-        const split = splitFrame(theme, width, `ACTIVITY · ${running} running${follow ? "" : " · paused"}`, list,
-          [...pinned, ...details.body.slice(scroll, scroll + bodyRows)], footer, rows, listWidth);
+        const split = splitFrame(theme, width, `ACTIVITY · ${running} running${follow ? "" : " · paused"}`, list, [...pinned, ...body], footer, rows, listWidth);
         layout = split.layout;
+        inputRow = subagent ? layout.footerTop + ACTIONS.length : -1;
         // Subagent events and shell exits repaint through the listeners; elapsed times and shell output
         // advance on a 1s tick that exists only while something runs.
         if (running && !timer && !closed) { timer = setInterval(() => tui.requestRender(), 1000); timer.unref?.(); }

package/src/advisor.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { ModelRoleManager } from "./model-roles.ts";
@@ -16,6 +17,8 @@ export const FAILURE_STREAK = 3;
 /** Automatic consultations allowed per user prompt. */
 export const GATES_PER_PROMPT = 2;
 const WINDOW = 8;
+/** Serialized inputs up to this length stay verbatim in a loop key; longer ones keep a prefix and a digest. */
+const KEY_INPUT_CHARS = 1024;
 
 export const ADVISOR_SYSTEM = [
   "You are the advisor: a senior engineer giving a second opinion to a coding agent (the executor) mid-task.",
@@ -85,8 +88,11 @@ export function advisorPrompt(request: AdvisorRequest, conversation: string, git
   ].filter(Boolean).join("\n\n");
 }
 
-/** Stable key for loop detection. */
-export const callKey = (tool: string, input: unknown) => tool + " " + JSON.stringify(input ?? {});
+/** Stable key for loop detection. A `write` of a large file must not pin its whole content in the recent window. */
+export function callKey(tool: string, input: unknown): string {
+  const json = String(JSON.stringify(input ?? {}));
+  return tool + " " + (json.length <= KEY_INPUT_CHARS ? json : json.slice(0, 200) + "…#" + createHash("sha1").update(json).digest("hex"));
+}
 
 /** Tracks repeated calls and failure streaks within one user prompt. */
 export class StuckDetector {
@@ -181,7 +187,7 @@ export function registerAdvisor(pi: ExtensionAPI, roles: ModelRoleManager, optio
       const focus = args.trim();
       ctx.ui.notify("Consulting the advisor…", "info");
       try {
-        const answer = await consult(ctx, focus ? { question: focus } : {});
+        const answer = await consult(ctx, focus ? { question: focus } : {}, ctx.signal);
         deliver(ctx, `◆ Advisor · ${answer.model}${focus ? " · " + focus : ""}`, answer.text);
       } catch (error) { ctx.ui.notify("Advisor failed: " + (error instanceof Error ? error.message : String(error)), "error"); }
     }

package/src/changes.ts

@@ -104,7 +104,8 @@ export class ChangeTracker {
   private readonly cwd: () => string;
   constructor(cwd: () => string) { this.cwd = cwd; }
 
-  private absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
+  /** Resolve like every other tracker method; baselines are keyed by this absolute path. */
+  absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
   private bytes(content: string | null): number { return content === null ? 0 : Buffer.byteLength(content, "utf8"); }
   private drop(target: string): void {
     if (this.baselines.has(target)) this.baselineBytes = Math.max(0, this.baselineBytes - this.bytes(this.baselines.get(target)!));
@@ -112,23 +113,46 @@ export class ChangeTracker {
     this.dirty.delete(target);
   }
 
-  /** Record the pre-change content once; returns false when the file cannot be tracked. */
-  capture(path: string): boolean {
-    const target = this.absolute(path);
-    if (this.baselines.has(target)) return true;
-    // Only project files: plan files and scratch space elsewhere are not part of the review.
+  /**
+   * Store a baseline when the file is inside the project (plan files and scratch space elsewhere are
+   * not reviewed) and within the file/byte caps. `content` is lazy so outside files are never read.
+   */
+  private admit(target: string, content: () => string | null | undefined): boolean {
     const rel = relative(this.cwd(), target);
     if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
     if (this.baselines.size >= MAX_TRACKED_FILES) return false;
-    const content = readText(target);
-    if (content === undefined) return false;
-    const bytes = this.bytes(content);
-    if (this.baselineBytes + bytes > MAX_TRACKED_TOTAL_BYTES) return false;
-    this.baselines.set(target, content);
+    const before = content();
+    if (before === undefined) return false;
+    const bytes = this.bytes(before);
+    if (bytes > MAX_TRACKED_BYTES || this.baselineBytes + bytes > MAX_TRACKED_TOTAL_BYTES) return false;
+    this.baselines.set(target, before);
     this.baselineBytes += bytes;
     return true;
   }
 
+  /** Record the pre-change content once; returns false when the file cannot be tracked. */
+  capture(path: string): boolean {
+    const target = this.absolute(path);
+    return this.baselines.has(target) || this.admit(target, () => readText(target));
+  }
+
+  /** Captured pre-change content (`null` = file did not exist), or `undefined` when untracked. */
+  baseline(path: string): string | null | undefined {
+    const target = this.absolute(path);
+    return this.baselines.has(target) ? this.baselines.get(target)! : undefined;
+  }
+
+  /**
+   * Take over a baseline captured elsewhere (a subagent's first-edit content) and mark the file
+   * dirty. An existing baseline is older and wins, so each absolute path counts once.
+   */
+  adopt(path: string, baseline: string | null): boolean {
+    const target = this.absolute(path);
+    if (!this.baselines.has(target) && !this.admit(target, () => baseline)) return false;
+    this.dirty.add(target);
+    return true;
+  }
+
   /**
    * Mark one captured file after a successful edit/write. Do not synchronously re-read the file on
    * every tool result; the review UI reconciles content lazily when /diff is actually opened.

package/src/child-baselines.ts

@@ -0,0 +1,42 @@
+import { createHash } from "node:crypto";
+import { existsSync, linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Directory a parent hands to a subagent so the child can report each file's content before its
+ * first edit/write. The parent then adopts those baselines into its own `/diff` review.
+ */
+export const CHILD_BASELINE_ENV = "PI_JAR_BASELINE_DIR";
+
+type BaselineRecord = { path: string; content: string | null };
+
+/** Writer and reader must agree on the name: one JSON file per absolute path. */
+const fileFor = (dir: string, absPath: string) => join(dir, createHash("sha1").update(absPath).digest("hex") + ".json");
+
+/**
+ * Store the pre-change content (`null` = file did not exist) once per absolute path. The first
+ * write wins: the temp file is hard-linked into place, which fails instead of replacing an
+ * existing baseline, so readers never see a partial or newer record. Throws on I/O failure.
+ */
+export function writeChildBaseline(dir: string, absPath: string, content: string | null): void {
+  const target = fileFor(dir, absPath);
+  const temp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  if (existsSync(target)) return;
+  mkdirSync(dir, { recursive: true });
+  try {
+    writeFileSync(temp, JSON.stringify({ path: absPath, content } satisfies BaselineRecord));
+    linkSync(temp, target);
+  } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; }
+  finally { rmSync(temp, { force: true }); }
+}
+
+/** The recorded baseline, or `undefined` when absent, unreadable or malformed. */
+export function readChildBaseline(dir: string, absPath: string): string | null | undefined {
+  let record: unknown;
+  try { record = JSON.parse(readFileSync(fileFor(dir, absPath), "utf8")); }
+  catch { return undefined; } // absent or corrupt: the parent simply does not adopt this file
+  if (!record || typeof record !== "object") return undefined;
+  const { path, content } = record as Partial<BaselineRecord>;
+  if (path !== absPath || (content !== null && typeof content !== "string")) return undefined;
+  return content;
+}