@d3ara1n/pi-subagent 2.2.0 → 3.1.0

package/src/inheritance.ts

@@ -0,0 +1,188 @@
+/**
+ * Deterministic, text-only serialization of an active pi session branch for
+ * optional subagent conversation inheritance.
+ */
+
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+const OMISSION_MARKER = "[Earlier inherited conversation omitted for length.]";
+const MESSAGE_OMISSION_MARKER = "[Earlier text in this message omitted.]";
+
+type EntryLike = {
+  type?: unknown;
+  summary?: unknown;
+  message?: unknown;
+  retainedTail?: unknown;
+};
+
+type MessageLike = {
+  role?: unknown;
+  content?: unknown;
+  summary?: unknown;
+};
+
+type Chunk = {
+  kind: "summary" | "dialogue";
+  text: string;
+};
+
+export interface InheritedConversationSnapshot {
+  /** Delimiter-safe text delivered to the child. */
+  text: string;
+  /** True when eligible inherited content was omitted to satisfy maxChars. */
+  truncated: boolean;
+}
+
+/** Keep inherited text from being interpreted as one of the surrounding prompt tags. */
+function escapePromptText(text: string): string {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;");
+}
+
+function textContent(content: unknown): string {
+  if (typeof content === "string") return escapePromptText(content);
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((part) => {
+      if (!part || typeof part !== "object") return [];
+      const block = part as { type?: unknown; text?: unknown };
+      return block.type === "text" && typeof block.text === "string"
+        ? [escapePromptText(block.text)]
+        : [];
+    })
+    .join("");
+}
+
+function serializeMessage(message: unknown): Chunk | undefined {
+  if (!message || typeof message !== "object") return undefined;
+  const { role, content, summary } = message as MessageLike;
+  if (role === "user" || role === "assistant") {
+    const text = textContent(content);
+    return text ? { kind: "dialogue", text: `[${role}]\n${text}` } : undefined;
+  }
+  if (role === "compactionSummary" && typeof summary === "string" && summary) {
+    return {
+      kind: "summary",
+      text: `[Compaction summary]\n${escapePromptText(summary)}`,
+    };
+  }
+  if (role === "branchSummary" && typeof summary === "string" && summary) {
+    return { kind: "summary", text: `[Branch summary]\n${escapePromptText(summary)}` };
+  }
+  return undefined;
+}
+
+function truncateDialogueChunk(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  const newline = text.indexOf("\n");
+  const label = newline >= 0 ? text.slice(0, newline) : "[message]";
+  const prefix = `${label}\n${MESSAGE_OMISSION_MARKER}\n`;
+  if (prefix.length >= maxChars) return prefix.slice(0, maxChars);
+  return prefix + text.slice(text.length - (maxChars - prefix.length));
+}
+
+/** Select newest complete dialogue chunks, truncating only the newest chunk as a last resort. */
+function newestDialogue(chunks: Chunk[], maxChars: number): string {
+  if (maxChars <= 0 || chunks.length === 0) return "";
+  const selected: string[] = [];
+  let used = 0;
+  for (let i = chunks.length - 1; i >= 0; i -= 1) {
+    const separator = selected.length > 0 ? 2 : 0;
+    const remaining = maxChars - used - separator;
+    if (remaining <= 0) break;
+    const text = chunks[i].text;
+    if (text.length <= remaining) {
+      selected.unshift(text);
+      used += separator + text.length;
+      continue;
+    }
+    selected.unshift(truncateDialogueChunk(text, remaining));
+    break;
+  }
+  return selected.join("\n\n");
+}
+
+/**
+ * Serialize the supplied active, compaction-aware session entries in order.
+ * Only compaction/branch summaries and user/assistant text are retained.
+ */
+export function serializeInheritedConversation(
+  entries: SessionEntry[],
+  maxChars: number,
+): InheritedConversationSnapshot {
+  const limit = Number.isFinite(maxChars) ? Math.max(0, Math.floor(maxChars)) : 0;
+  if (limit === 0) return { text: "", truncated: false };
+  const chunks: Chunk[] = [];
+
+  const addMessage = (message: unknown) => {
+    const serialized = serializeMessage(message);
+    if (serialized) chunks.push(serialized);
+  };
+
+  for (const rawEntry of entries) {
+    const entry = rawEntry as EntryLike;
+    if (entry.type === "compaction") {
+      if (typeof entry.summary === "string" && entry.summary) {
+        chunks.push({
+          kind: "summary",
+          text: `[Compaction summary]\n${escapePromptText(entry.summary)}`,
+        });
+      }
+      // Newer compaction entries materialize their kept context here. The
+      // installed firstKeptEntryId shape returns those entries separately.
+      if (Array.isArray(entry.retainedTail)) {
+        for (const message of entry.retainedTail) addMessage(message);
+      }
+      continue;
+    }
+    if (entry.type === "branch_summary") {
+      if (typeof entry.summary === "string" && entry.summary) {
+        chunks.push({
+          kind: "summary",
+          text: `[Branch summary]\n${escapePromptText(entry.summary)}`,
+        });
+      }
+      continue;
+    }
+    if (entry.type === "message") addMessage(entry.message);
+  }
+
+  const full = chunks.map((chunk) => chunk.text).join("\n\n");
+  if (full.length <= limit) return { text: full, truncated: false };
+
+  const summaryText = chunks
+    .filter((chunk) => chunk.kind === "summary")
+    .map((chunk) => chunk.text)
+    .join("\n\n");
+  const dialogueChunks = chunks.filter((chunk) => chunk.kind === "dialogue");
+  const dialogueText = dialogueChunks.map((chunk) => chunk.text).join("\n\n");
+
+  // Reserve an explicit marker, then retain summary context plus the newest
+  // dialogue. Start with a 40/60 split, but redistribute every unused char so
+  // a short side never wastes capacity. This is deterministic and model-free.
+  const hasSummary = summaryText.length > 0;
+  const hasDialogue = dialogueText.length > 0;
+  const separatorChars = (hasSummary ? 2 : 0) + (hasDialogue ? 2 : 0);
+  if (limit <= OMISSION_MARKER.length + separatorChars) {
+    return { text: OMISSION_MARKER.slice(0, limit), truncated: true };
+  }
+  const available = limit - OMISSION_MARKER.length - separatorChars;
+  let summaryBudget =
+    hasSummary && hasDialogue ? Math.floor(available * 0.4) : hasSummary ? available : 0;
+  let dialogueBudget = hasDialogue ? available - summaryBudget : 0;
+
+  if (summaryText.length < summaryBudget) {
+    dialogueBudget += summaryBudget - summaryText.length;
+    summaryBudget = summaryText.length;
+  }
+  if (dialogueText.length < dialogueBudget) {
+    summaryBudget += dialogueBudget - dialogueText.length;
+    dialogueBudget = dialogueText.length;
+  }
+
+  const selectedSummary = summaryBudget > 0 ? summaryText.slice(0, summaryBudget) : "";
+  const selectedDialogue = newestDialogue(dialogueChunks, dialogueBudget);
+  return {
+    text: [selectedSummary, OMISSION_MARKER, selectedDialogue].filter(Boolean).join("\n\n"),
+    truncated: true,
+  };
+}

