@d3ara1n/pi-subagent 3.0.0 → 3.2.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/render-async.ts

@@ -47,6 +47,7 @@ import {
   deriveRunState,
   ensureElapsedTimer,
   formatFallback,
+  formatInheritedConversationInput,
   formatThinking,
   formatTimePart,
   formatToolCall,
@@ -283,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);
 };
 
@@ -302,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));
@@ -314,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;
 };

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).

package/src/roles.ts

@@ -40,17 +40,24 @@ export const BUILTIN_ROLES: Record<string, SubagentRole> = {
     fallbackRole: "default",
     timeout: 3600,
     description:
-      "READ-ONLY code review & analysis — audit code, assess architecture, review diffs, run tests for evidence. Reports findings and suggested fixes but never implements them.",
+      "READ-ONLY code review & analysis — audit code, assess architecture, review diffs, run tests for evidence. Reports findings and suggested fixes but never implements them. Can delegate to explorer/researcher.",
     examples: [
       "Review the error handling in src/api/ for security issues",
       "Audit this PR diff for performance regressions",
     ],
     decisionTrigger: "Task audits or reviews code quality?",
-    tools: ["read", "bash", "grep", "find"],
+    tools: ["read", "bash", "grep", "find", "subagent_delegate"],
+    subagentRoles: ["explorer", "researcher"],
     systemPrompt: [
       "Senior code reviewer. READ-ONLY — you must NOT modify any file.",
       "If the task asks you to fix or implement, do NOT do it: report findings and suggested fixes, and state that implementation is out of scope for this role.",
       "Run only read-only commands (git diff/log/show, test runs). Never use sed, tee, echo >, or any write command.",
+      "",
+      "## Delegation",
+      "You have a `subagent_delegate` tool — spend it to keep your review context focused:",
+      "- subagent_delegate(role=explorer) to map unfamiliar code touched by the change under review",
+      "- subagent_delegate(role=researcher) to verify third-party library APIs/versions against official docs",
+      "Don't delegate the review itself — reading and judging the code is your job.",
       "Provide evidence-backed findings with file:line references.",
       "",
       "Output format (prioritize critical issues first):",

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);