@tt-a1i/openpi 0.3.0 → 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,45 +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 { createDeferredResultDelivery } from "./src/result-delivery.ts";
-import { resultDeliveryOptions } from "../background-terminals/src/result-delivery.ts";
-import {
-  effectiveChildToolAllowlist,
-  resolveStandaloneChildProjectTrust,
-} from "../shared/child-session.ts";
+import { persistResultArtifact, projectResult } from "./src/result-artifact.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,
@@ -135,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;
@@ -190,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[], wake: boolean) => {
+  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");
@@ -249,7 +293,7 @@ export function createSubagentResultDispatcher(
         display: false,
         details,
       },
-      resultDeliveryOptions(wake),
+      { deliverAs: "followUp", triggerTurn: true },
     );
   };
 }
@@ -278,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 ?? "?"}`)) +
@@ -307,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;
@@ -322,18 +370,31 @@ export default function (pi: ExtensionAPI) {
   let requestWidgetRender: (() => void) | undefined;
   let navigationLayerRegistered = false;
   let dashboardOpen = false;
-  const resultDelivery = createDeferredResultDelivery<SubagentSnapshot>();
-  const dispatchResults = createSubagentResultDispatcher(pi);
-  const hideLifecycleTools = () =>
-    patchOwnedTools(pi, "subagents", {
-      disable: OPENPI_TOOL_SURFACE.subagents.deferred,
-    });
-  const showLifecycleTools = () =>
+  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
+    // delivery coordinator batches results that settled while it was busy.
+    deliver: dispatchResults,
+  });
+  pi.on("agent_settled", () => resultDelivery.parentSettled());
+  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 = () => {
@@ -387,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,
     );
@@ -436,25 +500,6 @@ export default function (pi: ExtensionAPI) {
     navigationLayerRegistered = true;
   };
 
-  /**
-   * `wake` decides whether this costs the model a turn. A subagent that
-   * settled while the model sits idle is the result it is waiting on. A
-   * backlog that piled up while it worked is not: waking once per stale
-   * subagent forces a turn each, and the model can only answer "that one
-   * already finished". `nextTurn` still enters context with the user's next
-   * message, without demanding a reply.
-   */
-  const deliverResults = (
-    snaps: readonly SubagentSnapshot[],
-    wake: boolean,
-  ) => {
-    dispatchResults(snaps, wake);
-  };
-
-  const flushResults = (wake: boolean) => {
-    deliverResults(resultDelivery.drain(), wake);
-  };
-
   const deliverBtwResult = (snap: SubagentSnapshot) => {
     // appendEntry is a synchronous SessionManager operation and emits an
     // entry_appended event, so it is safe while the parent is streaming and
@@ -500,15 +545,18 @@ export default function (pi: ExtensionAPI) {
     // subagent_wait can consume it before agent_settled flushes follow-ups.
     // Defer a copy: the live snapshot keeps mutating if the subagent is
     // restarted before the deferred result flushes.
+    // The delivery coordinator closes both sides of the wake-up race: it
+    // flushes now if the parent is already idle, otherwise the parent's next
+    // agent_settled edge rechecks this same pending Map.
     resultDelivery.defer({ ...snap, meta: { ...snap.meta } });
-    // Settled while the model sits idle: it has nothing else in flight, so
-    // this is the result it is waiting on — wake it.
-    if (sessionContext?.isIdle()) flushResults(true);
   };
 
   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;
@@ -530,10 +578,6 @@ export default function (pi: ExtensionAPI) {
     managerPromise?.then(updateStatus).catch(() => undefined);
   });
 
-  // These settled while the model was working on something else, so they go
-  // into context without forcing a turn per stale subagent.
-  pi.on("agent_settled", () => flushResults(false));
-
   pi.on("session_shutdown", async () => {
     if (navigationLayerRegistered) {
       removeEditorLayer(pi, "subagents");
@@ -610,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];
@@ -785,8 +794,7 @@ export default function (pi: ExtensionAPI) {
         if (worktree) await reclaimWorktree(cwd, worktree).catch(() => {});
         throw error;
       }
-
-      showLifecycleTools();
+      persistId(snap.id);
 
       return {
         content: [
@@ -831,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,
       );
@@ -852,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)
@@ -888,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, {
@@ -1170,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,
@@ -1187,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 ?? "?"}`)) +
@@ -1271,6 +1316,7 @@ export default function (pi: ExtensionAPI) {
       );
       return;
     }
+    persistId(snap.id);
 
     await openSubagentTakeover(ctx, manager.view, snap.id, {
       badge: "by the way",