package/src/reminder.test.ts

@@ -5,9 +5,10 @@
  *   node --test packages/pi-subagent/src/reminder.test.ts
  *
  * Coverage: row formatting per state (queued/running/finished/failed/budget),
- * byte-stability between calls (the cache-prefix contract), empty-inbox
- * no-op, and cache-stable head injection (string content, block content,
- * non-user first message, empty transcript).
+ * delivery-derived row removal (terminal rows checked on the active branch
+ * drop out; live rows never do), byte-stability between calls (the
+ * cache-prefix contract), empty-inbox no-op, and cache-stable head injection
+ * (string content, block content, non-user first message, empty transcript).
  */
 
 import { test, describe } from "node:test";
@@ -40,19 +41,22 @@ function entry(partial: Partial<InboxEntry> & Pick<InboxEntry, "id" | "state">):
 
 describe("buildInboxReminder", () => {
   test("empty inbox returns undefined (zero injection)", () => {
-    assert.equal(buildInboxReminder([]), undefined);
+    assert.equal(buildInboxReminder([], new Set()), undefined);
   });
 
   test("queued and running rows carry no time-derived detail", () => {
-    const text = buildInboxReminder([
-      entry({ id: "sub-3", state: "queued", snapshot: frame({ exitCode: -1, queued: true }) }),
-      entry({
-        id: "sub-2",
-        state: "running",
-        // Live frame: startTime present — a naive formatter would derive elapsed from it.
-        snapshot: frame({ exitCode: -1, startTime: Date.now() - 60_000 }),
-      }),
-    ])!;
+    const text = buildInboxReminder(
+      [
+        entry({ id: "sub-3", state: "queued", snapshot: frame({ exitCode: -1, queued: true }) }),
+        entry({
+          id: "sub-2",
+          state: "running",
+          // Live frame: startTime present — a naive formatter would derive elapsed from it.
+          snapshot: frame({ exitCode: -1, startTime: Date.now() - 60_000 }),
+        }),
+      ],
+      new Set(),
+    )!;
     assert.match(text, /\n- sub-3 \(worker\) — queued — "Investigate flaky tests/);
     assert.match(text, /\n- sub-2 \(worker\) — running — "Investigate flaky tests/);
     // No seconds anywhere on live rows — byte-stability contract.
@@ -60,56 +64,68 @@ describe("buildInboxReminder", () => {
   });
 
   test("finished row freezes duration from elapsedMs", () => {
-    const text = buildInboxReminder([
-      entry({
-        id: "sub-1",
-        state: "finished",
-        snapshot: frame({ exitCode: 0, elapsedMs: 192_000 }),
-      }),
-    ])!;
+    const text = buildInboxReminder(
+      [
+        entry({
+          id: "sub-1",
+          state: "finished",
+          snapshot: frame({ exitCode: 0, elapsedMs: 192_000 }),
+        }),
+      ],
+      new Set(),
+    )!;
     assert.match(text, /\n- sub-1 \(worker\) — finished \(ran 3m12s\) — "Investigate flaky tests/);
   });
 
   test("budget-stopped finished row is flagged partial", () => {
-    const text = buildInboxReminder([
-      entry({
-        id: "sub-1",
-        state: "finished",
-        snapshot: frame({ exitCode: 0, elapsedMs: 300_000, stopReason: "budget_exceeded" }),
-      }),
-    ])!;
+    const text = buildInboxReminder(
+      [
+        entry({
+          id: "sub-1",
+          state: "finished",
+          snapshot: frame({ exitCode: 0, elapsedMs: 300_000, stopReason: "budget_exceeded" }),
+        }),
+      ],
+      new Set(),
+    )!;
     assert.match(text, /— finished, partial — budget exceeded \(ran 5m\) —/);
   });
 
   test("failed row carries the error preview, first line only", () => {
-    const text = buildInboxReminder([
-      entry({
-        id: "sub-4",
-        state: "failed",
-        snapshot: frame({
-          exitCode: 1,
-          elapsedMs: 5_000,
-          errorMessage: "provider timeout\nretry hint: check quota",
+    const text = buildInboxReminder(
+      [
+        entry({
+          id: "sub-4",
+          state: "failed",
+          snapshot: frame({
+            exitCode: 1,
+            elapsedMs: 5_000,
+            errorMessage: "provider timeout\nretry hint: check quota",
+          }),
         }),
-      }),
-    ])!;
+      ],
+      new Set(),
+    )!;
     assert.match(text, /— failed — provider timeout \(ran 5s\) —/);
     assert.doesNotMatch(text, /retry hint/);
   });
 
   test("cancelled row carries the cancel label, not failed", () => {
-    const text = buildInboxReminder([
-      entry({
-        id: "sub-5",
-        state: "failed",
-        snapshot: frame({
-          exitCode: 1,
-          stopReason: "cancelled",
-          elapsedMs: 7_000,
-          errorMessage: "user: wrong direction after review",
+    const text = buildInboxReminder(
+      [
+        entry({
+          id: "sub-5",
+          state: "failed",
+          snapshot: frame({
+            exitCode: 1,
+            stopReason: "cancelled",
+            elapsedMs: 7_000,
+            errorMessage: "user: wrong direction after review",
+          }),
         }),
-      }),
-    ])!;
+      ],
+      new Set(),
+    )!;
     assert.match(text, /— cancelled — user: wrong direction after review \(ran 7s\) —/);
   });
 
@@ -118,19 +134,52 @@ describe("buildInboxReminder", () => {
       entry({ id: "sub-1", state: "finished", snapshot: frame({ exitCode: 0, elapsedMs: 42_000 }) }),
       entry({ id: "sub-2", state: "running", snapshot: frame({ exitCode: -1, startTime: 123 }) }),
     ];
-    assert.equal(buildInboxReminder(entries), buildInboxReminder(entries));
+    assert.equal(buildInboxReminder(entries, new Set()), buildInboxReminder(entries, new Set()));
   });
 
   test("long task text is truncated to the shared 70-char preview cap", () => {
     const long = "x".repeat(120);
-    const text = buildInboxReminder([entry({ id: "sub-9", state: "running", task: long })])!;
+    const text = buildInboxReminder([entry({ id: "sub-9", state: "running", task: long })], new Set())!;
     assert.ok(text.includes(`"${"x".repeat(70)}..."`));
   });
 
   test("header explains pull-only collection semantics", () => {
-    const text = buildInboxReminder([entry({ id: "sub-1", state: "running" })])!;
+    const text = buildInboxReminder([entry({ id: "sub-1", state: "running" })], new Set())!;
     assert.match(text, /^\[background subagent runs — results are pull-only for the model/);
-    assert.match(text, /already collected\]/);
+    assert.match(text, /already checked on this branch\]/);
+  });
+
+  test("terminal rows in the delivered set drop out of the inbox", () => {
+    const text = buildInboxReminder(
+      [
+        entry({ id: "sub-1", state: "finished", snapshot: frame({ exitCode: 0, elapsedMs: 42_000 }) }),
+        entry({ id: "sub-2", state: "failed", snapshot: frame({ exitCode: 1, elapsedMs: 5_000 }) }),
+      ],
+      new Set(["sub-1"]),
+    )!;
+    assert.doesNotMatch(text, /sub-1/);
+    assert.match(text, /sub-2 \(worker\) — failed/);
+  });
+
+  test("live rows stay listed even when their id is in the delivered set", () => {
+    // A live frame checked mid-run does not count as delivery — the result
+    // was not final yet, so the run keeps nagging until a terminal check.
+    const text = buildInboxReminder(
+      [
+        entry({ id: "sub-1", state: "queued", snapshot: frame({ exitCode: -1, queued: true }) }),
+        entry({ id: "sub-2", state: "running", snapshot: frame({ exitCode: -1, startTime: 99 }) }),
+      ],
+      new Set(["sub-1", "sub-2"]),
+    )!;
+    assert.match(text, /sub-1 \(worker\) — queued/);
+    assert.match(text, /sub-2 \(worker\) — running/);
+  });
+
+  test("all terminal rows delivered returns undefined (zero injection)", () => {
+    const entries = [
+      entry({ id: "sub-1", state: "finished", snapshot: frame({ exitCode: 0, elapsedMs: 42_000 }) }),
+    ];
+    assert.equal(buildInboxReminder(entries, new Set(["sub-1"])), undefined);
   });
 });
 

package/src/reminder.ts

@@ -1,11 +1,13 @@
 /**
- * The model's inbox of unclaimed background subagent runs.
+ * The model's inbox of background subagent runs.
  *
  * Injected into the LLM context before every provider call via the `context`
- * event. The reminder lists every delegated run whose result has not been
- * claimed yet — queued, running, and finished/failed alike — so the model
- * cannot forget about them. `subagent_check` on a terminal run returns the
- * output AND removes the run from this list (read-once collection).
+ * event. The reminder lists every delegated run not yet delivered by a
+ * subagent_check on the active branch — queued, running, and
+ * finished/failed alike — so the model cannot forget about them. Delivery
+ * state is derived from the session tree (see collectDeliveredIds), not
+ * tracked in the registry: branching past a check re-arms the inbox,
+ * branching back silences it, and compaction un-delivers naturally.
  *
  * Cache discipline: the reminder is prepended to the FIRST user message, so
  * it sits at a stable position in the message prefix. Its content must stay
@@ -28,7 +30,7 @@ export interface InboxEntry {
 }
 
 const INBOX_HEADER =
-  "[background subagent runs — results are pull-only for the model: no completion notice wakes you. subagent_wait, then subagent_check to collect each run; a terminal check removes it from this list; runs missing here were already collected]";
+  "[background subagent runs — results are pull-only for the model: no completion notice wakes you. subagent_wait, then subagent_check to collect each run; a terminal check removes it from this list; runs missing here were already checked on this branch]";
 
 /** `42s`, `3m12s`, `4m` — whole seconds, no live clocks. */
 function formatDuration(totalSec: number): string {
@@ -61,12 +63,16 @@ function inboxStatus(entry: InboxEntry): string {
 
 /**
  * Build the inbox reminder text, or undefined when every delegated run has
- * been collected (nothing to remind about — inject nothing, keep the context
- * untouched and the provider cache fully stable).
+ * already been checked on the active branch (nothing to remind about —
+ * inject nothing, keep the context untouched and the provider cache fully
+ * stable). Queued/running runs are always listed regardless of delivery
+ * state — their result is not final yet, so a past check (of a live frame)
+ * never counts as delivered.
  */
-export function buildInboxReminder(entries: Iterable<InboxEntry>): string | undefined {
+export function buildInboxReminder(entries: Iterable<InboxEntry>, delivered: Set<string>): string | undefined {
   const rows: string[] = [];
   for (const entry of entries) {
+    if (entry.state !== "queued" && entry.state !== "running" && delivered.has(entry.id)) continue;
     rows.push(`- ${entry.id} (${entry.role}) — ${inboxStatus(entry)} — "${taskPreview(entry.task)}"`);
   }
   if (rows.length === 0) return undefined;

package/src/render-async.ts

@@ -33,6 +33,7 @@ import type {
   CheckDetails,
   CompletionNoticeDetails,
   RunViewEntry,
+  SteerDetails,
   SubagentResult,
   WaitDetails,
 } from "./types.ts";
@@ -46,6 +47,7 @@ import {
   deriveRunState,
   ensureElapsedTimer,
   formatFallback,
+  formatInheritedConversationInput,
   formatThinking,
   formatTimePart,
   formatToolCall,
@@ -282,10 +284,13 @@ export const renderCompletionNotice: MessageRenderer<CompletionNoticeDetails> =
 
 export const renderBackgroundDelegateCall: RenderCallFn = (args, theme) => {
   const roleName = (args as any).role || "...";
+  const mode = (args as any).inheritConversation
+    ? " (background · inherits conversation)"
+    : " (background)";
   const text =
     theme.fg("toolTitle", theme.bold("subagent_delegate ")) +
     theme.fg("accent", roleName) +
-    theme.fg("dim", " (background)");
+    theme.fg("dim", mode);
   return new Text(text, 0, 0);
 };
 
@@ -301,7 +306,7 @@ export const renderBackgroundDelegateResult: RenderResultFn = (result, { expande
 
   if (!expanded) return collapsedText(summaryLine);
 
-  // Expanded: full input — reference files, context size, task text.
+  // Expanded: full input — reference files, context/inheritance metadata, task text.
   const container = new Container();
   container.addChild(new Text(summaryLine, 0, 0));
   container.addChild(new Spacer(1));
@@ -313,6 +318,21 @@ export const renderBackgroundDelegateResult: RenderResultFn = (result, { expande
   if (details.context) {
     container.addChild(new Text(fg("dim", `ctx ${details.context.length} chars`), 0, 0));
   }
+  if (details.inheritConversation) {
+    container.addChild(
+      new Text(
+        fg(
+          "dim",
+          formatInheritedConversationInput(
+            details.inheritedConversationChars ?? 0,
+            details.inheritedConversationTruncated === true,
+          ),
+        ),
+        0,
+        0,
+      ),
+    );
+  }
   container.addChild(new Text(fg("dim", details.task), 0, 0));
   return container;
 };
@@ -387,6 +407,54 @@ export const renderCheckResult: RenderResultFn = (result, { expanded }, theme, _
   return collapsedText(checkEntryCollapsedText(details.result, fg));
 };
 
+// ── steer: correction echo (check verifies the effect) ──
+
+/**
+ * Factory: the call line shows the run's role, but args carry only id +
+ * message — the registry lookup is injected. Unknown id (e.g. re-rendering a
+ * persisted session where the registry is empty) degrades to the bare id.
+ */
+export function createSteerCallRender(roleOf: (id: string) => string | undefined): RenderCallFn {
+  return (args, theme) => {
+    const id = (args as any).id || "...";
+    const role = roleOf(id);
+    const label = role ? `${id} (${role})` : id;
+    const text = theme.fg("toolTitle", theme.bold("subagent_steer ")) + theme.fg("accent", label);
+    return new Text(text, 0, 0);
+  };
+}
+
+export const renderSteerResult: RenderResultFn = (result, { expanded }, theme) => {
+  const details = result.details as SteerDetails | undefined;
+  if (!details) return collapsedText(contentText(result));
+
+  const fg = theme.fg.bind(theme) as Fg;
+  const icon = fg("accent", "\u21a9"); // ↩ — same marker as steer entries in the activity stream
+  const message = details.message.trim() || "(empty message)";
+
+  // Body carries the correction only — no id/role prefix; the target lives in
+  // the call line and the delivery hint below.
+  if (!expanded) {
+    const firstLine = message.split("\n")[0];
+    return collapsedText(`${icon} ${fg("text", firstLine)}`);
+  }
+
+  const container = new Container();
+  container.addChild(new Text(`${icon} ${fg("text", message)}`, 0, 0));
+  container.addChild(new Spacer(1));
+  container.addChild(
+    new Text(
+      fg(
+        "dim",
+        `${details.id} (${details.role}) — delivered after the current tool batch, verify with subagent_check later`,
+      ),
+      0,
+      0,
+    ),
+  );
+  return container;
+};
+
 // ── cancel: confirmation-only view (check is the result-fetcher) ──
 
 export const renderCancelCall: RenderCallFn = (args, theme) => {

package/src/render.test.ts

@@ -0,0 +1,63 @@
+/** Tests for inherited-conversation TUI observability. */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { renderBackgroundDelegateCall, renderBackgroundDelegateResult } from "./render-async.ts";
+import { renderDelegateCall } from "./render.ts";
+
+const theme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+} as any;
+
+function rendered(component: { render(width: number): string[] }): string {
+  return component
+    .render(200)
+    .map((line) => line.trimEnd())
+    .join("\n");
+}
+
+test("delegate call titles mark inherited conversation without changing isolated mode", () => {
+  const isolated = rendered(renderDelegateCall({ role: "worker" } as any, theme, {} as any));
+  const inherited = rendered(
+    renderDelegateCall({ role: "worker", inheritConversation: true } as any, theme, {} as any),
+  );
+
+  assert.equal(isolated, "subagent_delegate worker");
+  assert.equal(inherited, "subagent_delegate worker (inherits conversation)");
+});
+
+test("background call and expanded input expose only safe inheritance metadata", () => {
+  const call = rendered(
+    renderBackgroundDelegateCall(
+      { role: "worker", background: true, inheritConversation: true } as any,
+      theme,
+      {} as any,
+    ),
+  );
+  assert.equal(call, "subagent_delegate worker (background · inherits conversation)");
+
+  const result = rendered(
+    renderBackgroundDelegateResult(
+      {
+        content: [{ type: "text", text: "started" }],
+        details: {
+          id: "sub-1",
+          role: "worker",
+          task: "Implement the delta",
+          context: "explicit context",
+          inheritConversation: true,
+          inheritedConversationChars: 50_000,
+          inheritedConversationTruncated: true,
+        },
+      } as any,
+      { expanded: true, isPartial: false },
+      theme,
+      {} as any,
+    ),
+  );
+
+  assert.match(result, /ctx 16 chars/);
+  assert.match(result, /conversation 50000 chars · truncated/);
+  assert.ok(!result.includes("inherited_conversation"));
+});

package/src/render.ts

@@ -15,6 +15,7 @@ import {
   contentText,
   ensureElapsedTimer,
   formatFallback,
+  formatInheritedConversationInput,
   formatThinking,
   formatTimePart,
   formatToolCall,
@@ -35,7 +36,13 @@ type RenderResultFn = NonNullable<ToolDefinition["renderResult"]>;
 
 export const renderDelegateCall: RenderCallFn = (args, theme, _context) => {
   const roleName = (args as any).role || "...";
-  const text = theme.fg("toolTitle", theme.bold("subagent_delegate ")) + theme.fg("accent", roleName);
+  const inheritance = (args as any).inheritConversation
+    ? theme.fg("dim", " (inherits conversation)")
+    : "";
+  const text =
+    theme.fg("toolTitle", theme.bold("subagent_delegate ")) +
+    theme.fg("accent", roleName) +
+    inheritance;
   return new Text(text, 0, 0);
 };
 
@@ -104,8 +111,8 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
       container.addChild(new Text(fallbackLine, 0, 0));
     }
 
-    // Input block: reference files + context char count + task full text,
-    // grouped without inner spacing (they are all subagent input).
+    // Input block: reference files + context/inherited-conversation metadata
+    // + task full text, grouped without inner spacing (all subagent input).
     container.addChild(new Spacer(1));
     if (r.files) {
       for (const f of r.files) {
@@ -115,6 +122,21 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
     if (r.context) {
       container.addChild(new Text(theme.fg("dim", `ctx ${r.context.length} chars`), 0, 0));
     }
+    if (r.inheritConversation) {
+      container.addChild(
+        new Text(
+          theme.fg(
+            "dim",
+            formatInheritedConversationInput(
+              r.inheritedConversationChars ?? 0,
+              r.inheritedConversationTruncated === true,
+            ),
+          ),
+          0,
+          0,
+        ),
+      );
+    }
     container.addChild(new Text(theme.fg("dim", r.task), 0, 0));
 
     // Activity stream (shown while running and after completion).