one-code-extension 0.4.1 → 0.5.0

package/extensions/subagents/panel-render.ts

@@ -6,10 +6,11 @@
  * index.ts; this file owns layout only, mirroring workflow/viewer.ts.
  */
 
-import { cutPlainText as cut, formatDuration, splitCell, splitRow, visibleWidth } from "../lib/tui-render.ts";
-import { hardWrapColumns } from "../lib/text-width.ts";
+import { cutPlainText as cut, formatDuration, splitCell, splitRow, visibleWidth, wrapProse } from "../lib/tui-render.ts";
 import { formatTokenCount } from "./usage.ts";
+import { sanitizeDisplayText } from "../lib/terminal-text.ts";
 import { type LiveRun, type LiveStatus, streamingText, type TranscriptBlock } from "./live-runs.ts";
+import { FORK_AGENT } from "./runs.ts";
 
 export interface Paint {
 	fg(color: string, text: string): string;
@@ -31,27 +32,33 @@ export interface PanelRow {
 }
 
 /**
- * A finished run stays in the strip this long (its "Completed"/"Failed" beat),
- * then drops out — Claude Code's tree only tracks live work. The run itself
- * stays in the registry: the viewer, /agents, and SendMessage still reach it.
+ * How long the strip says `/tasks to see subagents` after a run it was showing
+ * finishes. Claude Code 2.1.283 drops a finished agent from the strip at once
+ * and shows that hint in the footer for a few seconds (findings §40); the run
+ * stays in the registry, where `/tasks`, `/agents` and SendMessage reach it.
  */
 export const STRIP_LINGER_MS = 5000;
 
+/** The strip's short notice after a run leaves it. */
+export const TASKS_NOTICE = "/tasks to see subagents";
+
+/** A row's left label: a fork's name, any other agent's type (Claude Code's strip). */
+export function rowLabel(run: Pick<LiveRun, "agentType" | "name">): string {
+	return run.agentType === FORK_AGENT ? run.name : run.agentType;
+}
+
 /**
  * Build the row list: `main` first, then the live children as a TREE — roots
  * newest-first, each root followed by its nested spawns (a child's own Agent
  * calls) in spawn order, indented one level (CC's `└` rows). `mainBusy` drives
- * main's dot. Running children always show; settled ones — done, failed, or an
- * idle resident whose turn ended — only within STRIP_LINGER_MS of finishing
- * (finishedAt is stamped by finish() AND settle()). A nested run whose parent
- * already left the strip surfaces at root level rather than vanishing.
- *
- * `pinnedId` keeps one settled run in the strip past its linger window — the
- * run whose transcript is currently open. Without it a finished child drops out
- * from under an open viewer, the strip empties, and the panel clears focus,
- * orphaning the overlay (no key then reaches read mode to close it).
+ * main's dot. Running children always show; a settled one (done, failed, or
+ * an idle resident whose turn ended) leaves at once, as in Claude Code, unless
+ * it is `pinnedId`: the run whose transcript is open stays, shown `idle`, until
+ * the user switches back (findings §40). Without the pin a finished child
+ * would drop out from under an open viewer and orphan the overlay. A nested
+ * run whose parent already left the strip surfaces at root level.
  */
-export function buildRows(runs: LiveRun[], mainBusy: boolean, now: number, pinnedId?: string): PanelRow[] {
+export function buildRows(runs: LiveRun[], mainBusy: boolean, pinnedId?: string): PanelRow[] {
 	const rows: PanelRow[] = [
 		{
 			label: "main",
@@ -62,9 +69,7 @@ export function buildRows(runs: LiveRun[], mainBusy: boolean, now: number, pinne
 		},
 	];
 	// `runs` arrives newest-first; children under a parent read best in spawn order.
-	const visible = runs.filter(
-		(run) => run.status === "running" || run.taskId === pinnedId || (run.finishedAt ?? now) > now - STRIP_LINGER_MS,
-	);
+	const visible = runs.filter((run) => run.status === "running" || run.taskId === pinnedId);
 	const visibleIds = new Set(visible.map((run) => run.taskId));
 	const byParent = new Map<string, LiveRun[]>();
 	const roots: LiveRun[] = [];
@@ -80,8 +85,8 @@ export function buildRows(runs: LiveRun[], mainBusy: boolean, now: number, pinne
 	const emit = (run: LiveRun, depth: number) => {
 		rows.push({
 			run,
-			label: run.agentType,
-			activity: run.activity,
+			label: rowLabel(run),
+			activity: run.label,
 			status: run.status,
 			startedAt: run.startedAt,
 			finishedAt: run.finishedAt,
@@ -95,18 +100,14 @@ export function buildRows(runs: LiveRun[], mainBusy: boolean, now: number, pinne
 }
 
 /**
- * The agent taskId after `taskId` in strip order, wrapping to the first and
- * skipping the synthetic `main` row; undefined when there are no agent rows.
- * Tab-to-next-agent in read mode uses this against the FULL row list, anchored
- * to the viewed run — not the windowed strip selection, which `anchor()` can
- * reassign once the viewed run scrolls past MAX_STRIP_ROWS (else Tab/x would
- * act on the wrong agent).
+ * Whether the strip should say `/tasks to see subagents`: a run spawned by
+ * main left it within the last STRIP_LINGER_MS (it settled and is not the
+ * viewed one).
  */
-export function nextAgentTaskId(rows: PanelRow[], taskId: string | undefined): string | undefined {
-	const ids = rows.filter((row) => row.run).map((row) => row.run!.taskId);
-	if (ids.length === 0) return undefined;
-	const at = taskId ? ids.indexOf(taskId) : -1;
-	return ids[(at + 1) % ids.length];
+export function recentlyLeftStrip(runs: LiveRun[], now: number, pinnedId?: string): boolean {
+	return runs.some(
+		(run) => run.depth === 0 && run.status !== "running" && run.taskId !== pinnedId && run.finishedAt !== undefined && run.finishedAt > now - STRIP_LINGER_MS,
+	);
 }
 
 const STATUS_ROW_STYLE: Partial<Record<LiveStatus, string>> = { failed: "error" };
@@ -128,42 +129,56 @@ export interface StripInput {
 	rows: PanelRow[];
 	/** Soft-focused row index; undefined when the strip is not focused. */
 	selected?: number;
-	/** A transcript view is open → the strip is in "read" mode (scroll hints). */
-	viewOpen?: boolean;
+	/** The run whose transcript is open; undefined when the main transcript shows. */
+	viewedId?: string;
 	width: number;
 	now: number;
 }
 
 /**
- * One line per row: `mark  agentType  activity   elapsed · ↓ tokens`. The
- * selected row is bold and marked `❯` (Claude Code's selection caret); others
- * are unmarked. A focus hint precedes the list (only while focused) — its keys
- * reflect the mode: navigating the strip vs. reading an open transcript, where
- * `←` returns to selection so a different agent can be picked. Overflow past
- * MAX_STRIP_ROWS collapses to "+N more".
+ * The focused strip's hint. Claude Code's part (findings §40): `↑/↓ to select`
+ * while an agent is viewed, `Enter to view` when the selected row is not the
+ * one on screen, `x to stop` on a running agent. One Code adds the keys
+ * Claude Code leaves unhinted, so every panel key is discoverable: `esc back`,
+ * and `ctrl+x ctrl+k stop all` while any agent runs.
+ */
+export function stripHint(rows: PanelRow[], selected: number, viewedId: string | undefined): string {
+	const row = rows[selected];
+	const parts: string[] = [];
+	if (viewedId !== undefined || (row?.run?.taskId ?? "main") === "main") parts.push("↑/↓ to select");
+	if ((row?.run?.taskId ?? "main") !== (viewedId ?? "main")) parts.push("Enter to view");
+	if (row?.run?.status === "running") parts.push("x to stop");
+	if (rows.some((r) => r.run?.status === "running")) parts.push("ctrl+x ctrl+k stop all");
+	parts.push("esc back");
+	return parts.join(" · ");
+}
+
+/**
+ * One line per row, Claude Code's: `❯ ◯ label  description   elapsed · ↓
+ * tokens`. The caret marks the selected row, the filled dot the one on screen
+ * (`main` when no transcript is open), and a settled viewed run reads `idle`.
+ * A focus hint precedes the list while focused. Overflow past MAX_STRIP_ROWS
+ * collapses to "+N more".
  */
 export function renderStrip(input: StripInput, paint: Paint): string[] {
 	const width = Math.max(20, input.width);
 	const out: string[] = [];
-	if (input.selected !== undefined) {
-		const hint = input.viewOpen
-			? "↑/↓ scroll · PgUp/PgDn page · ← agents · ⇥ next · x stop · esc back"
-			: "↑/↓ select · ⏎ view · x stop · ctrl+x ctrl+k stop all · esc back";
-		out.push(paint.fg("dim", cut(hint, width)));
-	}
+	if (input.selected !== undefined) out.push(paint.fg("dim", cut(stripHint(input.rows, input.selected, input.viewedId), width)));
+	const current = input.viewedId ?? "main";
 	const shown = input.rows.slice(0, MAX_STRIP_ROWS);
 	for (const [index, row] of shown.entries()) {
 		const selected = input.selected === index;
-		const mark = selected ? "❯" : " ";
-		const stats = [
-			formatDuration(row.startedAt, row.finishedAt, input.now),
-			row.tokens ? `↓ ${formatTokenCount(row.tokens)} tokens` : "",
-		]
-			.filter(Boolean)
-			.join(" · ");
+		const caret = selected ? "❯" : " ";
+		const dot = (row.run?.taskId ?? "main") === current ? "⏺" : "◯";
+		const stats =
+			row.run && row.status !== "running"
+				? "idle"
+				: [formatDuration(row.startedAt, row.finishedAt, input.now), row.tokens ? `↓ ${formatTokenCount(row.tokens)} tokens` : ""]
+						.filter(Boolean)
+						.join(" · ");
 		const elbow = row.depth > 0 ? `${"  ".repeat(row.depth - 1)}└ ` : "";
-		const left = `${elbow}${mark} ${row.label}${row.activity ? `  ${row.activity}` : ""}`;
-		const line = splitCell(left, stats, width);
+		const left = `${caret} ${elbow}${dot} ${row.label}${row.activity ? `  ${row.activity}` : ""}`;
+		const line = splitCell(left, row.run ? stats : "", width);
 		if (selected) out.push(paint.fg("accent", paint.bold(line)));
 		else if (STATUS_ROW_STYLE[row.status]) out.push(paint.fg(STATUS_ROW_STYLE[row.status]!, line));
 		else out.push(row.run ? line : paint.fg("dim", line));
@@ -186,43 +201,6 @@ export function spinnerVerb(startedAt: number, now: number): string {
 	return SPINNER_VERBS[Math.floor(seconds / 3) % SPINNER_VERBS.length];
 }
 
-/**
- * Word-aware wrap for prose (task text, assistant text): breaks at spaces,
- * hard-breaking only words longer than the width; preserves blank lines. Plain
- * text in, plain lines out — painting happens after, per line.
- */
-export function wrapProse(text: string, width: number): string[] {
-	const columns = Math.max(1, width);
-	const out: string[] = [];
-	for (const raw of text.replace(/\r\n/g, "\n").split("\n")) {
-		if (raw.trim() === "") {
-			out.push("");
-			continue;
-		}
-		let line = "";
-		for (const word of raw.split(" ")) {
-			if (visibleWidth(word) > columns) {
-				// A word wider than the screen (path, hash): flush, then hard-break it.
-				// The last chunk becomes the running line so later words can join it.
-				if (line) out.push(line);
-				const chunks = hardWrapColumns(word, columns);
-				line = chunks.pop() ?? "";
-				out.push(...chunks);
-				continue;
-			}
-			const candidate = line ? `${line} ${word}` : word;
-			if (visibleWidth(candidate) > columns) {
-				out.push(line);
-				line = word;
-			} else {
-				line = candidate;
-			}
-		}
-		out.push(line);
-	}
-	return out;
-}
-
 /**
  * Renders one prose unit (assistant text) to painted lines at width. `ref`
  * identifies the unit across frames so implementations can cache: a settled
@@ -282,8 +260,9 @@ export function renderTranscript(input: TranscriptInput, paint: Paint): Transcri
 	// windowed ANCHORED TO THE TAIL — scroll counts lines back from the end, so
 	// the default view follows streaming like Claude Code.
 	const bodyRows = Math.max(0, input.height - out.length - 1);
-	const blockLines = run.blocks.flatMap((block) => blockToLines(block, width, paint, prose));
-	const partial = streamingText(run.streaming).trimEnd();
+	const fork = run.agentType === FORK_AGENT;
+	const blockLines = run.blocks.flatMap((block) => blockToLines(block, width, paint, prose, fork));
+	const partial = sanitizeDisplayText(streamingText(run.streaming)).trimEnd();
 	if (partial) for (const line of prose(`stream:${run.taskId}`, partial, width)) blockLines.push(line);
 	while (blockLines.length && blockLines.at(-1) === "") blockLines.pop();
 	const maxScroll = Math.max(0, blockLines.length - bodyRows);
@@ -297,7 +276,7 @@ export function renderTranscript(input: TranscriptInput, paint: Paint): Transcri
 	// discoverable right where the reader is looking (key hints otherwise live in
 	// the strip). splitPaint fuses to the left alone when the hint is "" (body
 	// fits) or the row is too narrow.
-	const scrollHint = maxScroll > 0 ? "↑/↓ scroll" : "";
+	const scrollHint = maxScroll > 0 ? "PgUp/PgDn scroll" : "";
 	const bottomRow = (text: string, color: string): string => splitPaint(paint, color, text, scrollHint, width, undefined, "dim", false);
 	if (run.status === "running") {
 		const verb = spinnerVerb(run.startedAt, input.now);
@@ -321,14 +300,59 @@ export function renderTranscript(input: TranscriptInput, paint: Paint): Transcri
  * a trailing blank for paragraph spacing. Call/result stay one line each, a
  * blank after the result so tool groups read like the main transcript.
  */
-function blockToLines(block: TranscriptBlock, width: number, paint: Paint, prose: ProseRenderer): string[] {
+function blockToLines(block: TranscriptBlock, width: number, paint: Paint, prose: ProseRenderer, fork: boolean): string[] {
+	// A fork's directive opens its view as Claude Code's `⑂ <question>` row.
+	if (block.kind === "task" && fork) return [...wrapProse(`⑂ ${block.text}`, width).map((l) => paint.fg("dim", l)), ""];
 	if (block.kind === "task") return [...wrapProse(block.text, width).map((l) => paint.fg("dim", l)), ""];
+	// A message the user typed at the agent, Claude Code's `❯ <text>` row.
+	if (block.kind === "user") return [...wrapProse(`❯ ${block.text}`, width), ""];
 	if (block.kind === "text") return [...prose(block, block.text, width), ""];
-	if (block.kind === "call") return [`${paint.fg("accent", "●")} ${cut(`${block.tool}(${block.text})`, width - 2)}`];
+	if (block.kind === "call") return [`${paint.fg("accent", "●")} ${cut(`${toolDisplayLabel(block.tool ?? "")}(${block.text})`, width - 2)}`];
 	const body = cut(block.text, width - 4);
 	return [`  ${paint.fg("dim", "⎿")} ${block.isError ? paint.fg("error", body) : body}`, ""];
 }
 
+/**
+ * Labels the main transcript gives tools whose name does not title-case to it
+ * (each tool's `ccToolRenderers` label; `agent-view-tool-labels.test.ts` keeps
+ * this table in step with the registrations).
+ */
+const TOOL_LABELS: Record<string, string> = {
+	edit: "Update",
+	ls: "LS",
+	powershell: "PowerShell",
+	ask_user_question: "Ask User",
+	task_create: "Create Task",
+	task_get: "Get Task",
+	task_list: "List Tasks",
+	task_update: "Update Task",
+	task_stop: "Stop Task",
+	lsp_diagnostics: "Diagnostics",
+	enter_plan_mode: "Enter plan mode",
+	exit_plan_mode: "Exit plan mode",
+	list_mcp_resources: "MCP Resources",
+	read_mcp_resource: "Read MCP Resource",
+	read_mcp_resource_dir: "List MCP Resource Directory",
+};
+
+/**
+ * The label the main transcript shows for a tool (`Bash(…)`, `Update(…)`,
+ * `Web Fetch(…)`, `server: tool(…)`), so a call reads the same in an agent's
+ * view: the irregular ones from a table, an MCP tool as `server: tool`, and
+ * the rest title-cased from the snake_case name, as the renderers label them.
+ */
+export function toolDisplayLabel(name: string): string {
+	const fixed = TOOL_LABELS[name];
+	if (fixed) return fixed;
+	const mcp = /^mcp__(.+?)__(.+)$/.exec(name);
+	if (mcp) return `${mcp[1]}: ${mcp[2]}`;
+	return name
+		.split("_")
+		.filter(Boolean)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join(" ");
+}
+
 /** A small inverse-video chip for the label, degrading to `[label]` when narrow. */
 function chip(label: string): string {
 	return label ? ` ${label} ` : "";

package/extensions/subagents/panel-widget.ts

@@ -1,7 +1,7 @@
 /**
  * The persistent panel below the editor: Claude Code's agent tree PLUS its
- * background-shell manager (chip → Background list → shell details, rendered
- * by shell-panel.ts). Mirrors workflow/widget.ts: a component-overload
+ * background-shells chip (shell-panel.ts; Enter on it opens the `/tasks`
+ * Background dialog). Mirrors workflow/widget.ts: a component-overload
  * setWidget so rows can right-align against the real width, debounced
  * re-renders, and a 1s ticker to keep elapsed time moving. Also carries both
  * soft-focus states for the down-arrow flow (wired in index.ts): the FIRST ↓
@@ -11,17 +11,12 @@
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { BackgroundTask } from "../background/registry.ts";
+import { canShowCustomUi } from "../lib/headless-output.ts";
 import type { ShellTaskTracker } from "../lib/shell-tasks.ts";
 import { linesComponent, liveUiCtx, safeThemeBold, safeThemeInverse, safeThemePaint } from "../lib/tui-render.ts";
-import { buildRows, MAX_STRIP_ROWS, nextAgentTaskId, renderStrip, type PanelRow } from "./panel-render.ts";
+import { buildRows, MAX_STRIP_ROWS, recentlyLeftStrip, renderStrip, TASKS_NOTICE, type PanelRow } from "./panel-render.ts";
 import type { LiveRunRegistry } from "./live-runs.ts";
-import {
-	anchorShellFocus,
-	renderShellSection,
-	type ShellFocus,
-	shellRows,
-	shellSectionVisible,
-} from "./shell-panel.ts";
+import { renderShellChip, shellRows } from "./shell-panel.ts";
 
 const WIDGET_KEY = "subagents";
 const DEBOUNCE_MS = 200;
@@ -41,8 +36,8 @@ export class SubagentWidget {
 	 * actually selected, never on whatever slid into its slot.
 	 */
 	private focusId: string | undefined;
-	/** The shell-manager side of the panel (chip → list → details). */
-	shellFocus: ShellFocus | undefined;
+	/** Whether the shells chip holds soft focus. */
+	shellChipFocused = false;
 	/**
 	 * The taskId whose transcript is open, or undefined when none is (set by
 	 * index.ts). Drives the strip's scroll hints AND pins that run in the strip
@@ -61,11 +56,15 @@ export class SubagentWidget {
 	 */
 	private disposed = false;
 	private readonly unsubscribes: Array<() => void> = [];
+	/** The text last sent as an RPC widget; undefined while none is shown. */
+	private rpcSent: string | undefined;
 
 	constructor(
 		private readonly registry: LiveRunRegistry,
 		private readonly getCtx: () => ExtensionContext | undefined,
 		private readonly shells?: ShellTaskTracker,
+		/** Told the rows this strip paints below the editor (lib/dock-rows.ts). */
+		private readonly onRows: (rows: number) => void = () => {},
 	) {
 		this.unsubscribes.push(registry.subscribe(() => this.schedule()));
 		if (shells) this.unsubscribes.push(shells.subscribe(() => this.schedule()));
@@ -84,7 +83,7 @@ export class SubagentWidget {
 		} catch {
 			mainBusy = false;
 		}
-		return buildRows(this.registry.list(), mainBusy, Date.now(), this.viewedId);
+		return buildRows(this.registry.list(), mainBusy, this.viewedId);
 	}
 
 	rowCount(): number {
@@ -130,64 +129,31 @@ export class SubagentWidget {
 		return this.viewedId;
 	}
 
-	/** The agent to retarget to on Tab, relative to the viewed run in the FULL
-	 * row list (see nextAgentTaskId — avoids the windowed-selection desync). */
-	nextAgentAfter(taskId: string | undefined): string | undefined {
-		return nextAgentTaskId(this.rows(), taskId);
-	}
-
-	// --- Shell-manager state (Claude Code's ↓-to-manage flow) ---
+	// --- The shells chip (Claude Code's ↓-to-manage flow) ---
 
-	/** Live shell rows for the list/details views. */
-	shellTasks(): BackgroundTask[] {
+	/** The shells the chip counts: running, or finished inside the linger window. */
+	private shellTasks(): BackgroundTask[] {
 		return this.shells ? shellRows(this.shells.list(), Date.now()) : [];
 	}
 
-	shellIds(): string[] {
-		return this.shellTasks().map((t) => t.id);
-	}
-
 	private runningShellCount(): number {
 		return this.shells?.running().length ?? 0;
 	}
 
-	/** Whether ↓ from the editor should land on the chip first — running shells
-	 * or finished ones still inside the linger window. */
+	/** Whether the chip shows, so ↓ from the editor lands on it first: running
+	 * shells, or finished ones still inside the linger window. */
 	shellChipAvailable(): boolean {
 		return this.shellTasks().length > 0;
 	}
 
-	/** `ids`, when the caller already derived the row order, skips re-deriving it. */
-	setShellFocus(focus: ShellFocus | undefined, ids?: string[]): void {
-		this.shellFocus = focus && anchorShellFocus(focus, ids ?? this.shellIds());
+	setShellChipFocus(focused: boolean): void {
+		this.shellChipFocused = focused;
 		this.render();
 	}
 
-	/** The anchored current focus (the selected shell may have lingered out). */
-	anchoredShellFocus(ids?: string[]): ShellFocus | undefined {
-		if (this.shellFocus) this.shellFocus = anchorShellFocus(this.shellFocus, ids ?? this.shellIds());
-		return this.shellFocus;
-	}
-
-	/** Point lookup — no need for the linger-filtered, sorted row build. */
-	shellTaskById(id: string): BackgroundTask | undefined {
-		return this.shells?.list().find((t) => t.id === id);
-	}
-
-	selectedShellTask(): BackgroundTask | undefined {
-		const focus = this.anchoredShellFocus();
-		if (!focus || focus.stage === "chip") return undefined;
-		return this.shellTaskById(focus.selectedId);
-	}
-
-	private shellVisible(): boolean {
-		return shellSectionVisible(this.shellTasks().length, this.shellFocus);
-	}
-
-	/** Lines the shell section currently occupies (for overlay reserve math) —
-	 * measured off the real renderer so layout changes can never desync it. */
+	/** Lines the chip occupies (for overlay reserve math). */
 	shellLineCount(): number {
-		return this.shellVisible() ? this.shellSectionLines(80).length : 0;
+		return this.shellChipAvailable() ? 1 : 0;
 	}
 
 	/** Re-derive focusIndex from focusId against the given rows (see focusId doc). */
@@ -224,6 +190,7 @@ export class SubagentWidget {
 		if (this.ticker) clearInterval(this.ticker);
 		this.timer = this.ticker = undefined;
 		for (const unsubscribe of this.unsubscribes.splice(0)) unsubscribe();
+		this.onRows(0);
 		try {
 			ctx?.ui.setWidget(WIDGET_KEY, undefined);
 		} catch {
@@ -240,23 +207,6 @@ export class SubagentWidget {
 		this.timer.unref?.();
 	}
 
-	/** The shell section's lines; identity paint when only counting. */
-	private shellSectionLines(
-		width: number,
-		paint = { fg: (_c: string, t: string) => t, bold: (t: string) => t, inverse: (t: string) => t },
-	): string[] {
-		return renderShellSection(
-			{
-				rows: this.shellTasks(),
-				runningCount: this.runningShellCount(),
-				focus: this.shellFocus,
-				width,
-				now: Date.now(),
-			},
-			paint,
-		);
-	}
-
 	private render(): void {
 		const ctx = this.liveCtx();
 		if (!ctx) {
@@ -265,30 +215,50 @@ export class SubagentWidget {
 			this.syncTicker(false);
 			return;
 		}
+		const now = Date.now();
 		const rows = this.rows();
-		const shellVisible = this.shellVisible();
+		const shellTasks = this.shellTasks();
+		const shellVisible = shellTasks.length > 0;
+		// The chip goes with its last shell: a focus left on it would read "0 shells".
+		if (!shellVisible) this.shellChipFocused = false;
+		const chipFocused = this.shellChipFocused;
 		// The chip is time-invariant while every shell runs (count changes arrive
-		// as tracker events), so the clock is needed only for the list (linger
-		// expiry) and details (runtime, live output) stages — or when finished
-		// shells are lingering, whose expiry is what hides the section.
-		const shellStage = this.shellFocus?.stage;
-		const lingering = shellVisible && this.shellTasks().length > this.runningShellCount();
-		this.syncTicker(rows.length > 1 || shellStage === "list" || shellStage === "details" || lingering);
+		// as tracker events), so the clock is needed only while finished shells
+		// linger, whose expiry is what clears the chip.
+		const lingering = shellTasks.length > this.runningShellCount();
+		// A run that just left the strip leaves Claude Code's `/tasks` pointer behind for a moment.
+		const notice = rows.length <= 1 && recentlyLeftStrip(this.registry.list(), now, this.viewedId);
+		this.syncTicker(rows.length > 1 || notice || lingering);
 		// Only the synthetic `main` row exists and no shells → nothing to show yet.
 		// Never tear down while a transcript view is open (viewedId set): clearing
 		// focus here would orphan the overlay with no key path to close it.
-		if (rows.length <= 1 && !shellVisible && this.viewedId === undefined) {
+		if (rows.length <= 1 && !shellVisible && !notice && this.viewedId === undefined) {
+			this.rpcSent = undefined;
 			ctx.ui.setWidget(WIDGET_KEY, undefined);
+			this.onRows(0);
 			this.focusIndex = undefined;
 			this.focusId = undefined;
-			this.shellFocus = undefined;
 			return;
 		}
 		this.anchor(rows);
-		if (this.shellFocus) this.shellFocus = anchorShellFocus(this.shellFocus, this.shellIds());
 		const selected = this.focusIndex;
 		const showStrip = rows.length > 1;
-		const now = Date.now();
+		// RPC forwards string-array widgets, not component factories or key handlers.
+		if (!canShowCustomUi(ctx)) {
+			const lines = rows.slice(1, MAX_STRIP_ROWS).map((row) =>
+				`${row.run!.name} (${row.run!.taskId}) — ${row.status}: ${row.activity}`,
+			);
+			if (rows.length > MAX_STRIP_ROWS) lines.push(`${rows.length - MAX_STRIP_ROWS} more agents — /tasks to list all`);
+			if (notice) lines.push(TASKS_NOTICE);
+			if (shellVisible) lines.push(...shellTasks.map((task) => `${task.id} [shell] ${task.status}: ${task.command ?? task.description}`));
+			// The ticker repaints every second; each send is a message to the client.
+			const text = lines.join("\n");
+			if (text === this.rpcSent) return;
+			this.rpcSent = text;
+			ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "belowEditor" });
+			this.onRows(0); // no TUI view sizes itself in RPC
+			return;
+		}
 		ctx.ui.setWidget(
 			WIDGET_KEY,
 			(tui, theme) => {
@@ -300,11 +270,13 @@ export class SubagentWidget {
 				const paint = { fg: safeThemePaint(theme), bold: safeThemeBold(theme), inverse: safeThemeInverse(theme) };
 				return linesComponent((width) => {
 					const lines: string[] = [];
-					if (showStrip) lines.push(...renderStrip({ rows, selected, viewOpen: this.viewedId !== undefined, width: width - 1, now }, paint));
+					if (showStrip) lines.push(...renderStrip({ rows, selected, viewedId: this.viewedId, width: width - 1, now }, paint));
+					else if (notice) lines.push(paint.fg("dim", TASKS_NOTICE));
 					if (shellVisible) {
 						if (lines.length) lines.push("");
-						lines.push(...this.shellSectionLines(width - 1, paint));
+						lines.push(renderShellChip(shellTasks.length, chipFocused, width - 1, paint));
 					}
+					this.onRows(lines.length);
 					return lines.map((line) => ` ${line}`);
 				});
 			},
@@ -313,10 +285,9 @@ export class SubagentWidget {
 	}
 
 	/**
-	 * Tick while any child row is shown or the shell manager is focused —
-	 * elapsed times move, finished rows expire out of the strip/list (linger
-	 * windows), and the details view's output box follows the live spool,
-	 * all without needing another registry event.
+	 * Tick while any child row is shown or a finished shell lingers: elapsed
+	 * times move and finished rows expire out of the strip and the chip (linger
+	 * windows), without needing another registry event.
 	 */
 	private syncTicker(active: boolean): void {
 		if (active && !this.ticker && !this.disposed) {