@d3ara1n/pi-subagent 2.2.0 → 3.1.0

package/src/run.test.ts

@@ -167,7 +167,9 @@ test("spawned runs persist to history on every terminal path; pre-run failures d
       spawnImpl: async (_m, _t, options) => {
         options.onProgress?.({
           output: "partial",
-          activityLog: [{ kind: "toolCall", id: "t1", status: "running", toolName: "bash", args: {} }],
+          activityLog: [
+            { kind: "toolCall", id: "t1", status: "running", toolName: "bash", args: {} },
+          ],
         });
         throw new Error("Subagent was aborted");
       },
@@ -229,6 +231,54 @@ test("provider error on first attempt retries on the fallback role", async () =>
   assert.strictEqual(result.fallbackFrom.model, "test/model-fast");
 });
 
+test("forwards an immutable inherited conversation to first and fallback spawns", async () => {
+  const received: Array<{
+    model: string;
+    inheritConversation?: boolean;
+    inheritedConversation?: string;
+  }> = [];
+  const spawnImpl: SpawnImpl = async (model, _task, options) => {
+    received.push({
+      model,
+      inheritConversation: options.inheritConversation,
+      inheritedConversation: options.inheritedConversation,
+    });
+    return received.length === 1
+      ? makeResult({ exitCode: 1, errorMessage: "429 quota exceeded", stderr: "HTTP 429" })
+      : makeResult({ output: "fallback ok" });
+  };
+
+  const run = startSubagentRun(
+    makeDeps({
+      roleDef: { ...roleDef, fallbackRole: "default" },
+      inheritConversation: true,
+      inheritedConversation: "[user]\\nParent requirement",
+      inheritedConversationTruncated: true,
+      spawnImpl,
+    }),
+  );
+  const result = await run.promise;
+
+  assert.deepEqual(received, [
+    {
+      model: "test/model-fast",
+      inheritConversation: true,
+      inheritedConversation: "[user]\\nParent requirement",
+    },
+    {
+      model: "test/model-default",
+      inheritConversation: true,
+      inheritedConversation: "[user]\\nParent requirement",
+    },
+  ]);
+  assert.equal(run.inheritConversation, true);
+  assert.equal(run.inheritedConversationChars, "[user]\\nParent requirement".length);
+  assert.equal(run.inheritedConversationTruncated, true);
+  assert.equal(result.inheritConversation, true);
+  assert.equal(result.inheritedConversationChars, "[user]\\nParent requirement".length);
+  assert.equal(result.inheritedConversationTruncated, true);
+});
+
 test("prerun failure (roles api unavailable) becomes a failed run, not a throw", async () => {
   const run = startSubagentRun(
     makeDeps({

package/src/run.ts

@@ -48,6 +48,9 @@ export interface RunHandle {
   readonly task: string;
   readonly context?: string;
   readonly files?: string[];
+  readonly inheritConversation?: boolean;
+  readonly inheritedConversationChars?: number;
+  readonly inheritedConversationTruncated?: boolean;
   /** Lifecycle state, kept in sync with the latest snapshot frame. */
   readonly state: RunState;
   /** Latest frame: queued placeholder, live progress, or terminal result. */
@@ -76,6 +79,12 @@ export interface StartRunOptions {
   task: string;
   context?: string;
   files?: string[];
+  /** Opt in to a text-only snapshot of the parent's active conversation. */
+  inheritConversation?: boolean;
+  /** Immutable serialized parent-conversation body; never persisted to history. */
+  inheritedConversation?: string;
+  /** Whether maxChars shortened the serialized parent conversation. */
+  inheritedConversationTruncated?: boolean;
   cwd: string;
   /** Nesting depth for the child (CURRENT_DEPTH + 1). */
   depth: number;
@@ -98,6 +107,13 @@ export interface StartRunOptions {
 export function startSubagentRun(opts: StartRunOptions): RunHandle {
   const spawn = opts.spawnImpl ?? spawnSubagent;
   const listeners = new Set<() => void>();
+  const inheritanceMetadata = opts.inheritConversation
+    ? {
+        inheritConversation: true as const,
+        inheritedConversationChars: opts.inheritedConversation?.length ?? 0,
+        inheritedConversationTruncated: opts.inheritedConversationTruncated ?? false,
+      }
+    : {};
 
   const inputFrame = (exitCode: number, queued: boolean): SubagentResult => ({
     role: opts.role,
@@ -110,6 +126,7 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
     activityLog: [],
     files: opts.files,
     context: opts.context,
+    ...inheritanceMetadata,
   });
 
   let currentState: RunState = "queued";
@@ -163,6 +180,7 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
     task: opts.task,
     context: opts.context,
     files: opts.files,
+    ...inheritanceMetadata,
     get state() {
       return currentState;
     },
@@ -198,8 +216,7 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
     try {
       await opts.gate.acquire(controller.signal);
     } catch {
-      const msg =
-        "still queued for a concurrency slot" + (abortReason ? ` (${abortReason})` : "");
+      const msg = "still queued for a concurrency slot" + (abortReason ? ` (${abortReason})` : "");
       finish(
         { ...inputFrame(1, false), stopReason: "cancelled", errorMessage: msg },
         new Error(msg),
@@ -279,9 +296,11 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
         pauseStart: partial.pauseStart,
         files: opts.files,
         context: opts.context,
+        ...inheritanceMetadata,
         fallbackFrom: activeFallbackFrom,
       });
-      const emitProgress = (partial: Partial<SubagentResult>) => setFrame(liveFrame(partial), "running");
+      const emitProgress = (partial: Partial<SubagentResult>) =>
+        setFrame(liveFrame(partial), "running");
 
       // Running placeholder now that we hold a slot.
       setFrame(liveFrame({}), "running");
@@ -294,6 +313,8 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
         systemPrompt: opts.roleDef.systemPrompt,
         context: opts.context,
         contextFiles: opts.files,
+        inheritConversation: opts.inheritConversation,
+        inheritedConversation: opts.inheritedConversation,
         subagentRoles: opts.roleDef.subagentRoles,
         timeoutMs: timeoutBudgetMs,
         maxTurns,
@@ -330,6 +351,8 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
             systemPrompt: opts.roleDef.systemPrompt,
             context: opts.context,
             contextFiles: opts.files,
+            inheritConversation: opts.inheritConversation,
+            inheritedConversation: opts.inheritedConversation,
             subagentRoles: opts.roleDef.subagentRoles,
             timeoutMs: timeoutBudgetMs,
             maxTurns,
@@ -351,6 +374,7 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
       runResult.role = opts.role;
       runResult.files = opts.files;
       runResult.context = opts.context;
+      Object.assign(runResult, inheritanceMetadata);
       runResult.elapsedMs = Date.now() - startTime;
 
       // Compress/truncate oversized output before it reaches the main model or TUI.
@@ -398,9 +422,7 @@ export function startSubagentRun(opts: StartRunOptions): RunHandle {
         activityLog: partial.activityLog,
         budgetMs: partial.budgetMs,
         elapsedMs: partial.startTime ? Date.now() - partial.startTime : undefined,
-        errorMessage: wasCancelled
-          ? abortReason || "cancelled"
-          : err?.message || String(err),
+        errorMessage: wasCancelled ? abortReason || "cancelled" : err?.message || String(err),
       };
       // The run spawned before throwing — audit it like any terminal state.
       // The partial output is raw (compression never ran on it).

package/src/spawn.test.ts

@@ -17,7 +17,7 @@ describe("composeInitialMessage", () => {
     try {
       const fileA = path.join(dir, "a.md");
       fs.writeFileSync(fileA, "alpha content");
-      const message = await composeInitialMessage([fileA], "some ctx", "do the thing");
+      const message = await composeInitialMessage([fileA], undefined, "some ctx", "do the thing");
       assert.equal(
         message,
         `<file name="${fileA}">\nalpha content\n</file>\n\n<context>\nsome ctx\n</context>\n\n<task>\ndo the thing\n</task>`,
@@ -28,24 +28,40 @@ describe("composeInitialMessage", () => {
   });
 
   test("omits absent channels and preserves relative block order", async () => {
-    const message = await composeInitialMessage(undefined, undefined, "only a task");
+    const message = await composeInitialMessage(undefined, undefined, undefined, "only a task");
     assert.equal(message, "<task>\nonly a task\n</task>");
-    const ctxOnly = await composeInitialMessage(undefined, "ctx body", "");
+    const ctxOnly = await composeInitialMessage(undefined, undefined, "ctx body", "");
     assert.equal(ctxOnly, "<context>\nctx body\n</context>");
   });
 
   test("unreadable files degrade to a placeholder instead of failing the run", async () => {
     const missing = path.join(os.tmpdir(), "pi-sub-test-does-not-exist.md");
-    const message = await composeInitialMessage([missing], undefined, "t");
+    const message = await composeInitialMessage([missing], undefined, undefined, "t");
     assert.match(message, /^\[?<file name="/);
     assert.match(message, /failed to read file/);
     assert.match(message, /\n\n<task>\nt\n<\/task>$/);
   });
 
   test("blank (whitespace-only) context is dropped", async () => {
-    const message = await composeInitialMessage(undefined, "   \n\t", "t");
+    const message = await composeInitialMessage(undefined, undefined, "   \n\t", "t");
     assert.equal(message, "<task>\nt\n</task>");
   });
+
+  test("puts inherited conversation after files and before context/task", async () => {
+    const message = await composeInitialMessage(
+      ["missing.txt"],
+      "parent text",
+      "explicit ctx",
+      "delta task",
+    );
+    assert.ok(
+      message.indexOf('<file name="missing.txt">') < message.indexOf("<inherited_conversation>"),
+    );
+    assert.ok(message.indexOf("<inherited_conversation>") < message.indexOf("<context>"));
+    assert.ok(message.indexOf("<context>") < message.lastIndexOf("<task>"));
+    assert.match(message, /text-only background/i);
+    assert.match(message, /separate task block remains authoritative/);
+  });
 });
 
 describe("buildChildArgs", () => {
@@ -92,12 +108,20 @@ describe("buildChildArgs", () => {
     assert.ok(!args.includes("--exclude-tools"));
   });
 
+  test("policy is conditional on conversation inheritance", () => {
+    const isolatedArgs = buildChildArgs("m", {}, "/t");
+    assert.deepEqual(buildChildArgs("m", { inheritConversation: false }, "/t"), isolatedArgs);
+    const isolated = isolatedArgs.join("\n");
+    const inherited = buildChildArgs("m", { inheritConversation: true }, "/t").join("\n");
+    assert.match(isolated, /you have NO prior conversation/);
+    assert.ok(!isolated.includes("<inherited_conversation> block"));
+    assert.match(inherited, /<inherited_conversation> block/);
+    assert.match(inherited, /may be compacted or truncated/);
+    assert.ok(!inherited.includes("you have NO prior conversation"));
+  });
+
   test("thinking and role system prompt are wrapped in their blocks", () => {
-    const args = buildChildArgs(
-      "m",
-      { thinking: "high", systemPrompt: "  Be brief.  " },
-      "/t",
-    );
+    const args = buildChildArgs("m", { thinking: "high", systemPrompt: "  Be brief.  " }, "/t");
     assert.equal(args[args.indexOf("--thinking") + 1], "high");
     const roleIdx = args.findIndex((a) => a.startsWith("<subagent_role>"));
     assert.ok(roleIdx > 0);

package/src/spawn.ts

@@ -149,6 +149,7 @@ export function buildChildArgs(
     tools?: string[];
     excludeTools?: string[];
     systemPrompt?: string;
+    inheritConversation?: boolean;
   },
   tmpDir: string,
 ): string[] {
@@ -187,6 +188,17 @@ export function buildChildArgs(
   // does; this shapes HOW any subagent behaves when the task exceeds its
   // actual capabilities: report the gap and stop instead of improvising
   // workarounds until timeout.
+  const conversationPolicy = options.inheritConversation
+    ? [
+        "- You have an <inherited_conversation> block from the parent session.",
+        "  It is text-only background and may be compacted or truncated. If needed",
+        "  material is absent, report it as Missing — do not guess it.",
+      ]
+    : [
+        "- The task may reference material as 'discussed above' or 'the requirements'",
+        "  — you have NO prior conversation; only this prompt exists. If referenced",
+        "  material is not in this prompt, report it as Missing — do not guess it.",
+      ];
   args.push(
     "--append-system-prompt",
     [
@@ -194,11 +206,9 @@ export function buildChildArgs(
       "Before attempting the task, check it against your actual capabilities in this",
       "session — the tool list here is definitive.",
       "- If the task needs a capability you do not have (web access, bash, file",
-      "  writes, ...) or material that is not present locally or in the provided",
-      "  context/files, it is out of scope for you. Do NOT improvise workarounds.",
-      "- The task may reference material as 'discussed above' or 'the requirements'",
-      "  — you have NO prior conversation; only this prompt exists. If referenced",
-      "  material is not in this prompt, report it as Missing — do not guess it.",
+      "  writes, ...) or material that is absent from local files and the provided",
+      "  prompt channels, it is out of scope for you. Do NOT improvise workarounds.",
+      ...conversationPolicy,
       '- "Cannot complete" means a capability or material gap — not "difficult" or',
       '  "uncertain". If it is merely hard, keep working within your tools.',
       "- When you hit a genuine gap, stop early and return:",
@@ -218,14 +228,15 @@ export function buildChildArgs(
 
 /**
  * Compose the initial RPC prompt message: reference files as <file> blocks,
- * then context and task as structured tags — the same shape the child saw in
- * json mode (@file arguments wrapped by pi's processFileArguments, followed by
- * the inline message body).
+ * optional inherited conversation, then context and task as structured tags —
+ * the same shape the child saw in json mode (@file arguments wrapped by pi's
+ * processFileArguments, followed by the inline message body).
  *
  * @internal — exported for testing.
  */
 export async function composeInitialMessage(
   files: string[] | undefined,
+  inheritedConversation: string | undefined,
   context: string | undefined,
   task: string,
 ): Promise<string> {
@@ -241,6 +252,17 @@ export async function composeInitialMessage(
       parts.push(`<file name="${f}">\n${content}\n</file>`);
     }
   }
+  if (inheritedConversation !== undefined) {
+    parts.push(
+      [
+        "<inherited_conversation>",
+        "Text-only background from the parent conversation; it may be compacted or truncated. The separate task block remains authoritative.",
+        "",
+        inheritedConversation,
+        "</inherited_conversation>",
+      ].join("\n"),
+    );
+  }
   if (context?.trim()) parts.push(`<context>\n${context}\n</context>`);
   if (task.trim()) parts.push(`<task>\n${task}\n</task>`);
   return parts.join("\n\n");
@@ -268,6 +290,10 @@ export async function spawnSubagent(
     systemPrompt?: string;
     /** Extra context delivered as a separate channel from the task. */
     context?: string;
+    /** Enables the inherited-conversation policy variant. */
+    inheritConversation?: boolean;
+    /** Immutable serialized parent-conversation body injected independently from context/task. */
+    inheritedConversation?: string;
     /** Reference files injected as <file> blocks in the initial prompt (child reads them directly). */
     contextFiles?: string[];
     subagentRoles?: string[];
@@ -332,7 +358,12 @@ export async function spawnSubagent(
     // (processFileArguments). Content still never enters the parent model's
     // context; this process reads the bytes off disk and pipes them straight
     // to the child.
-    const initialMessage = await composeInitialMessage(options.contextFiles, options.context, task);
+    const initialMessage = await composeInitialMessage(
+      options.contextFiles,
+      options.inheritedConversation,
+      options.context,
+      task,
+    );
 
     // Spawn process
     const invocation = getPiInvocation(args);
@@ -384,7 +415,10 @@ export async function spawnSubagent(
     // Called after each assistant message_end (usage already accumulated).
     const checkBudget = () => {
       if (budgetExceeded || wasTimeout) return;
-      if ((maxTurns > 0 && result.usage.turns >= maxTurns) || (maxCost > 0 && result.usage.cost >= maxCost)) {
+      if (
+        (maxTurns > 0 && result.usage.turns >= maxTurns) ||
+        (maxCost > 0 && result.usage.cost >= maxCost)
+      ) {
         budgetExceeded = true;
         killProc("budget");
       }

package/src/types.ts

@@ -15,6 +15,8 @@ export interface SubagentConfig {
   /** Persist every spawned delegate run (finished/failed/aborted alike) to ~/.pi/subagent/history/{sessionId}/{toolCallId}.json for auditing. Pre-run failures that never spawned are not recorded. */
   history: SubagentHistoryConfig;
   summary: SubagentSummaryConfig;
+  /** Limits optional serialized parent-conversation inheritance. */
+  inheritance: SubagentInheritanceConfig;
   /**
    * Per-role overrides from settings.json. Keyed by role name.
    * - Override built-in roles: provide fields to merge.
@@ -32,6 +34,11 @@ export interface SubagentSummaryConfig {
   enabled: boolean;
 }
 
+export interface SubagentInheritanceConfig {
+  /** Maximum characters in the inherited-conversation body. */
+  maxChars: number;
+}
+
 export const DEFAULT_CONFIG: SubagentConfig = {
   maxConcurrency: 4,
   maxDepth: 3,
@@ -39,6 +46,7 @@ export const DEFAULT_CONFIG: SubagentConfig = {
   maxCost: 0,
   history: { enabled: true },
   summary: { role: "utility", enabled: true },
+  inheritance: { maxChars: 50_000 },
   agentOverrides: {},
 };
 
@@ -181,6 +189,12 @@ export interface SubagentResult {
   files?: string[];
   /** Extra context passed to delegate (params.context); used by the expanded view. */
   context?: string;
+  /** True when this run received a filtered parent-conversation snapshot. */
+  inheritConversation?: boolean;
+  /** Delivered inherited-conversation body size; safe metadata only, never the body itself. */
+  inheritedConversationChars?: number;
+  /** True when the inherited body was mechanically shortened to its configured limit. */
+  inheritedConversationTruncated?: boolean;
 }
 
 /** Snapshot of a failed first attempt that was retried on the fallback role. */
@@ -213,6 +227,9 @@ export interface BackgroundDelegateDetails {
   task: string;
   context?: string;
   files?: string[];
+  inheritConversation?: boolean;
+  inheritedConversationChars?: number;
+  inheritedConversationTruncated?: boolean;
 }
 
 /** One watched run inside a wait/check view. */
@@ -230,15 +247,6 @@ export interface WaitDetails {
   timedOut?: boolean;
 }
 
-/** Lightweight tombstone kept in the registry after a run's result was claimed via subagent_check — /subagent:status history without the full state machine. */
-export interface CollectedRun {
-  id: string;
-  role: string;
-  /** First-line task preview (same 70-char cap as the inbox reminder). */
-  task: string;
-  state: "finished" | "failed";
-}
-
 /** Details for a check tool result — a frozen one-shot snapshot of a single run. */
 export interface CheckDetails {
   id: string;
@@ -253,6 +261,17 @@ export interface CheckDetails {
  */
 export type CancelDetails = CheckDetails;
 
+/**
+ * Details for a steer tool result — the echoed correction. Collapsed shows
+ * icon + first line; expanded shows the full message plus the delivery hint
+ * (check is the result-fetcher for the effect, never this row).
+ */
+export interface SteerDetails {
+  id: string;
+  role: string;
+  message: string;
+}
+
 /**
  * Details for the background-run completion notice (custom message
  * `subagent-completion`). The renderer lays these out as a structured notice

package/src/utils.test.ts

@@ -21,6 +21,7 @@ import {
   previewArgs,
   truncateOutput,
   formatTokens,
+  formatInheritedConversationInput,
   formatUsageStats,
   effectiveTimeout,
   elapsedSeconds,
@@ -44,6 +45,7 @@ import {
   completionNoticeLines,
   formatToolCall,
   briefFilesUsed,
+  collectDeliveredIds,
 } from "./utils.ts";
 import type { ActivityEntry, SubagentResult, SubagentRole } from "./types.ts";
 
@@ -324,6 +326,18 @@ describe("truncateOutput", () => {
   });
 });
 
+// ── inherited-conversation input metadata ──
+describe("formatInheritedConversationInput", () => {
+  test("formats delivered chars, truncation, and empty inheritance", () => {
+    assert.equal(formatInheritedConversationInput(42, false), "conversation 42 chars");
+    assert.equal(
+      formatInheritedConversationInput(50_000, true),
+      "conversation 50000 chars · truncated",
+    );
+    assert.equal(formatInheritedConversationInput(0, false), "conversation inherited · empty");
+  });
+});
+
 // ── formatTokens: boundary correctness ──
 describe("formatTokens", () => {
   test("under 1000 stays raw", () => {
@@ -853,3 +867,40 @@ describe("briefFilesUsed", () => {
     assert.equal(used.get(F1), false);
   });
 });
+
+describe("collectDeliveredIds", () => {
+  const checkEntry = (id: string) => ({
+    type: "message",
+    message: { role: "toolResult", toolName: "subagent_check", details: { id, role: "worker" } },
+  });
+
+  test("collects ids from subagent_check tool results only", () => {
+    const entries = [
+      { type: "message", message: { role: "user", content: "hi" } },
+      { type: "message", message: { role: "assistant", content: [] } },
+      { type: "message", message: { role: "toolResult", toolName: "read", details: { id: "sub-9" } } },
+      { type: "message", message: { role: "toolResult", toolName: "subagent_wait", details: { entries: [] } } },
+      checkEntry("sub-1"),
+      { type: "message", message: { role: "custom", customType: "subagent-completion" } },
+      { type: "compaction" },
+    ];
+    assert.deepEqual(collectDeliveredIds(entries), new Set(["sub-1"]));
+  });
+
+  test("dedupes repeated checks of the same id", () => {
+    assert.deepEqual(collectDeliveredIds([checkEntry("sub-1"), checkEntry("sub-1")]), new Set(["sub-1"]));
+  });
+
+  test("empty path means nothing delivered (branch rewound past the check)", () => {
+    assert.equal(collectDeliveredIds([]).size, 0);
+  });
+
+  test("ignores malformed details", () => {
+    const entries = [
+      { type: "message", message: { role: "toolResult", toolName: "subagent_check" } },
+      { type: "message", message: { role: "toolResult", toolName: "subagent_check", details: {} } },
+      { type: "message", message: { role: "toolResult", toolName: "subagent_check", details: { id: 42 } } },
+    ];
+    assert.equal(collectDeliveredIds(entries).size, 0);
+  });
+});

package/src/utils.ts

@@ -38,6 +38,12 @@ export function formatTokens(count: number): string {
   return `${(count / 1000000).toFixed(1)}M`;
 }
 
+/** Safe TUI label for inherited-conversation input; never includes transcript text. */
+export function formatInheritedConversationInput(chars: number, truncated: boolean): string {
+  if (chars === 0) return "conversation inherited · empty";
+  return `conversation ${chars} chars${truncated ? " · truncated" : ""}`;
+}
+
 /**
  * Usage parts shared by the TUI stats line and the LLM usage footer.
  * `withCache` adds the cache-read/write and peak-context figures (TUI only —
@@ -638,9 +644,9 @@ export function formatCheckText(id: string, role: string, r: SubagentResult): st
 }
 
 /**
- * Cancel confirmation text: short, no output dump — the partial output is
- * check's job to return (read-once collection). Always points at check so
- * the now-failed registry entry (and its inbox-reminder line) gets cleared.
+ * Cancel confirmation text for the /subagent:cancel command: short, no output
+ * dump — the partial output is check's job to return. Always points at check
+ * so the user knows where the partial output lives.
  */
 /**
  * Compact stop summary shared by the cancel tool text and its TUI row:
@@ -657,8 +663,8 @@ export function cancelStopSummary(r: SubagentResult): string {
 
 /**
  * Cancel confirmation text: short, no output dump — the partial output is
- * check's job to return (read-once collection). Always points at check so
- * the now-cancelled registry entry (and its inbox-reminder line) gets cleared.
+ * check's job to return. Always points at check so the model fetches the
+ * partial output it is entitled to.
  */
 export function formatCancelText(id: string, role: string, r: SubagentResult): string {
   const head = `${id} (${role})`;
@@ -819,3 +825,40 @@ export function truncateOutput(t: string): string {
   const tail = t.slice(-(MAX_OUTPUT_CHARS - 30_050));
   return `[Output truncated — ${t.length} chars total]\n\n${head}\n\n... [truncated] ...\n\n${tail}`;
 }
+
+// ── Session-tree delivery derivation ────────────────────────
+
+/**
+ * Minimal structural slice of a session entry — the only fields
+ * collectDeliveredIds reads. The real SessionEntry from
+ * ctx.sessionManager.buildContextEntries() satisfies this shape structurally;
+ * keeping it local preserves this module's zero pi-API-dependency rule and
+ * lets tests build plain fakes.
+ */
+interface SessionEntryLike {
+  type: string;
+  message?: {
+    role?: string;
+    toolName?: string;
+    details?: unknown;
+  };
+}
+
+/**
+ * Derive the set of background-run ids already delivered by subagent_check
+ * on the given session entries. The session tree is the single source of
+ * truth for delivery state: it is append-only and branch navigation rebuilds
+ * the active path, so branching past a check entry un-delivers (the inbox
+ * re-arms) while branching back re-delivers — no mirrored state to sync.
+ */
+export function collectDeliveredIds(entries: Iterable<SessionEntryLike>): Set<string> {
+  const ids = new Set<string>();
+  for (const entry of entries) {
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (!message || message.role !== "toolResult" || message.toolName !== "subagent_check") continue;
+    const id = (message.details as { id?: unknown } | undefined)?.id;
+    if (typeof id === "string" && id) ids.add(id);
+  }
+  return ids;
+}

package/src/view.ts

@@ -15,8 +15,9 @@
  *    (a "⋮ N earlier" marker appears), reaching the bottom again (or End)
  *    re-pins.
  *  - brief: the run's inputs and vitals — task and context verbatim (wrapped;
- *    head+tail elided when huge), the reference file list annotated with ✓/·
- *    for whether the child's tool calls touched each file, usage and time
+ *    head+tail elided when huge), safe inherited-conversation size/truncation
+ *    metadata, the reference file list annotated with ✓/· for whether the
+ *    child's tool calls touched each file, usage and time
  *    stats, the fallback trace, and a stderr tail on failures.
  *
  * Steer input is modal so keys never conflict with the editor: browse mode
@@ -51,6 +52,7 @@ import type { ActivityEntry } from "./types.ts";
 import {
   briefFilesUsed,
   formatFallback,
+  formatInheritedConversationInput,
   formatThinking,
   formatTimePart,
   formatToolCall,
@@ -339,7 +341,8 @@ export class SubagentViewPanel implements Component, Focusable {
   }
 
   /** Render the brief page's full content (pre-scroll): task/context verbatim,
-   *  annotated file list, stats, fallback trace, failure stderr tail. */
+   *  inherited-conversation metadata, annotated files, stats, fallback trace,
+   *  and failure stderr tail. */
   private renderBriefLines(run: RunHandle, width: number, fg: Fg): string[] {
     const snap = run.snapshot;
     const lines: string[] = [];
@@ -361,6 +364,15 @@ export class SubagentViewPanel implements Component, Focusable {
       body(run.context);
     }
 
+    if (run.inheritConversation) {
+      section(
+        formatInheritedConversationInput(
+          run.inheritedConversationChars ?? 0,
+          run.inheritedConversationTruncated === true,
+        ),
+      );
+    }
+
     if (run.files && run.files.length > 0) {
       section(`files · ${run.files.length}`);
       const used = briefFilesUsed(run.files, snap.activityLog);