@tt-a1i/openpi 0.3.1 → 0.4.0

package/extensions/subagents/index.ts

@@ -25,7 +25,6 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { StringEnum } from "@earendil-works/pi-ai";
 import type {
   ExtensionAPI,
   ExtensionCommandContext,
@@ -37,7 +36,6 @@ import {
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
   defineTool,
-  formatSize,
   getAgentDir,
   getMarkdownTheme,
   keyHint,
@@ -46,41 +44,70 @@ import {
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
+  formatActivityStatus,
+  hasActivity,
+  unreadActivityCounts,
+} from "../shared/activity-status.ts";
+import {
+  BelowEditorNavigationEditor,
+  BelowEditorStripState,
+} from "../shared/below-editor-navigation.ts";
+import {
+  effectiveChildToolAllowlist,
+  resolveStandaloneChildProjectTrust,
+} from "../shared/child-session.ts";
+import { formatContextUtilization } from "../shared/context-utilization.ts";
+import {
+  registerEditorLayer,
+  removeEditorLayer,
+} from "../shared/editor-layers.ts";
+import {
+  PLAN_MODE_CHANNEL,
+  type PlanModeState,
+  planModeAllowsDeclaredTools,
+  planModeChildTools,
+} from "../shared/plan-mode-state.ts";
+import { loadSetupConfig } from "../shared/setup-config.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
+import {
+  createWorktree,
+  reclaimWorktree,
+  type Worktree,
+} from "../shared/worktree.ts";
+import {
+  normalizeSubagentTitle,
+  SubagentStripWidget,
+  selectSubagentStripEntry,
+} from "./navigation.ts";
+import {
+  type AgentType,
   formatAgentTypeDiagnostics,
   loadAgentTypes,
   roleModelForAgentType,
   selectSubagentModel,
-  type AgentType,
 } from "./src/agent-types.ts";
 import { deriveBtwTitle, isModelVisible } from "./src/by-the-way.ts";
 import {
   BACKEND_NAMES,
   formatElapsed,
   latestText,
-  REASONING_EFFORTS,
   type SubagentSnapshot,
 } from "./src/domain.ts";
 import {
-  formatActivityStatus,
-  hasActivity,
-  unreadActivityCounts,
-} from "../shared/activity-status.ts";
-import {
-  OPENPI_TOOL_SURFACE,
-  patchOwnedTools,
-} from "../shared/tool-surface.ts";
-import {
-  registerEditorLayer,
-  removeEditorLayer,
-} from "../shared/editor-layers.ts";
-import { formatContextUtilization } from "./src/format.ts";
+  restoreSubagentIdCounters,
+  SUBAGENT_ID_WATERMARK_ENTRY_TYPE,
+  type SubagentIdCounters,
+  subagentIdWatermark,
+} from "./src/id-sequence.ts";
 import { SubagentManager, type SubagentManagerShape } from "./src/manager.ts";
 import {
   buildSubagentResultMessage,
-  createAgentTypeParameterSchema,
   buildSubagentSendResult,
   buildSubagentSpawnResult,
-  buildSubagentSpawnToolDescription,
+  createSubagentSpawnToolSurface,
   SUBAGENT_CANCEL_PARAMETER_DESCRIPTIONS,
   SUBAGENT_CANCEL_TOOL_DESCRIPTION,
   SUBAGENT_CHECK_PARAMETER_DESCRIPTIONS,
@@ -88,44 +115,22 @@ import {
   SUBAGENT_LIST_TOOL_DESCRIPTION,
   SUBAGENT_SEND_PARAMETER_DESCRIPTIONS,
   SUBAGENT_SEND_TOOL_DESCRIPTION,
-  SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS,
   SUBAGENT_SPAWN_PROMPT_GUIDELINES,
   SUBAGENT_SPAWN_PROMPT_SNIPPET,
-  SUBAGENT_SPAWN_TOOL_DESCRIPTION,
   SUBAGENT_WAIT_PARAMETER_DESCRIPTIONS,
   SUBAGENT_WAIT_TOOL_DESCRIPTION,
 } from "./src/prompt.ts";
-import { createSubagentResultDelivery } from "./src/result-delivery.ts";
+import { persistResultArtifact, projectResult } from "./src/result-artifact.ts";
 import {
-  effectiveChildToolAllowlist,
-  resolveStandaloneChildProjectTrust,
-} from "../shared/child-session.ts";
-import {
-  BelowEditorNavigationEditor,
-  BelowEditorStripState,
-} from "../shared/below-editor-navigation.ts";
-import { loadSetupConfig } from "../shared/setup-config.ts";
-import {
-  PLAN_MODE_CHANNEL,
-  planModeAllowsDeclaredTools,
-  planModeChildTools,
-  type PlanModeState,
-} from "../shared/plan-mode-state.ts";
-import {
-  createWorktree,
-  reclaimWorktree,
-  type Worktree,
-} from "../shared/worktree.ts";
+  allocateResultBudgets,
+  type ParentContextUsage,
+} from "../shared/result-budget.ts";
+import { createSubagentResultDelivery } from "./src/result-delivery.ts";
 import {
   createSubagentRuntime,
   runTool,
   type SubagentRuntime,
 } from "./src/runtime.ts";
-import {
-  normalizeSubagentTitle,
-  selectSubagentStripEntry,
-  SubagentStripWidget,
-} from "./navigation.ts";
 import { openSubagentPicker, openSubagentTakeover } from "./src/ui/takeover.ts";
 import {
   buildWaitResultPreview,
@@ -134,8 +139,13 @@ import {
 } from "./src/ui/wait-result.ts";
 
 const SUBAGENT_OUTPUT_MAX_BYTES = 24 * 1024;
+const AUTOMATIC_OUTPUT_MAX_BYTES = 48 * 1024;
+const AUTOMATIC_MIN_RESULT_BYTES = 2 * 1024;
 const WAIT_OUTPUT_MAX_BYTES = 48 * 1024;
 const WAIT_PER_AGENT_MAX_BYTES = 16 * 1024;
+const WAIT_MIN_RESULT_BYTES = 512;
+const RESULT_HEADROOM_SHARE = 0.5;
+const ESTIMATED_BYTES_PER_TOKEN = 4;
 
 interface SpawnResultDetails {
   readonly id?: string;
@@ -189,36 +199,71 @@ function describeSubagent(snap: SubagentSnapshot) {
   return `${snap.id} [${snap.status}] "${snap.title}" (${details.join(", ")})`;
 }
 
-function truncatedOutput(
+export function truncatedOutput(
   snap: SubagentSnapshot,
   maxBytes = SUBAGENT_OUTPUT_MAX_BYTES,
+  writeArtifact: (content: string) => string = (content) =>
+    persistResultArtifact(getAgentDir(), content),
 ): string {
   const output = snap.finalText || "(no output)";
-  const truncation = truncateHead(output, {
+  return projectResult(output, {
     maxBytes: Math.min(maxBytes, DEFAULT_MAX_BYTES),
     maxLines: Math.min(600, DEFAULT_MAX_LINES),
-  });
-  let text = truncation.content;
-  if (truncation.truncated) {
-    text += `\n\n[Output truncated: ${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)} shown. Full transcript in session file: ${snap.meta.sessionFilePath ?? "?"}]`;
-  }
-  return text;
+    writeArtifact,
+  }).text;
 }
 
 export function createSubagentResultDispatcher(
   pi: ExtensionAPI,
-  outputFor: (snap: SubagentSnapshot) => string = truncatedOutput,
+  outputFor: (
+    snap: SubagentSnapshot,
+    maxBytes: number,
+  ) => string = truncatedOutput,
+  getContextUsage: () => ParentContextUsage | undefined = () => undefined,
 ) {
   return (snaps: readonly SubagentSnapshot[]) => {
     if (snaps.length === 0) return;
+    const emptyMessages = snaps.map((snap) =>
+      buildSubagentResultMessage({
+        id: snap.id,
+        title: snap.title,
+        status: snap.status,
+        errorText: snap.errorText,
+        output: "",
+      }),
+    );
+    const wrapperBytes =
+      emptyMessages.reduce(
+        (sum, message) => sum + Buffer.byteLength(message, "utf8"),
+        0,
+      ) +
+      Math.max(0, snaps.length - 1) * 2;
+    const projectionBatchBytes = Math.max(
+      AUTOMATIC_MIN_RESULT_BYTES * snaps.length,
+      AUTOMATIC_OUTPUT_MAX_BYTES - wrapperBytes,
+    );
+    const allocation = allocateResultBudgets(
+      snaps.map((snap) =>
+        Buffer.byteLength(snap.finalText || "(no output)", "utf8"),
+      ),
+      getContextUsage(),
+      {
+        maxBatchBytes: projectionBatchBytes,
+        maxResultBytes: SUBAGENT_OUTPUT_MAX_BYTES,
+        minResultBytes: AUTOMATIC_MIN_RESULT_BYTES,
+        headroomShare: RESULT_HEADROOM_SHARE,
+        estimatedBytesPerToken: ESTIMATED_BYTES_PER_TOKEN,
+        fixedBytes: wrapperBytes,
+      },
+    );
     const content = snaps
-      .map((snap) =>
+      .map((snap, index) =>
         buildSubagentResultMessage({
           id: snap.id,
           title: snap.title,
           status: snap.status,
           errorText: snap.errorText,
-          output: outputFor(snap),
+          output: outputFor(snap, allocation.budgets[index]!),
         }),
       )
       .join("\n\n");
@@ -277,7 +322,7 @@ function renderSubagentResult(
   }
 
   const failed = details.status === "error";
-  const icon = failed ? theme.fg("error", "x") : theme.fg("success", "■");
+  const icon = failed ? theme.fg("error", "x") : theme.fg("success", "✓");
   const header =
     `${icon} ` +
     theme.fg("accent", theme.bold(`subagent ${details.id ?? "?"}`)) +
@@ -306,6 +351,10 @@ function renderSubagentResult(
 export default function (pi: ExtensionAPI) {
   let runtime: SubagentRuntime | undefined;
   let managerPromise: Promise<SubagentManagerShape> | undefined;
+  let restoredIdCounters: SubagentIdCounters = {
+    modelCounter: 0,
+    btwCounter: 0,
+  };
   let sessionContext: ExtensionContext | undefined;
   let ui: ExtensionUIContext | undefined;
   let unsubStatus: (() => void) | undefined;
@@ -321,7 +370,11 @@ export default function (pi: ExtensionAPI) {
   let requestWidgetRender: (() => void) | undefined;
   let navigationLayerRegistered = false;
   let dashboardOpen = false;
-  const dispatchResults = createSubagentResultDispatcher(pi);
+  const dispatchResults = createSubagentResultDispatcher(
+    pi,
+    truncatedOutput,
+    () => sessionContext?.getContextUsage(),
+  );
   const resultDelivery = createSubagentResultDelivery<SubagentSnapshot>({
     isIdle: () => sessionContext?.isIdle() === true,
     // Every unconsumed fire-and-forget result must reach the parent. The
@@ -329,16 +382,19 @@ export default function (pi: ExtensionAPI) {
     deliver: dispatchResults,
   });
   pi.on("agent_settled", () => resultDelivery.parentSettled());
-  const hideLifecycleTools = () =>
-    patchOwnedTools(pi, "subagents", {
-      disable: OPENPI_TOOL_SURFACE.subagents.deferred,
-    });
-  const showLifecycleTools = () =>
+  const registerStableToolFamily = () =>
     patchOwnedTools(pi, "subagents", {
-      enable: OPENPI_TOOL_SURFACE.subagents.deferred,
+      enable: OPENPI_TOOL_SURFACE.subagents.entry,
     });
 
-  const getRuntime = () => (runtime ??= createSubagentRuntime());
+  const getRuntime = () =>
+    (runtime ??= createSubagentRuntime({
+      initialModelCounter: restoredIdCounters.modelCounter,
+      initialBtwCounter: restoredIdCounters.btwCounter,
+    }));
+
+  const persistId = (id: string) =>
+    pi.appendEntry(SUBAGENT_ID_WATERMARK_ENTRY_TYPE, subagentIdWatermark(id));
 
   /** Resolve the manager service once per runtime and wire the extension hooks. */
   const getManager = () => {
@@ -392,9 +448,12 @@ export default function (pi: ExtensionAPI) {
       manager.view.list(),
       settledAcknowledgedAt,
     );
+    // In the TUI the below-editor strip already reports the same activity and
+    // carries the manage affordance, so a footer status line would repeat it.
+    const tui = sessionContext?.mode === "tui";
     ui.setStatus(
       "subagents",
-      hasActivity(counts)
+      !tui && hasActivity(counts)
         ? formatActivityStatus(ui.theme, "subagents", counts)
         : undefined,
     );
@@ -493,8 +552,11 @@ export default function (pi: ExtensionAPI) {
   };
 
   pi.on("session_start", (_event, ctx) => {
+    restoredIdCounters = restoreSubagentIdCounters(
+      ctx.sessionManager.getBranch(),
+    );
     refreshAgentTypes(ctx.cwd, ctx.isProjectTrusted());
-    hideLifecycleTools();
+    registerStableToolFamily();
     sessionContext = ctx;
     settledAcknowledgedAt = 0;
     if (ctx.hasUI) ui = ctx.ui;
@@ -592,57 +654,22 @@ export default function (pi: ExtensionAPI) {
     agentTypes = loaded.agentTypes;
     agentTypeDiagnostics = loaded.diagnostics;
     agentTypeList = [...agentTypes.values()];
-    subagentSpawnTool.description =
-      buildSubagentSpawnToolDescription(agentTypeList);
-    subagentSpawnTool.parameters = createSubagentSpawnParameters();
+    const surface = createSubagentSpawnToolSurface(agentTypeList);
+    subagentSpawnTool.description = surface.description;
+    subagentSpawnTool.parameters = surface.parameters;
     registerSubagentSpawnTool();
   };
 
   // --- Tools -------------------------------------------------------------
 
-  const createSubagentSpawnParameters = () =>
-    Type.Object({
-      agent_type: createAgentTypeParameterSchema(agentTypeList),
-      prompt: Type.String({
-        description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.prompt,
-      }),
-      name: Type.String({
-        description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.name,
-      }),
-      harness: Type.Optional(
-        StringEnum(BACKEND_NAMES, {
-          description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.harness,
-        }),
-      ),
-      working_dir: Type.Optional(
-        Type.String({
-          description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.workingDir,
-        }),
-      ),
-      isolation: Type.Optional(
-        StringEnum(["worktree"] as const, {
-          description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.isolation,
-        }),
-      ),
-      model: Type.Optional(
-        Type.String({
-          description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.model,
-        }),
-      ),
-      reasoning_effort: Type.Optional(
-        StringEnum(REASONING_EFFORTS, {
-          description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.reasoningEffort,
-        }),
-      ),
-    });
+  const initialSpawnSurface = createSubagentSpawnToolSurface(agentTypeList);
 
   const subagentSpawnTool = defineTool({
     name: "subagent_spawn",
     label: "Spawn Subagent",
-    description: buildSubagentSpawnToolDescription(agentTypeList),
+    ...initialSpawnSurface,
     promptSnippet: SUBAGENT_SPAWN_PROMPT_SNIPPET,
     promptGuidelines: SUBAGENT_SPAWN_PROMPT_GUIDELINES,
-    parameters: createSubagentSpawnParameters(),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       // Only one backend exists; harness is optional and defaults to it.
       const harness = params.harness ?? BACKEND_NAMES[0];
@@ -767,8 +794,7 @@ export default function (pi: ExtensionAPI) {
         if (worktree) await reclaimWorktree(cwd, worktree).catch(() => {});
         throw error;
       }
-
-      showLifecycleTools();
+      persistId(snap.id);
 
       return {
         content: [
@@ -813,8 +839,11 @@ export default function (pi: ExtensionAPI) {
       const meta = [details.harness, details.model]
         .filter(Boolean)
         .join(" \u00b7 ");
+      // A spawn is an event, not a state, so it speaks in the activity rows'
+      // verb language ("Wrote" / "Ran" / "Spawned") rather than a glyph; the
+      // strip's spinner carries the running state from here on.
       return new Text(
-        `${theme.fg("success", "\u25cf")} ${theme.bold(details.title ?? details.id)} ${theme.fg("dim", meta)}`,
+        `${theme.fg("toolTitle", "Spawned")}  ${theme.bold(details.title ?? details.id)} ${theme.fg("dim", meta)}`,
         0,
         0,
       );
@@ -834,7 +863,7 @@ export default function (pi: ExtensionAPI) {
         description: SUBAGENT_WAIT_PARAMETER_DESCRIPTIONS.ids,
       }),
     }),
-    async execute(_toolCallId, params, signal, onUpdate) {
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const manager = await getManager();
       const ids = [...new Set(params.ids)];
       if (ids.length === 0)
@@ -870,33 +899,66 @@ export default function (pi: ExtensionAPI) {
       // deferred automatic delivery now that the tool is returning the result.
       resultDelivery.consume(ids);
 
-      const sections: string[] = [];
-      let remainingBytes = WAIT_OUTPUT_MAX_BYTES;
-      for (const id of ids) {
+      const entries: Array<
+        | { readonly id: string; readonly section: string }
+        | {
+            readonly id: string;
+            readonly snap: SubagentSnapshot;
+            readonly header: string;
+          }
+      > = ids.map((id) => {
         const snap = manager.view.get(id);
-        if (!snap) {
-          sections.push(`## ${id}\n\n(no longer tracked)`);
-          continue;
-        }
+        if (!snap) return { id, section: `## ${id}\n\n(no longer tracked)` };
         const verb = snap.status === "error" ? "failed" : "finished";
-        let section = `## ${snap.id} "${snap.title}" ${verb}`;
-        if (snap.errorText) section += `\nError: ${snap.errorText}`;
-        const headerBytes = Buffer.byteLength(section, "utf8") + 2;
-        const outputBudget = Math.max(
-          512,
-          Math.min(WAIT_PER_AGENT_MAX_BYTES, remainingBytes - headerBytes),
+        let header = `## ${snap.id} "${snap.title}" ${verb}`;
+        if (snap.errorText) header += `\nError: ${snap.errorText}`;
+        return { id, snap, header };
+      });
+      const separatorsBytes = Math.max(0, entries.length - 1) * 7;
+      const fixedBytes =
+        separatorsBytes +
+        entries.reduce(
+          (sum, entry) =>
+            sum +
+            Buffer.byteLength(
+              "section" in entry ? entry.section : `${entry.header}\n\n`,
+              "utf8",
+            ),
+          0,
         );
-        section += `\n\n${truncatedOutput(snap, outputBudget)}`;
-        const sectionBytes = Buffer.byteLength(section, "utf8");
-        if (sectionBytes > remainingBytes) {
-          sections.push(
-            `## ${snap.id} "${snap.title}"\n\n[omitted: total wait output limit reached]`,
-          );
-          break;
-        }
-        sections.push(section);
-        remainingBytes -= sectionBytes;
-      }
+      const resultEntries = entries.filter(
+        (
+          entry,
+        ): entry is {
+          readonly id: string;
+          readonly snap: SubagentSnapshot;
+          readonly header: string;
+        } => "snap" in entry,
+      );
+      const projectionBatchBytes = Math.max(
+        WAIT_MIN_RESULT_BYTES * resultEntries.length,
+        WAIT_OUTPUT_MAX_BYTES - fixedBytes,
+      );
+      const allocation = allocateResultBudgets(
+        resultEntries.map(({ snap }) =>
+          Buffer.byteLength(snap.finalText || "(no output)", "utf8"),
+        ),
+        ctx.getContextUsage(),
+        {
+          maxBatchBytes: projectionBatchBytes,
+          maxResultBytes: WAIT_PER_AGENT_MAX_BYTES,
+          minResultBytes: WAIT_MIN_RESULT_BYTES,
+          headroomShare: RESULT_HEADROOM_SHARE,
+          estimatedBytesPerToken: ESTIMATED_BYTES_PER_TOKEN,
+          fixedBytes,
+        },
+      );
+      let resultIndex = 0;
+      const sections = entries.map((entry) => {
+        if ("section" in entry) return entry.section;
+        const outputBudget = allocation.budgets[resultIndex++]!;
+        return `${entry.header}\n\n${truncatedOutput(entry.snap, outputBudget)}`;
+      });
 
       const combined = sections.join("\n\n---\n\n");
       const bounded = truncateHead(combined, {
@@ -1152,11 +1214,12 @@ export default function (pi: ExtensionAPI) {
     (entry, _options, theme) => {
       const data = entry.data;
       const failed = data?.status === "error";
+      const icon = failed ? theme.fg("error", "x") : theme.fg("success", "✓");
       return new Text(
-        `${theme.fg(failed ? "error" : "success", "\u25cf")} ` +
+        `${icon} ${theme.fg("accent", data?.title ?? "?")}` +
           theme.fg(
-            "muted",
-            `Agent "${data?.title ?? "?"}" ${failed ? "failed" : "finished"} \u00b7 ${data?.elapsed ?? "?"}`,
+            "dim",
+            ` ${failed ? "failed" : "finished"} · ${data?.elapsed ?? "?"}`,
           ),
         1,
         0,
@@ -1169,7 +1232,7 @@ export default function (pi: ExtensionAPI) {
     (entry, { expanded }, theme) => {
       const data = entry.data;
       const failed = data?.status === "error";
-      const icon = failed ? theme.fg("error", "x") : theme.fg("success", "■");
+      const icon = failed ? theme.fg("error", "x") : theme.fg("success", "✓");
       const header =
         `${icon} ` +
         theme.fg("accent", theme.bold(`by the way · ${data?.title ?? "?"}`)) +
@@ -1253,6 +1316,7 @@ export default function (pi: ExtensionAPI) {
       );
       return;
     }
+    persistId(snap.id);
 
     await openSubagentTakeover(ctx, manager.view, snap.id, {
       badge: "by the way",

package/extensions/subagents/navigation.ts

@@ -2,15 +2,17 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { TUI } from "@earendil-works/pi-tui";
 import {
   fitNavigationSides,
+  renderNavigationMetrics,
   type BelowEditorStripState,
 } from "../shared/below-editor-navigation.ts";
 import {
   unreadActivityCounts,
   type ActivityCounts,
 } from "../shared/activity-status.ts";
+import { spinnerFrame } from "../shared/spinner.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import { formatElapsed, type SubagentSnapshot } from "./src/domain.ts";
-import { formatContextUtilization } from "./src/format.ts";
+import { contextPercent } from "../shared/context-utilization.ts";
 
 export interface SubagentStripEntry {
   snapshot: SubagentSnapshot;
@@ -58,8 +60,15 @@ function statusColor(status: SubagentSnapshot["status"]) {
   return "error" as const;
 }
 
-function statusSquare(snapshot: SubagentSnapshot, theme: Theme) {
-  return theme.fg(statusColor(snapshot.status), "■");
+/**
+ * One status indicator per run state; doubles as the focus marker when
+ * selected. Running spins, in step with the dashboard and takeover headers.
+ */
+function statusGlyph(snapshot: SubagentSnapshot, theme: Theme, now: number) {
+  if (snapshot.status === "running")
+    return theme.fg("warning", spinnerFrame(now));
+  if (snapshot.status === "done") return theme.fg("success", "✓");
+  return theme.fg("error", "✗");
 }
 
 /** One-line subagent manager entry with the same affordance as Workflow. */
@@ -94,28 +103,48 @@ export class SubagentStripWidget {
     const entry = this.getEntry();
     if (!entry || width <= 0) return [];
     const { snapshot, counts } = entry;
-    const marker = this.strip.focused
+    const glyph = this.strip.focused
       ? this.theme.fg("accent", "❯")
-      : this.theme.fg("dim", "○");
-    const titleText = normalizeSubagentTitle(snapshot.title, snapshot.id);
-    const title = this.strip.focused
-      ? this.theme.bold(this.theme.fg("accent", titleText))
-      : this.theme.fg("text", titleText);
-    const model = snapshot.meta.modelLabel
-      ? cleanLine(snapshot.meta.modelLabel)
-      : undefined;
-    const left = ` ${marker} ${statusSquare(snapshot, this.theme)} ${title}${model ? this.theme.fg("dim", ` · ${model}`) : ""}`;
-    const settled = counts.done + counts.failed;
-    const total = counts.running + settled;
-    const metrics = [
-      `${settled}/${total} agents`,
-      formatElapsed(snapshot),
-      formatContextUtilization(snapshot.usage),
+      : statusGlyph(snapshot, this.theme, Date.now());
+    // A name only means something when it names the only active subagent; with
+    // several, an aggregate label is honest and the counts carry the detail.
+    const total = counts.running + counts.done + counts.failed;
+    const single = total === 1;
+    const labelText = single
+      ? normalizeSubagentTitle(snapshot.title, snapshot.id)
+      : "subagents";
+    const label = this.strip.focused
+      ? this.theme.bold(this.theme.fg("accent", labelText))
+      : this.theme.fg("text", labelText);
+    // The footer already shows the session model; the takeover view keeps the
+    // per-subagent model, so the one-line strip stays title-only.
+    const left = ` ${glyph} ${label}`;
+    // Worded counts read at a glance; the selected run's own state comes
+    // first so the emphasis colour always lands on the matching count. A lone
+    // subagent needs no count — the glyph and label already say it.
+    const donePart = counts.done > 0 ? `${counts.done} done` : undefined;
+    const failedPart =
+      counts.failed > 0 ? `${counts.failed} failed` : undefined;
+    const activity = single
+      ? []
+      : counts.running > 0
+        ? [`${counts.running} running`]
+        : snapshot.status === "error"
+          ? [failedPart, donePart]
+          : [donePart, failedPart];
+    const percent = contextPercent(snapshot.usage);
+    const right = renderNavigationMetrics(
+      this.theme,
+      [
+        ...activity,
+        formatElapsed(snapshot),
+        percent === undefined ? undefined : `${percent}% ctx`,
+      ],
       this.strip.focused ? "enter open · ↑ back" : "↓ to manage",
-    ]
-      .filter((part): part is string => Boolean(part))
-      .join(" · ");
-    const right = this.theme.fg(statusColor(snapshot.status), metrics);
+      single || snapshot.status === "running"
+        ? undefined
+        : statusColor(snapshot.status),
+    );
     return [fitNavigationSides(left, right, width)];
   }
 }