pi-jar 0.1.2 → 0.1.3

package/src/activity-view.ts

@@ -0,0 +1,252 @@
+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 { 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";
+
+/** What to select when the view opens. */
+export type ActivityTarget = { kind: "subagent" | "shell"; id: string };
+/** A teammate another extension publishes through the role-status contract; listed read-only. */
+export interface ActivityRole { id: string; name: string; state: string; task?: string }
+export interface ActivitySources {
+  subagents: DelegateRegistry;
+  shells?: ShellManager;
+  roles?: () => ActivityRole[];
+}
+
+/** Doubles as the icon key for the row glyph. */
+type Status = "running" | "pending" | "success" | "error" | "stopped";
+type Fg = (color: string, text: string) => string;
+type Entry =
+  | { kind: "subagent"; id: string; status: Status; label: string; record: SubagentRecord }
+  | { 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 };
+
+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;
+
+/** Left-pane rows: a header per non-empty section, then its entries. */
+function collect(sources: ActivitySources): Item[] {
+  const items: Item[] = [];
+  const records = sources.subagents.records();
+  if (records.length) items.push({ kind: "header", label: withIcon("subagents", "SUBAGENTS") });
+  for (const record of records) {
+    const { run } = record;
+    const status: Status = run.state === "working" ? "running" : run.state === "queued" ? "pending" : run.state === "done" ? "success" : run.error === "stopped" ? "stopped" : "error";
+    items.push({ kind: "subagent", id: record.key, status, label: run.name, record });
+  }
+  const jobs = sources.shells?.summaries() ?? [];
+  if (jobs.length) items.push({ kind: "header", label: withIcon("shell", "SHELLS") });
+  for (const job of jobs) {
+    const status: Status = job.status === "running" ? "running" : job.status === "exited" && job.exitCode === 0 ? "success" : job.status === "killed" ? "stopped" : "error";
+    items.push({ kind: "shell", id: job.id, status, label: `${job.id} ${job.name}`, job });
+  }
+  let roles: ActivityRole[] = [];
+  try { roles = sources.roles?.() ?? []; } catch { /* teammates are decoration */ }
+  // jar_delegate publishes each run as a role status under its record key: list those once, as subagents.
+  roles = roles.filter((role) => !sources.subagents.get(role.id));
+  if (roles.length) items.push({ kind: "header", label: withIcon("roles", "ROLES") });
+  for (const role of roles) {
+    const status: Status = (ACTIVE_STATES as ReadonlySet<string>).has(role.state) ? "running" : role.state === "done" ? "success" : role.state === "failed" ? "error" : "pending";
+    items.push({ kind: "role", id: role.id, status, label: cleanText(role.name, 32) || role.id, role });
+  }
+  return items;
+}
+
+/** `head` stays pinned above the scrolling `body`, so following a transcript never hides who is running and how. */
+interface Details { head: string[]; body: string[] }
+
+function subagentDetails(run: DelegateRun, status: Status, width: number, fg: Fg): Details {
+  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)}`
+  ].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));
+  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 };
+}
+
+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 };
+}
+
+function roleDetails(role: ActivityRole, status: Status, width: number, fg: Fg): Details {
+  const head = [fg("accent", cleanText(role.name, 60) || role.id), fg(COLOR[status], withIcon(status, cleanText(role.state, 24))) + fg("dim", " · read-only")];
+  const body = role.task ? ["", fg("dim", "TASK"), ...wrapTextWithAnsi(cleanText(role.task, 400), width).map((line) => fg("text", line))] : [];
+  return { head, body };
+}
+
+/**
+ * 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.
+ */
+export async function openActivityView(ctx: ExtensionContext, sources: ActivitySources, initial?: ActivityTarget): Promise<void> {
+  if (!ctx.hasUI || ctx.mode !== "tui") return;
+  const opening = collect(sources);
+  if (!opening.some((item) => item.kind !== "header")) {
+    ctx.ui.notify("pi-jar: nothing running (subagents come from jar_delegate, shells from jar_shell)", "info");
+    return;
+  }
+  await ctx.ui.custom<void>((tui, theme, _keys, done) => {
+    let items = opening;
+    let at = initial ? items.findIndex((item) => item.kind !== "header" && item.kind === initial.kind && item.id === initial.id) : -1;
+    if (at < 0) at = items.findIndex((item) => item.kind !== "header" && item.status === "running");
+    if (at < 0) at = items.findIndex((item) => item.kind !== "header");
+    let follow = true;
+    let scroll = 0;
+    let maxScroll = 0;
+    let bodyRows = 0;
+    let listTop = 0;
+    let width = 80;
+    let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
+    let timer: NodeJS.Timeout | undefined;
+    let closed = false;
+    const fg: Fg = (color, text) => theme.fg(color as never, text);
+    const shells = sources.shells;
+    const previous = shells?.onChange;
+    const unsubscribe = sources.subagents.subscribe(() => tui.requestRender());
+    if (shells) shells.onChange = () => { previous?.(); tui.requestRender(); };
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      clearInterval(timer);
+      timer = undefined;
+      unsubscribe();
+      if (shells) shells.onChange = previous;
+    };
+    const close = () => { cleanup(); done(); };
+    // Rows reorder live (finished subagents sink, old ones drop off): keep the selection by identity.
+    const refresh = () => {
+      const current = items[at];
+      items = collect(sources);
+      const same = current && current.kind !== "header" ? items.findIndex((item) => item.kind !== "header" && item.kind === current.kind && item.id === current.id) : -1;
+      if (same >= 0) { at = same; return; }
+      const from = Math.max(0, Math.min(at, items.length - 1));
+      at = -1;
+      for (let index = from; index < items.length && at < 0; index++) if (items[index]!.kind !== "header") at = index;
+      for (let index = from - 1; index >= 0 && at < 0; index--) if (items[index]!.kind !== "header") at = index;
+    };
+    const move = (delta: number) => {
+      for (let index = at + delta; index >= 0 && index < items.length; index += delta) {
+        if (items[index]!.kind === "header") continue;
+        at = index; follow = true; scroll = 0;
+        return;
+      }
+    };
+    const scrollBy = (delta: number) => {
+      if (!maxScroll) return;
+      scroll = Math.max(0, Math.min(maxScroll, scroll + delta));
+      // Scrolling up pauses follow; scrolling back down to the end resumes it.
+      follow = delta > 0 && scroll >= maxScroll;
+    };
+    const stopSelected = () => {
+      const item = items[at];
+      if (!item || item.kind === "header" || 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 component = {
+      invalidate() {},
+      dispose: cleanup,
+      handleInput(data: string) {
+        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 (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 === "x") stopSelected();
+        else return;
+        tui.requestRender();
+      },
+      handleMouse(event: TuiMouseEvent) {
+        if (event.type === "wheel" && event.wheelDelta) { scrollBy(Math.sign(event.wheelDelta) * 3); tui.requestRender(); return { handled: true }; }
+        if (event.type !== "click" || event.button !== "left") return;
+        if (event.y === 0 && event.x >= width - 3) { close(); return { handled: true }; }
+        const row = event.y - layout.top;
+        if (layout.leftWidth && row >= 0 && row < layout.rows && event.x < layout.leftWidth + 3) {
+          const index = listTop + row;
+          if (!items[index] || items[index].kind === "header") return;
+          if (index !== at) { at = index; follow = true; scroll = 0; }
+          tui.requestRender();
+          return { handled: true, focus: true };
+        }
+        const action = ACTIONS[event.y - layout.footerTop];
+        if (action) { component.handleInput(action.key); 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 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)
+          : item.kind === "shell" ? shellDetails(item.job, shells?.output(item.id, SHELL_TAIL) ?? [], bodyWidth, fg)
+          : roleDetails(item.role, item.status, bodyWidth, fg);
+        // 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);
+        bodyRows = rows - pinned.length;
+        maxScroll = Math.max(0, details.body.length - bodyRows);
+        scroll = follow ? maxScroll : Math.min(scroll, maxScroll);
+        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));
+        const list = listWidth ? items.slice(listTop, listTop + rows).map((entry, offset) => {
+          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 + " ")
+            + 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);
+        layout = split.layout;
+        // 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?.(); }
+        else if (!running && timer) { clearInterval(timer); timer = undefined; }
+        return available < width ? split.lines.map((line) => truncateToWidth(line, Math.max(0, available))) : split.lines;
+      }
+    };
+    return component;
+  }, { overlay: true, overlayOptions: { width: "100%", maxHeight: "100%" } });
+}

package/src/composer.ts

@@ -4,6 +4,11 @@ import { Mascot, MASCOT_FACE_WIDTH, mascotFace, paintFace, paintTip, type Mascot
 import type { SuggestionState } from "./suggest.ts";
 import type { WorkingPhase } from "./working.ts";
 import { imageChip, imageInfo, imagePaths } from "./attachments.ts";
+// Aliased: roundedInput has a parameter named `icon`.
+import { icon as glyph, type IconKey } from "./icons.ts";
+
+/** `⏎ send`; ascii spells the key out (`enter send`). */
+const keyHint = (key: IconKey, action: string) => glyph(key) + " " + action;
 
 type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 type MouseEvent = Parameters<NonNullable<EditorComponent["handleMouse"]>>[0];
@@ -12,6 +17,8 @@ const PHASE_MOODS: Record<WorkingPhase, readonly MascotMood[]> = {
   idle: ["idle"], generating: ["happy", "thinking"], tool: ["tool"], waiting: ["waiting"]
 };
 export const COMPOSER_ACTIVE_INTERVAL_MS = 600;
+/** How long composer image chips trust a previous filesystem check for the same draft. */
+const ATTACHMENT_RECHECK_MS = 1000;
 /** Plain one-line face for a phase; every phase has the same width. */
 export function composerIcon(phase: WorkingPhase, frame = 0): string {
   const moods = PHASE_MOODS[phase];
@@ -95,7 +102,9 @@ export function roundedInput(lines: string[], width: number, focused: boolean, t
     if (index === 0 && options.ghost && row.includes(CURSOR)) {
       const base = row.replace(/ +$/, "");
       const room = inner - visibleWidth(base);
-      if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   ⇥ tab", room, "…"));
+      // ascii's tab "icon" is already the word.
+      const tab = glyph("tab") === "tab" ? "tab" : keyHint("tab", "tab");
+      if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   " + tab, room, "…"));
     }
     const fitted = truncateToWidth(row, inner);
     return border("│") + fitted + " ".repeat(Math.max(0, inner - visibleWidth(fitted))) + border("│");
@@ -159,7 +168,9 @@ class RoundedEditor extends CustomEditor {
 
   override render(width: number): string[] {
     const inner = this.renderTall(width < 8 ? width : width - 2);
-    const empty = this.getText() === "";
+    const text = this.getText();
+    const empty = text === "";
+    const below = this.decor.attachments(text);
     const ghost = empty && !this.isShowingAutocomplete() ? this.decor.ghost() : undefined;
     this.ghostShown = !!ghost;
     const visibleRows = (this as unknown as { renderedVisibleLineCount?: number }).renderedVisibleLineCount;
@@ -167,7 +178,7 @@ class RoundedEditor extends CustomEditor {
       ...(ghost ? { ghost } : {}), ...(this.decor.hint() ? { hint: this.decor.hint()! } : {}),
       ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}),
       ...(visibleRows != null ? { visibleRows } : {}), dim: this.decor.dim,
-      ...(this.decor.attachments(this.getText()) ? { below: this.decor.attachments(this.getText())! } : {})
+      ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
@@ -230,10 +241,12 @@ class ThemedEditor implements EditorComponent {
   }
   invalidate() { this.base.invalidate(); }
   render(width: number): string[] {
-    const ghost = this.base.getText() === "" ? this.decor.ghost() : undefined;
+    const text = this.base.getText();
+    const ghost = text === "" ? this.decor.ghost() : undefined;
+    const below = this.decor.attachments(text);
     const framed = roundedInput(this.base.render(width < 8 ? width : width - 2), width, this.focused, this.theme, this.paint, this.decor.icon(), this.decor.session(), {
       ...(ghost ? { ghost } : {}), ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}), dim: this.decor.dim,
-      ...(this.decor.attachments(this.base.getText()) ? { below: this.decor.attachments(this.base.getText())! } : {})
+      ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
@@ -269,6 +282,8 @@ export class ComposerStyle {
   private suggestions?: SuggestionState;
   private unsubscribe?: () => void;
   private colors?: { fg(color: string, text: string): string };
+  /** Chips for the last draft; image paths hit the filesystem, so reuse them briefly across repaints. */
+  private chips?: { text: string; cwd: string; at: number; chips: string[] };
 
   private readonly decor: ComposerDecor = {
     icon: () => this.mascotOn ? mascotFace(this.animations ? this.mascot.mood() : "idle") : "pi",
@@ -286,7 +301,9 @@ export class ComposerStyle {
     },
     session: () => this.session,
     ghost: () => this.suggestions?.text,
-    hint: () => this.suggestions?.text ? "⇥ accept · ⏎ send · ⇧⏎ newline" : "⏎ send · ⇧⏎ newline · /plan · /goal",
+    hint: () => this.suggestions?.text
+      ? `${keyHint("tab", "accept")} · ${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")}`
+      : `${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")} · /plan · /goal`,
     accept: () => {
       const text = this.suggestions?.text;
       if (text) this.suggestions!.clear();
@@ -297,9 +314,13 @@ export class ComposerStyle {
     dim: (text) => this.colors?.fg("dim", text) ?? `\x1b[2m${text}\x1b[22m`,
     attachments: (text) => {
       if (!/\.(png|jpe?g|gif|webp)\b/i.test(text)) return undefined;
-      const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
-      if (!chips.length) return undefined;
-      return chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
+      const now = Date.now();
+      if (this.chips?.text !== text || this.chips.cwd !== this.cwd || now - this.chips.at >= ATTACHMENT_RECHECK_MS) {
+        const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
+        this.chips = { text, cwd: this.cwd, at: now, chips };
+      }
+      if (!this.chips.chips.length) return undefined;
+      return this.chips.chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
     }
   };
 

package/src/delegate.ts

@@ -18,6 +18,14 @@ const TIMEOUT_MS = 20 * 60_000;
 const STATUS_REFRESH_MS = 20_000;
 const LIVE_UPDATE_MS = 1000;
 const MAX_EVENT_TEXT = 16_000;
+const MAX_LOG_LINES = 200;
+const MAX_LOG_CHARS = 240;
+/** Finished subagents the registry keeps for the activity view after their tool call returns. */
+const MAX_FINISHED = 8;
+/** Abort reason for stopping one subagent from the activity view (vs. aborting the whole tool call). */
+const STOP_REASON = "stopped";
+/** Tool arguments that best describe a call in the transcript, most telling first. */
+const HINT_KEYS = ["command", "path", "file_path", "pattern", "query", "url"] as const;
 
 export type DelegateState = "queued" | "working" | "done" | "failed";
 export interface DelegateRun {
@@ -33,6 +41,10 @@ export interface DelegateRun {
   cost: number;
   output: string;
   error?: string;
+  startedAt?: number;
+  endedAt?: number;
+  /** Live transcript (tool calls, assistant text), last MAX_LOG_LINES; never copied into tool details. */
+  log: string[];
 }
 
 type Spawn = (command: string, args: string[], options: Parameters<typeof spawn>[2]) => ChildProcess;
@@ -73,6 +85,30 @@ const textOf = (message: { content?: unknown }, limit = MAX_EVENT_TEXT): string
   return out;
 };
 
+/** Append transcript lines, cleaned and clipped, keeping only the newest MAX_LOG_LINES. */
+const appendLog = (run: DelegateRun, lines: readonly string[]) => {
+  for (const raw of lines) { const line = cleanText(raw, MAX_LOG_CHARS); if (line) run.log.push(line); }
+  if (run.log.length > MAX_LOG_LINES) run.log.splice(0, run.log.length - MAX_LOG_LINES);
+};
+
+/** The argument that says what a tool call does: the bash command, the file path, the search pattern… */
+const toolHint = (args: unknown): string => {
+  if (!args || typeof args !== "object") return "";
+  for (const key of HINT_KEYS) {
+    const value = (args as Record<string, unknown>)[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+};
+
+/** The slice of Pi's JSON event stream a run reads; leaves are unknown because it is another process's output. */
+interface ChildEvent {
+  type?: unknown;
+  toolName?: unknown;
+  args?: unknown;
+  message?: { role?: unknown; content?: unknown; usage?: { cost?: { total?: unknown } }; stopReason?: unknown; errorMessage?: unknown };
+}
+
 /** Run one child Pi, feeding progress into `run` and calling `update` on every change. */
 export function runDelegate(run: DelegateRun, args: string[], cwd: string, signal: AbortSignal | undefined, update: () => void, spawnProcess: Spawn = spawn as Spawn): Promise<void> {
   return new Promise((resolve) => {
@@ -81,9 +117,10 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
     try {
       child = spawnProcess(invocation.command, invocation.args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, [CHILD_ENV]: "1" } });
     } catch (error) {
-      run.state = "failed"; run.error = error instanceof Error ? error.message : String(error); update(); resolve(); return;
+      run.state = "failed"; run.error = error instanceof Error ? error.message : String(error); run.endedAt = Date.now(); update(); resolve(); return;
     }
     run.state = "working";
+    run.startedAt = Date.now();
     run.activity = "starting";
     update();
     let buffer = "";
@@ -97,25 +134,36 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
       run.state = state;
       if (error) run.error = error;
       run.activity = undefined;
+      run.endedAt = Date.now();
       update();
       resolve();
     };
     const stop = () => { child.kill("SIGTERM"); setTimeout(() => { if (child.exitCode === null) child.kill("SIGKILL"); }, 3000).unref?.(); };
-    const abort = () => { stop(); finish("failed", "aborted"); };
+    // Stopping one run from the activity view reads "stopped"; aborting the whole tool call reads "aborted".
+    const abort = () => { stop(); finish("failed", signal?.reason === STOP_REASON ? "stopped" : "aborted"); };
     const timer = setTimeout(() => { stop(); finish("failed", "timed out"); }, TIMEOUT_MS);
     timer.unref?.();
     if (signal?.aborted) { abort(); return; }
     signal?.addEventListener("abort", abort, { once: true });
     const line = (raw: string) => {
-      if (!raw.trim()) return;
-      let event: any;
-      try { event = JSON.parse(raw); } catch { return; }
-      if (event.type === "tool_execution_start") { run.tools++; run.activity = cleanText(String(event.toolName ?? "tool"), 24); update(); }
+      // Output that arrives after an abort or timeout must not revive a finished run's activity.
+      if (finished || !raw.trim()) return;
+      let parsed: unknown;
+      try { parsed = JSON.parse(raw); } catch { return; }
+      if (!parsed || typeof parsed !== "object") return;
+      // Parsed child output: the object check above is all the cast assumes; every field stays unknown until read.
+      const event = parsed as ChildEvent;
+      if (event.type === "tool_execution_start") {
+        run.tools++;
+        run.activity = cleanText(String(event.toolName ?? "tool"), 24);
+        appendLog(run, [`▸ ${run.activity} ${toolHint(event.args)}`]);
+        update();
+      }
       else if (event.type === "message_end" && event.message?.role === "assistant") {
         run.turns++;
         run.cost += Number(event.message.usage?.cost?.total) || 0;
         const text = textOf(event.message).trim();
-        if (text) run.output = text.slice(0, MAX_OUTPUT_CHARS);
+        if (text) { run.output = text.slice(0, MAX_OUTPUT_CHARS); appendLog(run, text.split("\n").slice(-MAX_LOG_LINES)); }
         if (event.message.stopReason === "error" && event.message.errorMessage) run.error = cleanText(String(event.message.errorMessage), 200);
         run.activity = "thinking";
         update();
@@ -137,6 +185,81 @@ export function runDelegate(run: DelegateRun, args: string[], cwd: string, signa
   });
 }
 
+const isActive = (state: DelegateState) => state === "queued" || state === "working";
+
+export interface SubagentRecord { key: string; batch: number; run: DelegateRun; stop(): void }
+
+/**
+ * Live subagents for the activity view. Tool details are saved in the session, so they stay small;
+ * the transcript and the per-run stop handle live only here, for this process.
+ */
+export class DelegateRegistry {
+  private entries = new Map<string, { record: SubagentRecord; finished?: number }>();
+  private listeners = new Set<() => void>();
+  private sequence = 0;
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+  /** Queued/working first (oldest first), then finished ones newest first. */
+  records(): SubagentRecord[] {
+    this.sweep();
+    const live: SubagentRecord[] = [];
+    const finished: Array<{ record: SubagentRecord; finished: number }> = [];
+    for (const { record, finished: at } of this.entries.values()) {
+      if (at === undefined) live.push(record); else finished.push({ record, finished: at });
+    }
+    finished.sort((a, b) => b.finished - a.finished);
+    return [...live, ...finished.map((entry) => entry.record)];
+  }
+  get(key: string): SubagentRecord | undefined { return this.entries.get(key)?.record; }
+  /** Abort one queued/working run, leaving the rest of its batch alone; false when unknown or already finished. */
+  stop(key: string): boolean {
+    const record = this.entries.get(key)?.record;
+    if (!record || !isActive(record.run.state)) return false;
+    record.stop();
+    this.notify();
+    return true;
+  }
+  running(): number {
+    let count = 0;
+    for (const { record } of this.entries.values()) if (isActive(record.run.state)) count++;
+    return count;
+  }
+  /** Stop outstanding runs on session changes/shutdown and forget their transcript. */
+  clear(): void {
+    const stopping = [...this.entries.values()].filter(({ record }) => isActive(record.run.state)).map(({ record }) => record.stop);
+    this.entries.clear();
+    for (const stop of stopping) stop();
+    this.notify();
+  }
+  /** jar_delegate's side: list new runs. */
+  add(...records: SubagentRecord[]): void {
+    for (const record of records) this.entries.set(record.key, { record });
+    this.notify();
+  }
+  /** jar_delegate's side: a run changed. */
+  notify(): void {
+    this.sweep();
+    for (const listener of this.listeners) {
+      try { listener(); } catch { /* views are decoration; a broken one must not break the run */ }
+    }
+  }
+  /** Stamp runs in the order they finish and keep only the newest MAX_FINISHED of them. */
+  private sweep(): void {
+    let finished = 0;
+    for (const entry of this.entries.values()) {
+      if (isActive(entry.record.run.state)) continue;
+      entry.finished ??= ++this.sequence;
+      finished++;
+    }
+    if (finished <= MAX_FINISHED) return;
+    const oldest = [...this.entries].filter(([, entry]) => entry.finished !== undefined).sort((a, b) => a[1].finished! - b[1].finished!);
+    for (const [key] of oldest.slice(0, finished - MAX_FINISHED)) this.entries.delete(key);
+  }
+}
+
 const Parameters = Type.Object({
   tasks: Type.Array(Type.Object({
     task: Type.String({ description: "A complete, self-contained instruction: the subagent sees nothing else." }),
@@ -149,7 +272,8 @@ const Parameters = Type.Object({
 const glyph = (state: DelegateState) => state === "done" ? "✔" : state === "failed" ? "✖" : state === "working" ? "●" : "○";
 const color = (state: DelegateState) => state === "done" ? "success" : state === "failed" ? "error" : state === "working" ? "accent" : "dim";
 
-export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spawnProcess?: Spawn): void {
+/** jar_delegate. Every run is listed live in `registry` (with its transcript and a stop handle) for the activity view. */
+export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, registry: DelegateRegistry, spawnProcess?: Spawn): void {
   if (process.env[CHILD_ENV] || typeof (pi as ExtensionAPI & { registerTool?: unknown }).registerTool !== "function") return;
   let batch = 0;
   pi.registerTool({
@@ -170,21 +294,29 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
         const resolved = roles.resolve(role) ?? roles.resolve("default");
         const model = resolved ? `${resolved.provider}/${resolved.model}` : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
         return { index: index + 1, name: cleanText(item.name ?? `agent ${index + 1}`, 24), task: item.task, role, ...(model ? { model } : {}),
-          state: "queued", tools: 0, turns: 0, cost: 0, output: "" };
+          state: "queued", tools: 0, turns: 0, cost: 0, output: "", log: [] };
       });
+      // One controller per run: aborting the tool call stops them all, the activity view stops one.
+      const controllers = runs.map(() => new AbortController());
+      const abortAll = () => { for (const controller of controllers) controller.abort(); };
+      if (signal?.aborted) abortAll(); else signal?.addEventListener("abort", abortAll, { once: true });
+      // The key doubles as the role-status id, so views can tell our own teammates from other extensions'.
+      const records: SubagentRecord[] = runs.map((run, index) => ({ key: `delegate-${id}-${run.index}`, batch: id, run, stop: () => controllers[index]!.abort(STOP_REASON) }));
+      registry.add(...records);
       const thinking = (role: string) => (roles.resolve(role) ?? roles.resolve("default"))?.thinking;
       // Live teammates: the welcome TEAM row and the footer read this public status contract.
       const publish = () => {
         if (!ctx.hasUI) return;
-        for (const run of runs) {
+        for (const { key, run } of records) {
           try {
-            ctx.ui.setStatus(`${ROLE_PREFIX}delegate-${id}-${run.index}`, run.state === "done" || run.state === "failed" ? undefined : JSON.stringify({
+            ctx.ui.setStatus(`${ROLE_PREFIX}${key}`, run.state === "done" || run.state === "failed" ? undefined : JSON.stringify({
               name: run.name, label: run.name.slice(0, 12), state: run.state === "queued" ? "waiting" : "working", task: cleanText(run.task, 60), expiresAt: Date.now() + 25_000
             }));
           } catch { /* status is decoration */ }
         }
       };
-      const details = (includeOutput = true) => ({ runs: runs.map((run) => includeOutput ? { ...run } : { ...run, output: "" }), write });
+      // Details are persisted with the session: never the transcript, which the registry holds instead.
+      const details = (includeOutput = true) => ({ runs: runs.map(({ log: _log, ...run }) => includeOutput ? run : { ...run, output: "" }), write });
       let updateTimer: ReturnType<typeof setTimeout> | undefined;
       let lastUpdateAt = 0;
       const emitUpdate = () => {
@@ -194,6 +326,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
         onUpdate?.({ content: [{ type: "text", text: runs.map((run) => `${run.name}: ${run.state}`).join("\n") }], details: details(false) });
       };
       const update = () => {
+        registry.notify();
         if (!onUpdate) { publish(); return; }
         const wait = Math.max(0, LIVE_UPDATE_MS - (Date.now() - lastUpdateAt));
         if (wait === 0) { if (updateTimer) { clearTimeout(updateTimer); updateTimer = undefined; } emitUpdate(); return; }
@@ -209,10 +342,12 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
       const refresh = setInterval(publish, STATUS_REFRESH_MS);
       refresh.unref?.();
       try {
-        await Promise.all(runs.map((run) => runDelegate(run, delegateArgs(run.task, run.model, thinking(run.role), write), ctx.cwd, signal, update, spawnProcess)));
+        await Promise.all(runs.map((run, index) => runDelegate(run, delegateArgs(run.task, run.model, thinking(run.role), write), ctx.cwd, controllers[index]!.signal, update, spawnProcess)));
       } finally {
         clearInterval(refresh);
-        for (const run of runs) if (run.state !== "done") run.state = "failed";
+        signal?.removeEventListener("abort", abortAll);
+        for (const run of runs) if (run.state !== "done") { run.state = "failed"; run.endedAt ??= Date.now(); }
+        registry.notify();
         flushUpdate();
       }
       const report = runs.map((run) => `## [${run.index}] ${run.name} (${run.role}${run.model ? " · " + run.model : ""}) — ${run.state}${run.error ? ": " + run.error : ""}\n${run.output || "(no report)"}`).join("\n\n");
@@ -224,7 +359,7 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, spaw
         + theme.fg("dim", args.write ? " · can edit" : " · read-only"), 0, 0);
     },
     renderResult(result, { expanded }, theme) {
-      const runs = (result.details as { runs?: DelegateRun[] } | undefined)?.runs ?? [];
+      const runs = (result.details as { runs?: Array<Omit<DelegateRun, "log">> } | undefined)?.runs ?? [];
       const rows = runs.map((run) => {
         const meta = [run.role, run.activity, run.tools ? `${run.tools} tools` : "", run.cost ? `$${run.cost.toFixed(3)}` : "", run.error].filter(Boolean).join(" · ");
         let row = theme.fg(color(run.state) as never, `  ${glyph(run.state)} ${run.name}`) + theme.fg("dim", " · " + meta);