@akagilnc/pi-workflow-roles 0.1.4528 → 0.1.4620

package/dist/acp-host/production-host.js

@@ -62,7 +62,7 @@ async function spawnEngineDetourOnce(input) {
   }
   const command = input.argv[0];
   const args = input.argv.slice(1);
-  return await new Promise((resolve21, reject) => {
+  return await new Promise((resolve22, reject) => {
     let settled = false;
     const signal = input.signal;
     const child = spawn(command, args, {
@@ -92,7 +92,7 @@ async function spawnEngineDetourOnce(input) {
       if (signal !== void 0) {
         signal.removeEventListener("abort", onAbort);
       }
-      resolve21(result);
+      resolve22(result);
     };
     const onAbort = () => {
       fail4(signal !== void 0 ? abortReasonError(signal) : new Error("aborted"));
@@ -1807,7 +1807,48 @@ var init_collector_output = __esm({
 });
 
 // src/package-contracts/navigator-output.ts
+var navigator_output_exports = {};
+__export(navigator_output_exports, {
+  NAVIGATOR_ACCEPTED_TEXT: () => NAVIGATOR_ACCEPTED_TEXT,
+  NAVIGATOR_OUTPUT_TOOL_NAME: () => NAVIGATOR_OUTPUT_TOOL_NAME,
+  navigatorOutputSchema: () => navigatorOutputSchema,
+  navigatorProseFromUnknown: () => navigatorProseFromUnknown,
+  projectLawfulNavigatorOutput: () => projectLawfulNavigatorOutput,
+  validateRecordedNavigatorOutput: () => validateRecordedNavigatorOutput
+});
 import { Type as Type5 } from "typebox";
+function projectLawfulNavigatorOutput(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return { prose: value };
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const record4 = value;
+    if (typeof record4.prose === "string") return { prose: record4.prose };
+    if (record4.prose !== void 0 && record4.prose !== null) {
+      return { prose: typeof record4.prose === "string" ? record4.prose : String(record4.prose) };
+    }
+    const keys = Object.keys(record4);
+    if (keys.length === 0) return { prose: "" };
+    try {
+      return { prose: JSON.stringify(record4) };
+    } catch {
+      return { prose: String(record4) };
+    }
+  }
+  return { prose: String(value) };
+}
+function validateRecordedNavigatorOutput(value) {
+  const projected = projectLawfulNavigatorOutput(value);
+  if (projected === void 0) {
+    throw new Error("Navigator output is empty");
+  }
+  return projected;
+}
+function navigatorProseFromUnknown(value) {
+  const projected = projectLawfulNavigatorOutput(value);
+  if (projected === void 0) return void 0;
+  const trimmed = projected.prose.trim();
+  return trimmed === "" ? void 0 : projected.prose;
+}
 var NAVIGATOR_OUTPUT_TOOL_NAME, NAVIGATOR_ACCEPTED_TEXT, navigatorOutputSchema;
 var init_navigator_output = __esm({
   "src/package-contracts/navigator-output.ts"() {
@@ -1819,11 +1860,8 @@ var init_navigator_output = __esm({
     navigatorOutputSchema = withTerminatingOutputDeclarations(
       openToolObject(
         Type5.Object({
-          status: Type5.Unknown({
-            description: "advice \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
-          }),
-          candidates: Type5.Unknown({
-            description: "\u6392\u597D\u5E8F\u7684\u8DEF\u7EBF\u5EFA\u8BAE\u6570\u7EC4\uFF0C\u5143\u7D20\u542B next/phase/reason \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
+          prose: Type5.Unknown({
+            description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7B49\u7ED3\u6784\u5316\u5B57\u6BB5\u3002\u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8"
           })
         })
       )
@@ -4754,7 +4792,7 @@ function normalizeReviewComment(raw) {
 function createGhApiRunner(options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn3;
   return async (args, runOptions = {}) => {
-    return await new Promise((resolve21, reject) => {
+    return await new Promise((resolve22, reject) => {
       const signal = runOptions.signal;
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
@@ -4827,11 +4865,11 @@ function createGhApiRunner(options = {}) {
               const value = line2.slice(idx + 1).trim();
               headers[name] = value;
             }
-            resolve21({ status, headers, bodyText });
+            resolve22({ status, headers, bodyText });
             return;
           }
           if (code === 0) {
-            resolve21({ status: 200, headers: {}, bodyText: stdout });
+            resolve22({ status: 200, headers: {}, bodyText: stdout });
             return;
           }
           const failure2 = new Error(
@@ -5420,6 +5458,56 @@ var init_typed_provider_http = __esm({
 });
 
 // src/public-cli/run-lifecycle.ts
+var run_lifecycle_exports = {};
+__export(run_lifecycle_exports, {
+  AUTO_RESUME_LIMIT: () => AUTO_RESUME_LIMIT,
+  GATE_DOSSIER_POINTER_PREFIX: () => GATE_DOSSIER_POINTER_PREFIX,
+  RESUME_TRANSPORT_ENVELOPE: () => RESUME_TRANSPORT_ENVELOPE,
+  RunWriterLeaseHeldError: () => RunWriterLeaseHeldError,
+  V1_RESUMABLE_PROVIDERS: () => V1_RESUMABLE_PROVIDERS,
+  acquireRunWriterLease: () => acquireRunWriterLease,
+  autopsyWriterLock: () => autopsyWriterLock,
+  buildAutoResumeContinuationPrompt: () => buildAutoResumeContinuationPrompt,
+  buildResumeContinuationPrompt: () => buildResumeContinuationPrompt,
+  clearCurrentCourt: () => clearCurrentCourt,
+  clearTypedProviderHttpObservation: () => clearTypedProviderHttpObservation,
+  describeErrorIdentity: () => describeErrorIdentity,
+  findLatestRunIdForSeatTicket: () => findLatestRunIdForSeatTicket,
+  findRunDirectoryById: () => findRunDirectoryById,
+  isDurablePrincipalAvailable: () => isDurablePrincipalAvailable,
+  isV1ResumableProvider: () => isV1ResumableProvider,
+  loadResumableCoderRun: () => loadResumableCoderRun,
+  loadResumableCollectorRun: () => loadResumableCollectorRun,
+  loadResumableCountersignRun: () => loadResumableCountersignRun,
+  loadResumableDiaristRun: () => loadResumableDiaristRun,
+  loadResumableDoctorRun: () => loadResumableDoctorRun,
+  loadResumableFixerRun: () => loadResumableFixerRun,
+  loadResumableGleanerLeftRun: () => loadResumableGleanerLeftRun,
+  loadResumableInspectorRun: () => loadResumableInspectorRun,
+  loadResumableInstructionSeatRun: () => loadResumableInstructionSeatRun,
+  loadResumableJudgeRun: () => loadResumableJudgeRun,
+  loadResumableMergerRun: () => loadResumableMergerRun,
+  loadResumableNotaryRun: () => loadResumableNotaryRun,
+  loadResumableReviewerRun: () => loadResumableReviewerRun,
+  loadResumableSecretariatRun: () => loadResumableSecretariatRun,
+  markRunAdmitted: () => markRunAdmitted,
+  markRunResumable: () => markRunResumable,
+  markRunRunning: () => markRunRunning,
+  markRunTerminal: () => markRunTerminal,
+  parentRunPathFromGatePointerInstruction: () => parentRunPathFromGatePointerInstruction,
+  peekRoleRunRole: () => peekRoleRunRole,
+  readCurrentCourt: () => readCurrentCourt,
+  readLatestTypedProviderHttpObservation: () => readLatestTypedProviderHttpObservation,
+  readRoleRunIdentity: () => readRoleRunIdentity,
+  readRoleRunState: () => readRoleRunState,
+  readRunParentPath: () => readRunParentPath,
+  readTypedHttp429Observation: () => readTypedHttp429Observation,
+  recordCurrentCourt: () => recordCurrentCourt,
+  recordTypedProviderHttpStatus: () => recordTypedProviderHttpStatus,
+  renderResumeCommand: () => renderResumeCommand,
+  selectResumeContinuationPrompt: () => selectResumeContinuationPrompt,
+  writeRoleRunState: () => writeRoleRunState
+});
 import { chmod, lstat as lstat2, open, readdir as readdir4, readFile as readFile9, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
 import { basename as basename4, join as join15 } from "node:path";
 function selectResumeContinuationPrompt(message, engineMaterial) {
@@ -5435,6 +5523,15 @@ function buildResumeContinuationPrompt(options) {
     })
   );
 }
+function buildAutoResumeContinuationPrompt(options) {
+  return selectResumeContinuationPrompt(
+    RESUME_TRANSPORT_ENVELOPE,
+    engineSessionMaterialFromOptions({
+      packageRoot: options.packageRoot,
+      ...pickEngineAxis(options)
+    })
+  );
+}
 function isV1ResumableProvider(provider) {
   return V1_RESUMABLE_PROVIDERS.includes(provider);
 }
@@ -5598,6 +5695,11 @@ function materializeRoleRunFromDisk(disk, authority) {
     return void 0;
   }
 }
+async function readRoleRunState(runDirectory, authority) {
+  const disk = await readRoleRunStateDisk(runDirectory);
+  if (disk === void 0) return void 0;
+  return materializeRoleRunFromDisk(disk, authority)?.run;
+}
 async function readRoleRunIdentity(runDirectory) {
   const disk = await readRoleRunStateDisk(runDirectory);
   if (disk === void 0) return void 0;
@@ -6331,6 +6433,117 @@ async function loadResumableJudgeRun(home, runId, authority) {
   };
   return seatLoadedResult(loaded, admitted);
 }
+async function loadResumableCoderRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "coder") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not coder`
+    );
+  }
+  const phase = loaded.admittedFields.phase ?? loaded.run.phase;
+  if (phase !== "plan" && phase !== "apply") {
+    throw new CliUsageError(
+      `role run admitted coder phase is missing: ${runId}`
+    );
+  }
+  const taskPath = loaded.admittedFields.taskPath;
+  if (taskPath === void 0) {
+    throw new CliUsageError(
+      `role run admitted coder task path is missing: ${runId}`
+    );
+  }
+  if (loaded.admittedFields.instruction.trim() === "") {
+    throw new CliUsageError(
+      `role run admitted coder task is blank: ${runId}`
+    );
+  }
+  const admitted = {
+    role: "coder",
+    phase,
+    ...resumedBaseAdmitted(loaded),
+    instructionEmpty: false,
+    taskPath
+  };
+  return seatLoadedResult(loaded, admitted);
+}
+async function loadResumableFixerRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "fixer") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not fixer`
+    );
+  }
+  const phase = loaded.admittedFields.phase ?? loaded.run.phase;
+  if (phase !== "plan" && phase !== "apply") {
+    throw new CliUsageError(
+      `role run admitted fixer phase is missing: ${runId}`
+    );
+  }
+  const packetPath = loaded.admittedFields.packetPath;
+  if (packetPath === void 0) {
+    throw new CliUsageError(
+      `role run admitted fixer packet path is missing: ${runId}`
+    );
+  }
+  if (loaded.admittedFields.instruction.trim() === "") {
+    throw new CliUsageError(
+      `role run admitted fixer instruction is blank: ${runId}`
+    );
+  }
+  const prerequisites = loaded.admittedFields.prerequisites ?? Object.freeze([]);
+  const admitted = {
+    role: "fixer",
+    phase,
+    ...resumedBaseAdmitted(loaded),
+    instructionEmpty: false,
+    packetPath,
+    ...loaded.admittedFields.prerequisitesPath === void 0 ? {} : { prerequisitesPath: loaded.admittedFields.prerequisitesPath },
+    prerequisites
+  };
+  return seatLoadedResult(loaded, admitted);
+}
+async function loadResumableReviewerRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "reviewer") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not reviewer`
+    );
+  }
+  const rawBase = loaded.admittedFields.baseRevision;
+  if (rawBase === void 0 || rawBase.trim() === "") {
+    throw new CliUsageError(
+      `role run admitted reviewer base revision is missing: ${runId}`
+    );
+  }
+  if (/\s/.test(rawBase) || rawBase.startsWith("-")) {
+    throw new CliUsageError(
+      `role run admitted reviewer base revision is damaged: ${runId}`
+    );
+  }
+  const baseRevision = rawBase;
+  const lens = loaded.admittedFields.lens;
+  if (!isReviewerLens(lens)) {
+    throw new CliUsageError(
+      `role run admitted reviewer lens is missing: ${runId}`
+    );
+  }
+  const authorityRefs = Object.freeze([
+    ...loaded.admittedFields.authorityRefs ?? []
+  ]);
+  if (authorityRefs.length === 0) {
+    throw new CliUsageError(
+      `role run admitted reviewer authority refs are missing: ${runId}`
+    );
+  }
+  const admitted = {
+    role: "reviewer",
+    ...resumedBaseAdmitted(loaded),
+    baseRevision,
+    lens,
+    authorityRefs
+  };
+  return seatLoadedResult(loaded, admitted);
+}
 async function loadResumableCountersignRun(home, runId, authority) {
   const loaded = await loadResumableRunRecord(home, runId, authority);
   if (loaded.run.role !== "countersign") {
@@ -6362,6 +6575,26 @@ async function loadResumableInstructionSeatRun(home, runId, authority) {
   };
   return seatLoadedResult(loaded, admitted);
 }
+async function loadResumableGleanerLeftRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "gleaner-left") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not gleaner-left`
+    );
+  }
+  const baseRevision = loaded.admittedFields.baseRevision;
+  if (baseRevision === void 0 || baseRevision.trim() === "") {
+    throw new CliUsageError(
+      `role run admitted gleaner-left base revision is missing: ${runId}`
+    );
+  }
+  const admitted = {
+    role: "gleaner-left",
+    ...resumedBaseAdmitted(loaded),
+    baseRevision
+  };
+  return seatLoadedResult(loaded, admitted);
+}
 async function loadResumableDiaristRun(home, runId, authority) {
   const loaded = await loadResumableRunRecord(home, runId, authority);
   if (loaded.run.role !== "diarist") {
@@ -6375,6 +6608,88 @@ async function loadResumableDiaristRun(home, runId, authority) {
   };
   return seatLoadedResult(loaded, admitted);
 }
+async function loadResumableSecretariatRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "secretariat") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not secretariat`
+    );
+  }
+  const admitted = {
+    role: "secretariat",
+    ...resumedBaseAdmitted(loaded)
+  };
+  return seatLoadedResult(loaded, admitted);
+}
+async function loadResumableMergerRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "merger") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not merger`
+    );
+  }
+  const mergerInputPath = loaded.admittedFields.mergerInputPath;
+  if (mergerInputPath === void 0) {
+    throw new CliUsageError(
+      `role run admitted merger input path is missing: ${runId}`
+    );
+  }
+  const derived = loaded.admittedFields.derived;
+  if (derived === void 0) {
+    throw new CliUsageError(
+      `role run admitted merger envelope is missing: ${runId}`
+    );
+  }
+  if (loaded.admittedFields.instruction.trim() === "") {
+    throw new CliUsageError(
+      `role run admitted merger task is blank: ${runId}`
+    );
+  }
+  const admitted = {
+    role: "merger",
+    ...resumedBaseAdmitted(loaded),
+    instructionEmpty: false,
+    mergerInputPath,
+    derived
+  };
+  return seatLoadedResult(loaded, admitted);
+}
+async function loadResumableCollectorRun(home, runId, authority) {
+  const loaded = await loadResumableRunRecord(home, runId, authority);
+  if (loaded.run.role !== "collector") {
+    throw new CliUsageError(
+      `role run ${runId} belongs to ${loaded.run.role}, not collector`
+    );
+  }
+  const { prNumber, repository, repositoryDisplay, manifestDigest } = loaded.admittedFields;
+  if (repository === void 0 || repositoryDisplay === void 0 || manifestDigest === void 0) {
+    throw new CliUsageError(
+      `role run admitted collector repository identity is missing: ${runId}`
+    );
+  }
+  let parsedRepository;
+  try {
+    parsedRepository = parseCollectorRepository(repositoryDisplay);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CliUsageError(detail, { cause: error });
+  }
+  if (parsedRepository.canonical !== repository) {
+    throw new CliUsageError(
+      `role run admitted collector repository does not match its canonical form: ${runId}`
+    );
+  }
+  const admitted = {
+    role: "collector",
+    ...resumedBaseAdmitted(loaded),
+    ...prNumber === void 0 ? {} : { prNumber },
+    repository: parsedRepository,
+    ...loaded.admittedFields.requestManifestPath === void 0 ? {} : { requestManifestPath: loaded.admittedFields.requestManifestPath },
+    ...loaded.admittedFields.waitWindowMs === void 0 ? {} : { waitWindowMs: loaded.admittedFields.waitWindowMs },
+    manifestDigest
+  };
+  return seatLoadedResult(loaded, admitted);
+}
 async function loadResumableDoctorRun(home, runId, authority) {
   const loaded = await loadResumableRunRecord(home, runId, authority);
   if (loaded.run.role !== "doctor") {
@@ -6432,6 +6747,12 @@ async function loadResumableInspectorRun(home, runId, authority) {
   };
   return seatLoadedResult(loaded, admitted);
 }
+async function peekRoleRunRole(home, runId) {
+  const runDirectory = await findRunDirectoryById(home, runId);
+  if (runDirectory === void 0) return void 0;
+  const run = await readRoleRunIdentity(runDirectory);
+  return run?.role;
+}
 var V1_RESUMABLE_PROVIDERS, AUTO_RESUME_LIMIT, RESUME_TRANSPORT_ENVELOPE, RUN_STATE_FILE, WRITER_LOCK_FILE, RunWriterLeaseHeldError, WRITER_LEASE_RECLAIM_ROUNDS, GATE_DOSSIER_POINTER_PREFIX;
 var init_run_lifecycle = __esm({
   "src/public-cli/run-lifecycle.ts"() {
@@ -6448,7 +6769,7 @@ var init_run_lifecycle = __esm({
     init_invocation();
     V1_RESUMABLE_PROVIDERS = ["openai-codex", "xai"];
     AUTO_RESUME_LIMIT = 2;
-    RESUME_TRANSPORT_ENVELOPE = "[ak-role:resume-continue]";
+    RESUME_TRANSPORT_ENVELOPE = "\u7EE7\u7EED\u3002";
     RUN_STATE_FILE = "run-state.json";
     WRITER_LOCK_FILE = "writer.lock";
     RunWriterLeaseHeldError = class extends Error {
@@ -7088,12 +7409,12 @@ var init_option_definitions = __esm({
         canonical: "--lens",
         aliases: [],
         valueMetavar: "completeness|correctness",
-        required: true,
+        required: false,
         repeatable: false,
         form: "option",
         description: {
-          en: "Required single review lens: completeness or correctness (no default).",
-          zh: "\u5FC5\u586B\u5355 lens\uFF1Acompleteness \u6216 correctness\uFF08\u65E0\u9ED8\u8BA4\u503C\uFF09\u3002"
+          en: "Optional single-lens override: completeness or correctness; omitted runs both in parallel.",
+          zh: "\u53EF\u9009\u5355 lens \u8986\u76D6\uFF1Acompleteness \u6216 correctness\uFF1B\u7701\u7565\u65F6\u5E76\u884C\u8FD0\u884C\u4E24\u8F74\u3002"
         }
       },
       {
@@ -7450,9 +7771,9 @@ var init_option_definitions = __esm({
       },
       reviewer: {
         command: "reviewer",
-        summary: "Fixed-target single-lens review (completeness or correctness).",
+        summary: "Fixed-target parallel two-lens review, with an optional single-lens override.",
         usage: [
-          "ak-role reviewer --base <revision> --lens completeness|correctness --authority-ref <ref> [options] <instruction>"
+          "ak-role reviewer --base <revision> [--lens completeness|correctness] --authority-ref <ref> [options] <instruction>"
         ],
         examples: [
           'ak-role reviewer --base main --lens completeness --authority-ref docs/adr/0001.md "Review the branch."',
@@ -7503,7 +7824,7 @@ var init_option_definitions = __esm({
       },
       navigator: {
         command: "navigator",
-        summary: "Direct Navigator (\u6E38\u5955\u4F7F) route advice: ordered next-role candidates.",
+        summary: "Direct Navigator (\u6E38\u5955\u4F7F) free-form prose route advice.",
         usage: ["ak-role navigator [options] [instruction]"],
         examples: [
           'ak-role navigator "\u521A\u5B8C\u6210 coder apply \u6536\u655B\uFF0C\u4E0B\u4E00\u6B65\uFF1F"'
@@ -9585,7 +9906,7 @@ function parseReviewerArgv(args) {
     instruction: positional.join(" "),
     attachmentPaths,
     baseRevision,
-    lens,
+    ...lens === void 0 ? {} : { lens },
     authorityRefs,
     ...project === void 0 ? {} : { project }
   };
@@ -9634,6 +9955,7 @@ async function admitReviewerInvocation(options) {
     baseRevision,
     lens,
     authorityRefs: [...authorityRefs],
+    ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId },
     attachments: attachments.map((a) => ({
       provenancePath: a.provenancePath,
       frozenPath: a.frozenPath,
@@ -9661,7 +9983,8 @@ async function admitReviewerInvocation(options) {
     admittedRequestPath,
     baseRevision,
     lens,
-    authorityRefs
+    authorityRefs,
+    ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId }
   };
 }
 function buildReviewerSkillArgProjection(admitted) {
@@ -9878,11 +10201,11 @@ function parseAnalystCohortIssueToken(raw, flag) {
       `${flag} requires a comma-separated list of N or book:N`
     );
   }
-  const sep6 = trimmed.lastIndexOf(":");
-  if (sep6 > 0) {
-    const rhs = trimmed.slice(sep6 + 1);
+  const sep7 = trimmed.lastIndexOf(":");
+  if (sep7 > 0) {
+    const rhs = trimmed.slice(sep7 + 1);
     if (ANALYST_TICKET_NUMBER_PATTERN.test(rhs)) {
-      const bookKey = trimmed.slice(0, sep6);
+      const bookKey = trimmed.slice(0, sep7);
       if (bookKey.trim() === "") {
         throw new CliUsageError(
           `${flag} book:N requires a non-empty book key, got ${raw}`
@@ -11791,31 +12114,58 @@ async function restoreState(cwd, runId, scope) {
     }, 0)
   };
 }
+function sessionParentFromHostContext(context) {
+  const runDirectory = runDirectoryFromHostContext(context);
+  if (runDirectory !== void 0) return join24(runDirectory, "session", "session.jsonl");
+  const sessionFile = context.sessionManager.getSessionFile?.();
+  if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
+  const sessionDir = context.sessionManager.getSessionDir?.();
+  if (typeof sessionDir === "string" && sessionDir.length > 0) {
+    return join24(sessionDir, "session.jsonl");
+  }
+  return void 0;
+}
+function homeFromHostContext(context, home) {
+  if (home !== void 0) return home;
+  const sessionParent = sessionParentFromHostContext(context);
+  return sessionParent !== void 0 ? tryHomeFromAkRolesPath(sessionParent) : void 0;
+}
+async function sealAcceptedSubmission(options) {
+  const runId = runIdentity(options.context);
+  const attemptId = attemptIdentity(options.context, runId);
+  const sessionParent = sessionParentFromHostContext(options.context);
+  const home = homeFromHostContext(options.context, options.home);
+  const state = await restoreState(options.context.cwd, runId, {
+    ...home === void 0 ? {} : { home },
+    ...sessionParent === void 0 ? {} : { sessionParent }
+  });
+  const pointer = sitianReport({
+    level: "event",
+    kind: "sealed",
+    subject: { runId, attemptId },
+    ...state.prior === void 0 ? {} : { priorEventId: state.prior.identity },
+    payload: {
+      type: "sealed",
+      attemptId,
+      toolCallId: options.toolCallId,
+      role: options.role,
+      accepted: options.accepted
+    },
+    source: "role-runtime",
+    cwd: options.context.cwd,
+    ...home !== void 0 ? { home } : {},
+    ...sessionParent === void 0 ? {} : { sessionParent }
+  });
+  state.prior = pointer;
+}
 function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (error) => {
   throw error;
 }, projectClosure = () => void 0, options) {
   const states = /* @__PURE__ */ new Map();
-  const sessionParentFromContext = (context) => {
-    const runDirectory = runDirectoryFromHostContext(context);
-    if (runDirectory !== void 0) {
-      return join24(runDirectory, "session", "session.jsonl");
-    }
-    const sessionFile = context.sessionManager.getSessionFile?.();
-    if (typeof sessionFile === "string" && sessionFile.length > 0) return sessionFile;
-    const sessionDir = context.sessionManager.getSessionDir?.();
-    if (typeof sessionDir === "string" && sessionDir.length > 0) {
-      return join24(sessionDir, "session.jsonl");
-    }
-    return void 0;
-  };
-  const resolveHomeFromContext = (context) => {
-    if (options?.home !== void 0) return options.home;
-    const sessionParent = sessionParentFromContext(context);
-    return sessionParent !== void 0 ? tryHomeFromAkRolesPath(sessionParent) : void 0;
-  };
+  const resolveHomeFromContext = (context) => homeFromHostContext(context, options?.home);
   const stateFor = (context, runId) => states.get(runId) ?? (() => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pending = restoreState(context.cwd, runId, {
       ...home === void 0 ? {} : { home },
       ...sessionParent === void 0 ? {} : { sessionParent }
@@ -11825,7 +12175,7 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
   })();
   const appendFor = (state, context, runId, attemptId, event) => {
     const home = resolveHomeFromContext(context);
-    const sessionParent = sessionParentFromContext(context);
+    const sessionParent = sessionParentFromHostContext(context);
     const pointer = sitianReport({
       level: "event",
       kind: event.type,
@@ -12268,12 +12618,12 @@ function createSystemCollectorClock() {
   return {
     wallNow: () => /* @__PURE__ */ new Date(),
     monoNow: () => Number(process.hrtime.bigint() - start) / 1e6,
-    sleep: (ms, signal) => new Promise((resolve21, reject) => {
+    sleep: (ms, signal) => new Promise((resolve22, reject) => {
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
         return;
       }
-      const timer = setTimeout(resolve21, ms);
+      const timer = setTimeout(resolve22, ms);
       const onAbort = () => {
         clearTimeout(timer);
         reject(signal?.reason ?? new Error("aborted"));
@@ -14153,44 +14503,6 @@ var init_receipt_delivery_policy = __esm({
   }
 });
 
-// src/public-command-renderer.ts
-function isPublicCallableRole2(role) {
-  return PUBLIC_CALLABLE_ROLES3.has(role);
-}
-function renderPublicAkRoleCommand(target) {
-  if (!isPublicCallableRole2(target.role)) return void 0;
-  const role = target.role;
-  const metadata = packagedRoleMetadata(role);
-  if (metadata !== void 0 && "bareCommand" in metadata && metadata.bareCommand === false) {
-    return void 0;
-  }
-  if (target.phase === null || target.phase === void 0) {
-    return `ak-role ${role}`;
-  }
-  if (role === "coder" || role === "fixer") {
-    return `ak-role ${role} ${target.phase}`;
-  }
-  return `ak-role ${role}`;
-}
-var PUBLIC_CALLABLE_ROLES3;
-var init_public_command_renderer = __esm({
-  "src/public-command-renderer.ts"() {
-    "use strict";
-    init_packaged_role_registry();
-    PUBLIC_CALLABLE_ROLES3 = new Set(
-      PACKAGED_ROLE_REGISTRY.map((entry) => entry.role)
-    );
-  }
-});
-
-// src/public-cli/command-renderer.ts
-var init_command_renderer = __esm({
-  "src/public-cli/command-renderer.ts"() {
-    "use strict";
-    init_public_command_renderer();
-  }
-});
-
 // src/public-cli/terminal.ts
 function encodeTerminalField(value) {
   return JSON.stringify(value);
@@ -14201,14 +14513,10 @@ function isLawfulTypedTerminalOutcome(outcome) {
 function exitCodeForTerminalOutcome(outcome) {
   return isLawfulTypedTerminalOutcome(outcome) ? 0 : 1;
 }
-function recommendationNavigatorFact(input) {
-  const command = typeof input.modelCommand === "string" && input.modelCommand.trim() !== "" ? input.modelCommand : isPublicCallableRole2(input.next.role) ? renderPublicAkRoleCommand(input.next) : void 0;
+function adviceNavigatorFact(input) {
   return {
-    disposition: "recommendation",
-    next: input.next,
-    reason: input.reason,
-    ...command === void 0 ? {} : { command },
-    ...input.route === void 0 ? {} : { route: input.route },
+    disposition: "advice",
+    prose: input.prose,
     ...input.advisoryDiagnostic === void 0 ? {} : { advisoryDiagnostic: input.advisoryDiagnostic }
   };
 }
@@ -14236,14 +14544,8 @@ function formatTerminalResult(result) {
   if (result.navigator.advisoryDiagnostic !== void 0) {
     lines.push(`navigator-advisory	${encodeTerminalField(result.navigator.advisoryDiagnostic)}`);
   }
-  if (result.navigator.disposition === "recommendation") {
-    lines.push(
-      `next	${result.navigator.next.role}	${result.navigator.next.phase ?? "none"}`
-    );
-    lines.push(`reason	${encodeTerminalField(result.navigator.reason)}`);
-    if (result.navigator.command !== void 0) {
-      lines.push(`command	${encodeTerminalField(result.navigator.command)}`);
-    }
+  if (result.navigator.disposition === "advice") {
+    lines.push(`prose	${encodeTerminalField(result.navigator.prose)}`);
   } else if (result.navigator.disposition === "unavailable") {
     lines.push(
       `unavailable	${result.navigator.source}	${encodeTerminalField(result.navigator.reason)}`
@@ -14263,6 +14565,15 @@ function formatTerminalResult(result) {
       );
     }
   }
+  if (result.reviewerChildOutcomes !== void 0) {
+    for (const axis of ["completeness", "correctness"]) {
+      const child = result.reviewerChildOutcomes[axis];
+      lines.push(`reviewer-child	${axis}	${child.exitCode}`);
+      if (child.stderr !== void 0 && child.stderr !== "") {
+        lines.push(`reviewer-child-diagnostic	${axis}	${encodeTerminalField(child.stderr)}`);
+      }
+    }
+  }
   if (result.resume !== void 0) {
     lines.push(`resume	${encodeTerminalField(result.resume.command)}`);
   } else if (result.runId !== void 0) {
@@ -14283,7 +14594,6 @@ function formatTerminalResult(result) {
 var init_terminal = __esm({
   "src/public-cli/terminal.ts"() {
     "use strict";
-    init_command_renderer();
   }
 });
 
@@ -15263,10 +15573,6 @@ async function appendRunAttemptHistory(source, outcome) {
   } catch {
   }
 }
-function navigatorPhaseValue(value) {
-  if (value === "plan" || value === "apply") return value;
-  return null;
-}
 function navigatorAttendanceCorrelatedWithBoundMarker(details, attendanceIndex, terminalIndex, marker) {
   if (attendanceIndex <= terminalIndex) return false;
   if (details.invocationId !== marker.invocationId) return false;
@@ -15275,29 +15581,33 @@ function navigatorAttendanceCorrelatedWithBoundMarker(details, attendanceIndex,
 function parseNavigatorAttendanceDetails(details) {
   const disposition = details.disposition;
   const advisoryDiagnostic = typeof details.routePlaybookReadFailure === "string" ? { advisoryDiagnostic: details.routePlaybookReadFailure } : {};
-  if (disposition === "recommendation") {
-    const next = details.next;
-    if (!isRecord11(next) || typeof next.role !== "string") {
+  if (disposition === "advice" || disposition === "recommendation") {
+    let prose;
+    if (typeof details.prose === "string" && details.prose.trim() !== "") {
+      prose = details.prose;
+    } else {
+      const next = isRecord11(details.next) && typeof details.next.role === "string" ? details.next.role : void 0;
+      const reason = typeof details.reason === "string" && details.reason.trim() !== "" ? details.reason : void 0;
+      const command = typeof details.command === "string" && details.command.trim() !== "" ? details.command : void 0;
+      if (reason !== void 0 && next !== void 0) {
+        prose = `${reason}\uFF08\u4E0B\u4E00\u6B65\uFF1A${next}\uFF09`;
+      } else if (reason !== void 0) {
+        prose = reason;
+      } else if (next !== void 0) {
+        prose = `\u4E0B\u4E00\u6B65\uFF1A${next}`;
+      } else if (command !== void 0) {
+        prose = command;
+      }
+    }
+    if (prose === void 0 || prose.trim() === "") {
       return {
-        disposition: "unavailable",
-        source: "unknown",
-        reason: "navigator recommendation missing typed next role"
+        disposition: "no-advice",
+        ...advisoryDiagnostic
       };
     }
-    const reason = typeof details.reason === "string" ? details.reason : "";
-    const route = Array.isArray(details.route) ? details.route.filter(isRecord11).map((target) => ({
-      role: String(target.role),
-      phase: navigatorPhaseValue(target.phase)
-    })) : void 0;
-    return recommendationNavigatorFact({
-      ...advisoryDiagnostic,
-      next: {
-        role: next.role,
-        phase: navigatorPhaseValue(next.phase)
-      },
-      reason,
-      ...route === void 0 ? {} : { route },
-      ...typeof details.command === "string" ? { modelCommand: details.command } : {}
+    return adviceNavigatorFact({
+      prose,
+      ...advisoryDiagnostic
     });
   }
   if (disposition === "unavailable") {
@@ -16723,10 +17033,10 @@ function presentFailureTerminal(terminal, io) {
 }
 function defaultNavigatorGraceSleep() {
   let timer;
-  const sleep = ((ms) => new Promise((resolve21) => {
+  const sleep = ((ms) => new Promise((resolve22) => {
     timer = setTimeout(() => {
       timer = void 0;
-      resolve21();
+      resolve22();
     }, ms);
   }));
   sleep.cancel = () => {
@@ -16738,7 +17048,7 @@ function defaultNavigatorGraceSleep() {
   return sleep;
 }
 function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep = defaultNavigatorGraceSleep()) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let settled = false;
     const finish = (action) => {
       if (settled) return;
@@ -16747,11 +17057,11 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep
       action();
     };
     void work.then(
-      (value) => finish(() => resolve21({ status: "done", value })),
+      (value) => finish(() => resolve22({ status: "done", value })),
       (error) => finish(() => reject(error))
     );
     void sleep(graceMs).then(() => {
-      finish(() => resolve21({ status: "timeout" }));
+      finish(() => resolve22({ status: "timeout" }));
     });
   });
 }
@@ -18202,6 +18512,30 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
     }
   }
 }
+async function resolveResumeMethodMaterialAdapters(input) {
+  if (input.shouldLoad === false) {
+    return { kind: "continue", adapters: input.emptyAdapters };
+  }
+  try {
+    const material = await input.loadMaterial();
+    return { kind: "continue", adapters: input.adaptersWith(material) };
+  } catch (error) {
+    const terminal = await presentControlledFailure2(
+      input.admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error,
+        ...input.knownCause === void 0 ? {} : { knownCause: input.knownCause }
+      },
+      input.emptyAdapters,
+      input.authority,
+      input.io
+    );
+    return { kind: "terminal", ...terminal };
+  }
+}
 async function presentControlledFailure2(admitted, failureInput, adapters, authority, io, persistRunState = true) {
   const hasThrown = Object.hasOwn(failureInput, "thrown");
   const resumeObservation = await resolveControlledFailureResumeObservation({
@@ -18752,6 +19086,8 @@ async function runPostAdmissionSeatResume(input) {
     }
     adapters = prepared.adapters;
   }
+  let env = input.env;
+  let preparedCleanup;
   const buildRequestAfterLease = async () => {
     let openCourtAttemptId;
     let admittedForBuild = loaded.admitted;
@@ -18802,7 +19138,12 @@ async function runPostAdmissionSeatResume(input) {
     return turnRequest;
   };
   try {
-    if (input.env.stationChild === true) {
+    if (input.afterAdmittedPrepare !== void 0) {
+      const prepared = await input.afterAdmittedPrepare(loaded.admitted);
+      if (prepared.env !== void 0) env = prepared.env;
+      preparedCleanup = prepared.cleanup;
+    }
+    if (env.stationChild === true) {
       let firstTurn;
       const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
       const invocationScopeId = mintEngineDetourInvocationScope({
@@ -18810,14 +19151,14 @@ async function runPostAdmissionSeatResume(input) {
       });
       return await runWithAutoResumeLoop({
         admitted: loaded.admitted,
-        principalAuthority: input.env.principalAuthority,
+        principalAuthority: env.principalAuthority,
         isPrincipalAvailable: resolveHostAwareSessionAvailability(
-          input.env.host,
-          input.env.principalAuthority
+          env.host,
+          env.principalAuthority
         ),
         io: input.io,
-        sessionAppender: input.env.sessionAppender,
-        autoResumeLimit: input.env.autoResumeLimit,
+        sessionAppender: env.sessionAppender,
+        autoResumeLimit: env.autoResumeLimit,
         buildInitialPayload: () => ({ resumeTurn: false }),
         buildResumePayload: () => ({ resumeTurn: true }),
         // Same as public manual resume: prior-court sealed acceptance is not a
@@ -18844,7 +19185,7 @@ async function runPostAdmissionSeatResume(input) {
           dispatch: async (turnRequest) => {
             const result = await dispatchPostAdmissionTurn({
               admitted: loaded.admitted,
-              env: input.env,
+              env,
               io: attemptIo,
               request: turnRequest,
               lease,
@@ -18854,7 +19195,7 @@ async function runPostAdmissionSeatResume(input) {
             });
             return settleDeferredPersist(
               loaded.admitted,
-              input.env.principalAuthority,
+              env.principalAuthority,
               stationAdapters,
               attemptIo,
               result
@@ -18865,7 +19206,7 @@ async function runPostAdmissionSeatResume(input) {
     }
     return await runPostAdmissionManualResume({
       admitted: loaded.admitted,
-      env: input.env,
+      env,
       io: input.io,
       adapters,
       ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine },
@@ -18877,6 +19218,10 @@ async function runPostAdmissionSeatResume(input) {
       return { exitCode: 2 };
     }
     throw error;
+  } finally {
+    if (preparedCleanup !== void 0) {
+      await preparedCleanup();
+    }
   }
 }
 async function runPostAdmissionOneShot(input) {
@@ -18889,7 +19234,7 @@ async function runPostAdmissionOneShot(input) {
       ...input.request,
       continuation: {
         kind: "resume",
-        prompt: buildResumeContinuationPrompt({
+        prompt: buildAutoResumeContinuationPrompt({
           packageRoot: input.env.packageRoot,
           ...pickEngineAxis({
             engine: input.effectiveEngine ?? input.env.engine,
@@ -19038,7 +19383,7 @@ var init_post_admission = __esm({
 
 // src/public-cli/turn-request.ts
 function projectRoleTurnRequest(admitted, roleDetails, options) {
-  const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
+  const cwd = options.cwd ?? admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
   if (cwd === void 0) throw new Error("admitted invocation missing working directory");
   if (admitted.principal === void 0) throw new Error("admitted invocation missing principal");
   return {
@@ -19761,7 +20106,7 @@ async function runPublicJudge(argv, env, io, parseJudgeArgv2) {
       ...admitted.correlationId === void 0 && env.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? env.correlationId },
       continuation: {
         kind: "resume",
-        prompt: buildResumeContinuationPrompt({
+        prompt: buildAutoResumeContinuationPrompt({
           packageRoot: env.packageRoot,
           ...pickEngineAxis(env)
         })
@@ -20542,32 +20887,362 @@ var init_countersign_run = __esm({
   }
 });
 
-// src/public-role-summons.ts
-var public_role_summons_exports = {};
-__export(public_role_summons_exports, {
-  AK_ROLE_PACKAGE_ROOT_ENV: () => AK_ROLE_PACKAGE_ROOT_ENV,
-  resolveSummonsPackageRoot: () => resolveSummonsPackageRoot,
-  summonGateOfficer: () => summonGateOfficer,
-  summonPublicRole: () => summonPublicRole
+// src/public-cli/reviewer-run.ts
+var reviewer_run_exports = {};
+__export(reviewer_run_exports, {
+  buildReviewerTurnRequest: () => buildReviewerTurnRequest,
+  runPublicReviewer: () => runPublicReviewer,
+  runPublicReviewerResume: () => runPublicReviewerResume
 });
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join35 } from "node:path";
-function createCapturingIo() {
-  const chunks = [];
-  return {
-    io: {
-      stdout() {
-      },
-      stderr(text) {
-        chunks.push(text);
-      }
-    },
-    stderrText: () => chunks.join("")
-  };
+import { resolve as resolve14 } from "node:path";
+function reviewerMethods(packageRoot) {
+  return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "ak-cross-m-review") }];
 }
-function parentDir(path) {
-  const end = path.endsWith("/") || path.endsWith("\\") ? path.slice(0, -1) : path;
-  const idx = Math.max(end.lastIndexOf("/"), end.lastIndexOf("\\"));
+async function runReviewerTurnInFreshCopy(env, projectRoot, io, body) {
+  if (env.executionCwd !== void 0) {
+    return body(env);
+  }
+  const { withEphemeralReviewerWorktree: withEphemeralReviewerWorktree2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+  return await withEphemeralReviewerWorktree2({
+    projectRoot,
+    onCleanupDiagnostic: (diagnostic) => {
+      io.stderr(`${diagnostic}
+`);
+    },
+    run: (executionCwd) => body({ ...env, executionCwd })
+  });
+}
+function buildReviewerTurnRequest(admitted, options) {
+  return projectRoleTurnRequest(
+    admitted,
+    {
+      activation: {
+        role: "reviewer",
+        baseRevision: admitted.baseRevision,
+        lens: admitted.lens,
+        authorityRefs: admitted.authorityRefs,
+        ...admitted.ticketNumber === void 0 ? {} : { ticketNumber: admitted.ticketNumber }
+      },
+      methods: reviewerMethods(options.packageRoot)
+    },
+    options
+  );
+}
+function reviewerAdapters(packageRoot, methodMaterial) {
+  return {
+    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleReviewerTerminalResult(
+      admitted,
+      authority,
+      {
+        methodProvenance: methodMaterial.provenance,
+        methodSkillPath: methodMaterial.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+          packageRoot,
+          "ak-cross-m-review"
+        )
+      },
+      scope
+    ),
+    resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
+      const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
+      return infrastructureFailure === void 0 ? result.knownFailure : {
+        ...infrastructureFailure.cause === void 0 ? {} : { cause: infrastructureFailure.cause },
+        diagnostic: infrastructureFailure.diagnostic,
+        ...infrastructureFailure.identity === void 0 ? {} : { identity: infrastructureFailure.identity }
+      };
+    }
+  };
+}
+async function loadReviewerMethodMaterial(packageRoot) {
+  return await loadPackagedMethodSkillMaterial(packageRoot, "ak-cross-m-review");
+}
+function reviewerResumePrompt(env, message) {
+  const lines = [RESUME_TRANSPORT_ENVELOPE];
+  if (message !== void 0) lines.push("", message);
+  return appendEngineSessionMaterial(
+    lines,
+    engineSessionMaterialFromOptions({
+      ...pickEngineAxis(env),
+      packageRoot: env.packageRoot
+    })
+  ).join("\n");
+}
+async function runPublicReviewer(argv, env, io, parseReviewerArgv2) {
+  let parsed;
+  try {
+    parsed = parseReviewerArgv2(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+  if (parsed.lens === void 0) {
+    const { summonParallelReviewerLenses: summonParallelReviewerLenses2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+    const children = await summonParallelReviewerLenses2({
+      argv,
+      // Replay argv under the same cwd the single-axis entry would see (10a).
+      // Do not substitute the resolved project path — relative --project must
+      // not be re-resolved against a shifted cwd.
+      cwd: env.cwd,
+      projectRoot: resolve14(parsed.project ?? env.cwd),
+      // Typed base from the public parse — precheck only; child argv stays verbatim.
+      baseRevision: parsed.baseRevision,
+      home: env.home,
+      agentDir: env.agentDir,
+      ...env.credentials === void 0 ? {} : { credentials: env.credentials },
+      ...env.model === void 0 ? {} : { model: env.model },
+      ...env.host === void 0 ? {} : { host: env.host },
+      ...env.engine === void 0 ? {} : { engine: env.engine },
+      ...env.engineModel === void 0 ? {} : { engineModel: env.engineModel },
+      packageRoot: env.packageRoot,
+      ...env.signal === void 0 ? {} : { signal: env.signal },
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      roleTurnHost: env.roleTurnHost,
+      ...env.hostAdapters === void 0 ? {} : { hostAdapters: env.hostAdapters },
+      principalAuthority: env.principalAuthority,
+      ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs }
+    });
+    const childResults = [children.completeness, children.correctness];
+    const terminals = childResults.map((child) => child.terminal).filter((terminal2) => terminal2 !== void 0);
+    const failedChildren = childResults.filter((child) => child.terminal === void 0 || !isLawfulTypedTerminalOutcome(child.terminal.roleOutcome)).length;
+    const overlayExit = childResults.some((child) => child.exitCode !== 0);
+    const failed = failedChildren > 0 || overlayExit;
+    const overlayDiagnostics = [...new Set(
+      childResults.map((child) => child.stderr).filter((text) => typeof text === "string" && text !== "")
+    )];
+    const terminal = {
+      batch: "reviewer",
+      roleOutcome: failed ? {
+        kind: "failure",
+        role: "reviewer",
+        diagnostic: failedChildren > 0 ? "Reviewer batch child failure" : overlayDiagnostics[0] ?? "Reviewer batch infrastructure failure",
+        decisiveFacts: { failedChildren },
+        payloads: terminals
+      } : { kind: "accepted", role: "reviewer", payloads: terminals },
+      reviewerChildren: {
+        ...children.completeness.terminal === void 0 ? {} : { completeness: children.completeness.terminal },
+        ...children.correctness.terminal === void 0 ? {} : { correctness: children.correctness.terminal }
+      },
+      reviewerChildOutcomes: {
+        completeness: { exitCode: children.completeness.exitCode, ...children.completeness.stderr === void 0 ? {} : { stderr: children.completeness.stderr } },
+        correctness: { exitCode: children.correctness.exitCode, ...children.correctness.stderr === void 0 ? {} : { stderr: children.correctness.stderr } }
+      },
+      // Batch has no parent run and no own attendance; no-advice is affirmative
+      // only (navigator-attendance.ts). Children carry their own navigator facts.
+      navigator: {
+        disposition: "unavailable",
+        source: "unknown",
+        reason: "Reviewer batch has no parent-run Navigator attendance"
+      },
+      artifacts: terminals.flatMap((item) => item.artifacts)
+    };
+    io.stdout(formatTerminalResult(terminal));
+    return { exitCode: failed ? 1 : 0, terminal };
+  }
+  let admitted;
+  try {
+    admitted = await admitReviewerInvocation({
+      home: env.home,
+      principalAuthority: env.principalAuthority,
+      cwd: env.cwd,
+      instruction: parsed.instruction,
+      attachmentPaths: parsed.attachmentPaths,
+      baseRevision: parsed.baseRevision,
+      lens: parsed.lens,
+      authorityRefs: parsed.authorityRefs,
+      ...parsed.project === void 0 ? {} : { project: parsed.project },
+      ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      ...env.model === void 0 ? {} : { model: env.model }
+    });
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+  await markRunAdmitted(admitted, env.principalAuthority);
+  let methodMaterial;
+  try {
+    methodMaterial = await loadReviewerMethodMaterial(env.packageRoot);
+  } catch (error) {
+    return await presentControlledFailure2(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error
+      },
+      reviewerAdapters(env.packageRoot),
+      env.principalAuthority,
+      io
+    );
+  }
+  try {
+    return await runReviewerTurnInFreshCopy(env, admitted.projectRoot, io, async (sandboxedEnv) => await runPostAdmissionResumable({
+      admitted,
+      env: sandboxedEnv,
+      io,
+      buildInitialRequest: () => buildReviewerTurnRequest(admitted, {
+        packageRoot: sandboxedEnv.packageRoot,
+        home: sandboxedEnv.home,
+        agentDir: sandboxedEnv.agentDir,
+        ...sandboxedEnv.model === void 0 ? {} : { model: sandboxedEnv.model },
+        ...pickEngineAxis(sandboxedEnv),
+        ...sandboxedEnv.timeoutMs === void 0 ? {} : { timeoutMs: sandboxedEnv.timeoutMs },
+        ...admitted.correlationId === void 0 && sandboxedEnv.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId },
+        // Ephemeral worktree cwd; durable projectRoot stays on admitted caller project.
+        ...sandboxedEnv.executionCwd === void 0 ? {} : { cwd: sandboxedEnv.executionCwd },
+        continuation: {
+          kind: "initial",
+          prompt: buildReviewerTransportPrompt(
+            admitted,
+            engineSessionMaterialFromOptions({
+              ...pickEngineAxis(sandboxedEnv),
+              packageRoot: sandboxedEnv.packageRoot
+            })
+          )
+        }
+      }),
+      buildResumeRequest: () => buildReviewerTurnRequest(admitted, {
+        packageRoot: sandboxedEnv.packageRoot,
+        home: sandboxedEnv.home,
+        agentDir: sandboxedEnv.agentDir,
+        ...sandboxedEnv.model === void 0 ? {} : { model: sandboxedEnv.model },
+        ...pickEngineAxis(sandboxedEnv),
+        ...sandboxedEnv.timeoutMs === void 0 ? {} : { timeoutMs: sandboxedEnv.timeoutMs },
+        ...admitted.correlationId === void 0 && sandboxedEnv.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId },
+        // In-batch auto-resume keeps the same call's sandbox (dual-lens or single).
+        ...sandboxedEnv.executionCwd === void 0 ? {} : { cwd: sandboxedEnv.executionCwd },
+        continuation: {
+          kind: "resume",
+          prompt: reviewerResumePrompt(sandboxedEnv)
+        }
+      }),
+      adapters: reviewerAdapters(sandboxedEnv.packageRoot, methodMaterial),
+      ...sandboxedEnv.engine === void 0 ? {} : { effectiveEngine: sandboxedEnv.engine }
+    }));
+  } catch (error) {
+    return await presentControlledFailure2(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error
+      },
+      reviewerAdapters(env.packageRoot, methodMaterial),
+      env.principalAuthority,
+      io
+    );
+  }
+}
+async function runPublicReviewerResume(request, env, io) {
+  const sandbox = {
+    ...env.executionCwd === void 0 ? {} : { executionCwd: env.executionCwd }
+  };
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: (effective) => loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) => {
+      const activeEnv = sandbox.executionCwd === void 0 ? env : { ...env, executionCwd: sandbox.executionCwd };
+      const base = resumeTurnRequestProjectionOptions(admitted, effective, activeEnv);
+      return buildReviewerTurnRequest(admitted, {
+        ...base,
+        // Fresh copy at resume time; durable projectRoot unchanged.
+        ...sandbox.executionCwd === void 0 ? {} : { cwd: sandbox.executionCwd },
+        continuation: {
+          kind: "resume",
+          prompt: reviewerResumePrompt(activeEnv, effective.message)
+        }
+      });
+    },
+    adapters: reviewerAdapters(env.packageRoot),
+    afterAdmittedLoad: async (admitted) => {
+      return resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        loadMaterial: () => loadReviewerMethodMaterial(env.packageRoot),
+        adaptersWith: (material) => reviewerAdapters(env.packageRoot, material),
+        emptyAdapters: reviewerAdapters(env.packageRoot)
+      });
+    },
+    afterAdmittedPrepare: async (admitted) => {
+      if (sandbox.executionCwd !== void 0) {
+        return { env: { ...env, executionCwd: sandbox.executionCwd } };
+      }
+      const { openEphemeralReviewerWorktree: openEphemeralReviewerWorktree2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+      const opened = await openEphemeralReviewerWorktree2({
+        projectRoot: admitted.projectRoot,
+        onCleanupDiagnostic: (diagnostic) => {
+          io.stderr(`${diagnostic}
+`);
+        }
+      });
+      sandbox.executionCwd = opened.executionCwd;
+      return {
+        env: { ...env, executionCwd: opened.executionCwd },
+        cleanup: opened.close
+      };
+    },
+    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
+  });
+}
+var init_reviewer_run = __esm({
+  "src/public-cli/reviewer-run.ts"() {
+    "use strict";
+    init_engine_material();
+    init_method_skill();
+    init_cli_errors();
+    init_invocation();
+    init_run_lifecycle();
+    init_settlement();
+    init_terminal();
+    init_turn_request();
+    init_post_admission();
+  }
+});
+
+// src/public-role-summons.ts
+var public_role_summons_exports = {};
+__export(public_role_summons_exports, {
+  AK_ROLE_PACKAGE_ROOT_ENV: () => AK_ROLE_PACKAGE_ROOT_ENV,
+  openEphemeralReviewerWorktree: () => openEphemeralReviewerWorktree,
+  resolveSummonsPackageRoot: () => resolveSummonsPackageRoot,
+  summonGateOfficer: () => summonGateOfficer,
+  summonParallelReviewerLenses: () => summonParallelReviewerLenses,
+  summonPublicRole: () => summonPublicRole,
+  withEphemeralReviewerWorktree: () => withEphemeralReviewerWorktree
+});
+import { execFile as execFile3 } from "node:child_process";
+import { existsSync as existsSync11 } from "node:fs";
+import { mkdir as mkdir5, mkdtemp as mkdtemp4, realpath as realpath6, rm as rm4 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join35, relative as relative3, sep as sep5 } from "node:path";
+import { promisify as promisify3 } from "node:util";
+function createCapturingIo() {
+  const chunks = [];
+  return {
+    io: {
+      stdout() {
+      },
+      stderr(text) {
+        chunks.push(text);
+      }
+    },
+    stderrText: () => chunks.join("")
+  };
+}
+function parentDir(path) {
+  const end = path.endsWith("/") || path.endsWith("\\") ? path.slice(0, -1) : path;
+  const idx = Math.max(end.lastIndexOf("/"), end.lastIndexOf("\\"));
   if (idx <= 0) return end;
   return end.slice(0, idx);
 }
@@ -20639,13 +21314,14 @@ async function createSummonEnv(options, afterHost) {
     Promise.resolve().then(() => (init_role_turn_host_resolution(), role_turn_host_resolution_exports)),
     Promise.resolve().then(() => (init_config(), config_exports))
   ]);
-  const principalAuthority = piDurablePrincipalAuthority2;
+  const principalAuthority = options.principalAuthority ?? piDurablePrincipalAuthority2;
   const roleTurnHost = resolveRoleTurnHost2(
     {
       packageRoot: options.packageRoot,
       ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
       ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
-      ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs }
+      ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs },
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     },
     { role: options.role, seat: options.seat, principalAuthority }
   );
@@ -20658,13 +21334,16 @@ async function createSummonEnv(options, afterHost) {
     };
   }
   const hostName = seatWithModel.host ?? "pi";
-  const { loadHostProvidersTable: loadHostProvidersTable2, projectHostFacingProvider: projectHostFacingProvider2 } = await Promise.resolve().then(() => (init_host_providers(), host_providers_exports));
-  const hostFacingSelection = projectHostFacingProvider2(
-    seatWithModel.selection,
-    hostName,
-    loadHostProvidersTable2(options.home),
-    options.home
-  );
+  let hostFacingSelection = options.hostFacingModel;
+  if (hostFacingSelection === void 0) {
+    const { loadHostProvidersTable: loadHostProvidersTable2, projectHostFacingProvider: projectHostFacingProvider2 } = await Promise.resolve().then(() => (init_host_providers(), host_providers_exports));
+    hostFacingSelection = projectHostFacingProvider2(
+      seatWithModel.selection,
+      hostName,
+      loadHostProvidersTable2(options.home),
+      options.home
+    );
+  }
   return {
     ok: true,
     env: {
@@ -20678,7 +21357,8 @@ async function createSummonEnv(options, afterHost) {
       credentials: options.credentials,
       ...hostFacingSelection === void 0 ? {} : { model: hostFacingSelection },
       ...projectSeatEngine(seatWithModel),
-      ...projectSeatHost(seatWithModel)
+      ...projectSeatHost(seatWithModel),
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     }
   };
 }
@@ -20693,7 +21373,19 @@ async function summonPublicRole(options) {
   } = await Promise.resolve().then(() => (init_config(), config_exports));
   const credentials = options.credentials ?? await loadCredentialProviders2(agentDir);
   const config = await loadPublicCliConfig2(home);
-  const seat = resolveEffectiveSeat2(config, options.role, credentials);
+  const resolvedSeat = resolveEffectiveSeat2(config, options.role, credentials);
+  const inheritedSelection = options.model === void 0 ? void 0 : {
+    provider: options.model.provider,
+    model: options.model.model,
+    ...options.model.thinking === void 0 ? {} : { thinking: options.model.thinking }
+  };
+  const seat = {
+    ...resolvedSeat,
+    ...inheritedSelection === void 0 ? {} : { selection: inheritedSelection, source: "invocation" },
+    ...options.host === void 0 ? {} : { host: options.host, hostSource: "invocation" },
+    ...options.engine === void 0 ? {} : { engine: options.engine, engineSource: "invocation" },
+    ...options.engineModel === void 0 ? {} : { engineModel: options.engineModel }
+  };
   const captured = options.io === void 0 ? createCapturingIo() : void 0;
   const io = options.io ?? captured.io;
   const summonEnvInput = {
@@ -20706,7 +21398,11 @@ async function summonPublicRole(options) {
     seat,
     ...options.extraPiArgs === void 0 ? {} : { extraPiArgs: options.extraPiArgs },
     ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
-    ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters }
+    ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
+    ...options.principalAuthority === void 0 ? {} : { principalAuthority: options.principalAuthority },
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+    // Parent model is already host-facing; child must not project again.
+    ...options.model === void 0 ? {} : { hostFacingModel: options.model }
   };
   async function prepareSummonEnv(afterHost) {
     try {
@@ -20718,7 +21414,9 @@ async function summonPublicRole(options) {
         ok: true,
         env: {
           ...built.env,
-          stationChild: true,
+          // Nested court stations keep station-child semantics; dual-lens
+          // ordinary Reviewer axes opt out (#946 / ADR 0082).
+          ...options.stationChild === false ? {} : { stationChild: true },
           // Forward composition-root adapters so nested court stations (e.g.
           // countersign → diarist) select the same faux/production table (#924).
           ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
@@ -20728,7 +21426,8 @@ async function summonPublicRole(options) {
           ...options.gateReviewInstruction === void 0 ? {} : { gateReviewInstruction: options.gateReviewInstruction },
           ...options.boundTicketNumber === void 0 ? {} : { boundTicketNumber: options.boundTicketNumber },
           ...options.correlationId === void 0 || options.correlationId.trim() === "" ? {} : { correlationId: options.correlationId },
-          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
+          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId },
+          ...options.executionCwd === void 0 ? {} : { executionCwd: options.executionCwd }
         }
       };
     } catch (error) {
@@ -20790,14 +21489,32 @@ async function summonPublicRole(options) {
     case "navigator":
     case "gatekeeper": {
       const seat2 = options.role;
-      const [{ runPublicInstructionSeat: runPublicInstructionSeat2 }, invocation] = await Promise.all([
+      const [{ runPublicInstructionSeat: runPublicInstructionSeat2, runPublicInstructionSeatResume: runPublicInstructionSeatResume2 }, invocation] = await Promise.all([
         Promise.resolve().then(() => (init_instruction_seat_run(), instruction_seat_run_exports)),
         Promise.resolve().then(() => (init_invocation(), invocation_exports))
       ]);
       const parse = seat2 === "auditor" ? invocation.parseAuditorArgv : seat2 === "navigator" ? invocation.parseNavigatorArgv : invocation.parseGatekeeperArgv;
-      const stepped = await runPrepared(parse, (env, once) => runPublicInstructionSeat2(options.argv, env, io, seat2, once));
-      if ("fail" in stepped) return stepped.fail;
-      result = stepped.ok;
+      const resumeRunId = typeof options.resumeRunId === "string" && options.resumeRunId.trim() !== "" ? options.resumeRunId.trim() : void 0;
+      if (resumeRunId !== void 0) {
+        const instruction = options.argv[0] ?? "";
+        const stepped = await runPrepared(parse, (env) => runPublicInstructionSeatResume2(
+          {
+            runId: resumeRunId,
+            summons: {
+              instruction,
+              instructionEmpty: instruction.trim() === ""
+            }
+          },
+          env,
+          io
+        ));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      } else {
+        const stepped = await runPrepared(parse, (env, once) => runPublicInstructionSeat2(options.argv, env, io, seat2, once));
+        if ("fail" in stepped) return stepped.fail;
+        result = stepped.ok;
+      }
       break;
     }
     case "judge": {
@@ -20840,6 +21557,16 @@ async function summonPublicRole(options) {
       result = stepped.ok;
       break;
     }
+    case "reviewer": {
+      const [{ runPublicReviewer: runPublicReviewer2 }, { parseReviewerArgv: parseReviewerArgv2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_reviewer_run(), reviewer_run_exports)),
+        Promise.resolve().then(() => (init_invocation(), invocation_exports))
+      ]);
+      const stepped = await runPrepared(parseReviewerArgv2, (env, once) => runPublicReviewer2(options.argv, env, io, once));
+      if ("fail" in stepped) return stepped.fail;
+      result = stepped.ok;
+      break;
+    }
   }
   const stderr = captured?.stderrText();
   const runDirectory = result.admitted?.runDirectory;
@@ -20851,6 +21578,296 @@ async function summonPublicRole(options) {
     ...stderr === void 0 || stderr === "" ? {} : { stderr }
   };
 }
+function withReviewerLens(argv, lens) {
+  const separator = argv.indexOf("--");
+  if (separator === -1) return [...argv, "--lens", lens];
+  return [...argv.slice(0, separator), "--lens", lens, ...argv.slice(separator)];
+}
+async function resolveReviewerWorktreeRoots(projectRoot) {
+  const callerProjectRoot = await realpath6(projectRoot);
+  const sourceProjectRoot = await realpath6((await execFileAsync3(
+    "git",
+    ["rev-parse", "--show-toplevel"],
+    { cwd: callerProjectRoot }
+  )).stdout.trim());
+  const callerRelative = relative3(sourceProjectRoot, callerProjectRoot);
+  const projectRelative = callerRelative === "" || callerRelative === "." || callerRelative.startsWith(`..${sep5}`) || callerRelative === ".." ? "" : callerRelative;
+  return { callerProjectRoot, sourceProjectRoot, projectRelative };
+}
+function reviewerSandboxPath(worktreeAxis, projectRelative) {
+  return projectRelative === "" ? worktreeAxis : join35(worktreeAxis, projectRelative);
+}
+async function openEphemeralReviewerWorktree(options) {
+  const { sourceProjectRoot, projectRelative } = await resolveReviewerWorktreeRoots(
+    options.projectRoot
+  );
+  const { stdout: headStdout } = await execFileAsync3(
+    "git",
+    ["rev-parse", "--verify", "HEAD^{commit}"],
+    { cwd: sourceProjectRoot }
+  );
+  const targetCommit = headStdout.trim();
+  const root = await mkdtemp4(join35(tmpdir4(), "ak-reviewer-sandbox-"));
+  const worktreeRoot = join35(root, "work");
+  let registered = false;
+  const rollback = async (cause) => {
+    const cleanupErrors = [];
+    if (registered) {
+      try {
+        await execFileAsync3("git", ["worktree", "remove", "--force", worktreeRoot], {
+          cwd: sourceProjectRoot
+        });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+    }
+    try {
+      await rm4(root, { recursive: true, force: true });
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+    if (cleanupErrors.length > 0) {
+      options.onCleanupDiagnostic?.([
+        "reviewer worktree cleanup failed",
+        ...cleanupErrors.map((error) => error instanceof Error ? error.message : String(error))
+      ].join("\n"));
+    }
+    throw cause;
+  };
+  try {
+    await execFileAsync3("git", ["worktree", "add", "--detach", worktreeRoot, targetCommit], {
+      cwd: sourceProjectRoot
+    });
+    registered = true;
+    if (projectRelative !== "") {
+      await mkdir5(reviewerSandboxPath(worktreeRoot, projectRelative), { recursive: true });
+    }
+  } catch (error) {
+    await rollback(error);
+  }
+  let closed = false;
+  return {
+    executionCwd: reviewerSandboxPath(worktreeRoot, projectRelative),
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      const cleanupErrors = [];
+      try {
+        await execFileAsync3("git", ["worktree", "remove", worktreeRoot], {
+          cwd: sourceProjectRoot
+        });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      try {
+        await rm4(root, { recursive: true, force: true });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      if (cleanupErrors.length > 0) {
+        options.onCleanupDiagnostic?.([
+          "reviewer worktree cleanup failed",
+          ...cleanupErrors.map((error) => error instanceof Error ? error.message : String(error))
+        ].join("\n"));
+      }
+    }
+  };
+}
+async function withEphemeralReviewerWorktree(options) {
+  const sandbox = await openEphemeralReviewerWorktree({
+    projectRoot: options.projectRoot,
+    ...options.onCleanupDiagnostic === void 0 ? {} : { onCleanupDiagnostic: options.onCleanupDiagnostic }
+  });
+  try {
+    return await options.run(sandbox.executionCwd);
+  } finally {
+    await sandbox.close();
+  }
+}
+async function summonParallelReviewerLenses(options) {
+  const describeFailure = (error) => {
+    if (error instanceof AggregateError) {
+      return [error.message, ...error.errors.map(describeFailure)].join("\n");
+    }
+    return error instanceof Error ? error.message : String(error);
+  };
+  const failedResult = (error) => ({
+    exitCode: 1,
+    stderr: describeFailure(error)
+  });
+  const dualFailure = (error) => {
+    const failure2 = failedResult(error);
+    return { completeness: failure2, correctness: failure2 };
+  };
+  let sourceProjectRoot;
+  let projectRelative;
+  let targetCommit;
+  const statusArgs = [
+    "status",
+    "--porcelain=v1",
+    "--untracked-files=all",
+    "--",
+    ":/",
+    ":(top,exclude).claude/worktrees/**"
+  ];
+  try {
+    const roots = await resolveReviewerWorktreeRoots(options.projectRoot);
+    sourceProjectRoot = roots.sourceProjectRoot;
+    projectRelative = roots.projectRelative;
+    const { stdout: statusStdout } = await execFileAsync3("git", statusArgs, {
+      cwd: sourceProjectRoot
+    });
+    if (statusStdout !== "") {
+      const diagnostic = [
+        "Reviewer target status gate failed:",
+        "git status --porcelain=v1 --untracked-files=all -- :/ ':(top,exclude).claude/worktrees/**'",
+        statusStdout
+      ].join("\n");
+      return dualFailure(new Error(diagnostic));
+    }
+    const { stdout: targetStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    targetCommit = targetStdout.trim();
+    await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", `${options.baseRevision}^{commit}`],
+      { cwd: sourceProjectRoot }
+    );
+  } catch (error) {
+    return dualFailure(error);
+  }
+  const root = await mkdtemp4(join35(tmpdir4(), "ak-reviewer-lenses-"));
+  const completenessRoot = join35(root, "completeness");
+  const correctnessRoot = join35(root, "correctness");
+  const worktrees = [completenessRoot, correctnessRoot];
+  const created = /* @__PURE__ */ new Set();
+  let results;
+  const creation = await Promise.allSettled(
+    worktrees.map(async (path) => {
+      await execFileAsync3("git", ["worktree", "add", "--detach", path, targetCommit], {
+        cwd: sourceProjectRoot
+      });
+      created.add(path);
+      if (projectRelative !== "") {
+        await mkdir5(reviewerSandboxPath(path, projectRelative), { recursive: true });
+      }
+    })
+  );
+  const creationFailures = creation.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (creationFailures.length > 0) {
+    const failure2 = failedResult(new AggregateError(
+      creationFailures,
+      "parallel reviewer worktree creation failed"
+    ));
+    results = { completeness: failure2, correctness: failure2 };
+  } else {
+    const summon = (lens, worktreeAxis) => {
+      const sandbox = reviewerSandboxPath(worktreeAxis, projectRelative);
+      return summonPublicRole({
+        role: "reviewer",
+        argv: withReviewerLens(options.argv, lens),
+        cwd: options.cwd,
+        executionCwd: sandbox,
+        // Ordinary single-axis public semantics — not a nested court station.
+        stationChild: false,
+        home: options.home,
+        ...options.agentDir === void 0 ? {} : { agentDir: options.agentDir },
+        ...options.credentials === void 0 ? {} : { credentials: options.credentials },
+        ...options.model === void 0 ? {} : { model: options.model },
+        ...options.host === void 0 ? {} : { host: options.host },
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineModel === void 0 ? {} : { engineModel: options.engineModel },
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId },
+        ...options.packageRoot === void 0 ? {} : { packageRoot: options.packageRoot },
+        ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
+        ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
+        ...options.principalAuthority === void 0 ? {} : { principalAuthority: options.principalAuthority },
+        ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+      });
+    };
+    const settled = await Promise.allSettled([
+      summon("completeness", completenessRoot),
+      summon("correctness", correctnessRoot)
+    ]);
+    results = {
+      completeness: settled[0].status === "fulfilled" ? settled[0].value : failedResult(settled[0].reason),
+      correctness: settled[1].status === "fulfilled" ? settled[1].value : failedResult(settled[1].reason)
+    };
+  }
+  let sealDiagnostic;
+  try {
+    const { stdout: headBeforeStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    const { stdout: sealedStatusStdout } = await execFileAsync3("git", statusArgs, {
+      cwd: sourceProjectRoot
+    });
+    const { stdout: headAfterStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    const headBefore = headBeforeStdout.trim();
+    const headAfter = headAfterStdout.trim();
+    if (headBefore !== targetCommit || headAfter !== targetCommit || sealedStatusStdout !== "") {
+      sealDiagnostic = [
+        "Reviewer target final seal failed:",
+        `HEAD before status => ${headBefore}`,
+        `HEAD after status => ${headAfter}`,
+        `expected PRE_HEAD ${targetCommit}`,
+        "git status --porcelain=v1 --untracked-files=all -- :/ ':(top,exclude).claude/worktrees/**'",
+        sealedStatusStdout
+      ].join("\n");
+    }
+  } catch (error) {
+    sealDiagnostic = `Reviewer target final seal failed:
+${describeFailure(error)}`;
+  }
+  if (sealDiagnostic !== void 0) {
+    const withSealFailure = (result) => ({
+      ...result,
+      exitCode: 1,
+      stderr: [result.stderr, sealDiagnostic].filter(
+        (text) => typeof text === "string" && text !== ""
+      ).join("\n")
+    });
+    results = {
+      completeness: withSealFailure(results.completeness),
+      correctness: withSealFailure(results.correctness)
+    };
+  }
+  const cleanup = await Promise.allSettled(
+    [...created].map((path) => execFileAsync3("git", ["worktree", "remove", path], { cwd: sourceProjectRoot }))
+  );
+  const cleanupFailures = cleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (cleanupFailures.length === 0) {
+    const rootCleanup = await Promise.allSettled([rm4(root, { recursive: true, force: true })]);
+    cleanupFailures.push(...rootCleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []));
+  }
+  if (cleanupFailures.length > 0) {
+    const diagnostic = [
+      "parallel reviewer worktree cleanup failed",
+      ...cleanupFailures.map((failure2) => failure2 instanceof Error ? failure2.message : String(failure2))
+    ].join("\n");
+    const withCleanupDiagnostic = (result) => ({
+      ...result,
+      stderr: [result.stderr, diagnostic].filter(
+        (text) => typeof text === "string" && text !== ""
+      ).join("\n")
+    });
+    results = {
+      completeness: withCleanupDiagnostic(results.completeness),
+      correctness: withCleanupDiagnostic(results.correctness)
+    };
+  }
+  return results;
+}
 async function summonGateOfficer(options) {
   let home = options.home;
   if (home === void 0) {
@@ -20900,22 +21917,23 @@ async function summonGateOfficer(options) {
     ...common
   });
 }
-var AK_ROLE_PACKAGE_ROOT_ENV;
+var AK_ROLE_PACKAGE_ROOT_ENV, execFileAsync3;
 var init_public_role_summons = __esm({
   "src/public-role-summons.ts"() {
     "use strict";
     init_engine_material();
     AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT";
+    execFileAsync3 = promisify3(execFile3);
   }
 });
 
 // src/acp-host/production-host.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // src/role-envelope.ts
 init_engine_detour();
-import { randomUUID as randomUUID8 } from "node:crypto";
-import { mkdir as mkdir6, writeFile as writeFile12 } from "node:fs/promises";
+import { randomUUID as randomUUID9 } from "node:crypto";
+import { appendFile as appendFile3, mkdir as mkdir7, writeFile as writeFile12 } from "node:fs/promises";
 import { createServer } from "node:net";
 import { dirname as dirname22, join as join41 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -21003,7 +22021,7 @@ async function requireGatekeeperPass(options) {
 }
 
 // src/host-native-method.ts
-import { lstat as lstat7, mkdir as mkdir5, readlink, realpath as realpath6, symlink } from "node:fs/promises";
+import { lstat as lstat7, mkdir as mkdir6, readlink, realpath as realpath7, symlink } from "node:fs/promises";
 import { basename as basename9, dirname as dirname18, join as join36 } from "node:path";
 var packagedMethodsDir = (root) => join36(root, "resources", "methods");
 function hostMethodSkills(methods) {
@@ -21014,11 +22032,11 @@ function hostMethodSkills(methods) {
   }));
 }
 async function installWorkspaceMethodSkills(cwd, packageRoot) {
-  const target = await realpath6(packagedMethodsDir(packageRoot));
+  const target = await realpath7(packagedMethodsDir(packageRoot));
   const link = join36(cwd, ".agents", "skills");
   try {
     const stat2 = await lstat7(link);
-    if (!stat2.isSymbolicLink() || await realpath6(link) !== target) {
+    if (!stat2.isSymbolicLink() || await realpath7(link) !== target) {
       const detail = stat2.isSymbolicLink() ? `symlink to ${await readlink(link)}` : "non-symlink entry";
       throw new Error(`workspace method catalog conflict at ${link}: ${detail}`);
     }
@@ -21026,12 +22044,12 @@ async function installWorkspaceMethodSkills(cwd, packageRoot) {
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  await mkdir5(dirname18(link), { recursive: true });
+  await mkdir6(dirname18(link), { recursive: true });
   try {
     await symlink(target, link);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
-    if (await realpath6(link).catch(() => "") !== target) {
+    if (await realpath7(link).catch(() => "") !== target) {
       throw new Error(`workspace method catalog conflict at ${link}`);
     }
   }
@@ -21045,6 +22063,7 @@ init_host_contracts();
 init_sitian_facade();
 init_submission_ledger();
 init_collector_ledger();
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { readFileSync as readFileSync6, writeSync as writeSync4 } from "node:fs";
 import { join as join40 } from "node:path";
 import { Value as Value4 } from "typebox/value";
@@ -21096,7 +22115,7 @@ import {
   openSync as openSync2,
   writeSync
 } from "node:fs";
-import { dirname as dirname19, isAbsolute as isAbsolute10, resolve as resolve15 } from "node:path";
+import { dirname as dirname19, isAbsolute as isAbsolute10, resolve as resolve16 } from "node:path";
 
 // src/activation-ledger-session.ts
 init_activation_ledger_topology();
@@ -21106,7 +22125,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { isAbsolute as isAbsolute9, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute9, resolve as resolve15 } from "node:path";
 var ActivationSessionFileMissingError = class extends Error {
   code = "AK_ACTIVATION_SESSION_FILE_MISSING";
   path;
@@ -21151,7 +22170,7 @@ function durableSessionPointer(sessionManager) {
       `Workflow role activation requires an absolute durable session file path; got relative path: ${file}`
     );
   }
-  const resolvedFile = resolve14(file);
+  const resolvedFile = resolve15(file);
   try {
     lstatSync2(resolvedFile);
   } catch (error) {
@@ -21243,8 +22262,8 @@ function appendActivationLedgerLine(ledgerPath, line2, options) {
       `activation ledger home must be absolute: ${options.ledgerHome}`
     );
   }
-  const resolvedLedger = resolve15(ledgerPath);
-  const resolvedHome = resolve15(options.ledgerHome);
+  const resolvedLedger = resolve16(ledgerPath);
+  const resolvedHome = resolve16(options.ledgerHome);
   const parent = dirname19(resolvedLedger);
   ensureRealDirectoryTree(resolvedHome, parent);
   assertLedgerFileInsideHome(resolvedLedger, resolvedHome);
@@ -21605,11 +22624,11 @@ init_collector_github();
 
 // src/collector-handbook.ts
 import { readFile as readFile19 } from "node:fs/promises";
-import { join as join38, sep as sep5 } from "node:path";
+import { join as join38, sep as sep6 } from "node:path";
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { rename as rename3, rm as rm4, writeFile as writeFile11 } from "node:fs/promises";
+import { rename as rename3, rm as rm5, writeFile as writeFile11 } from "node:fs/promises";
 import { dirname as dirname20, join as join37 } from "node:path";
 async function writeFileAtomically(destination, contents) {
   const parent = dirname20(destination);
@@ -21618,7 +22637,7 @@ async function writeFileAtomically(destination, contents) {
     await writeFile11(temporary, contents);
     await rename3(temporary, destination);
   } catch (error) {
-    await rm4(temporary, { force: true }).catch(() => void 0);
+    await rm5(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -21719,7 +22738,7 @@ function resolveCollectorHandbookRoot(sessionPath) {
   if (typeof sessionPath !== "string" || sessionPath.trim().length === 0) {
     throw new Error("\u901A\u8FDB\u53F8\u624B\u518C\u8981\u6C42\u975E\u7A7A session \u8DEF\u5F84\uFF0C\u4E14\u4F4D\u4E8E books/<bookKey>/");
   }
-  const segments = sessionPath.split(sep5);
+  const segments = sessionPath.split(sep6);
   let bookKey;
   for (let i = 0; i + 3 < segments.length; i += 1) {
     if (segments[i] === ".ak-roles" && segments[i + 1] === "books") {
@@ -22891,7 +23910,7 @@ init_navigator_output();
 var NAVIGATOR_TOOL_SPEC = {
   name: NAVIGATOR_OUTPUT_TOOL_NAME,
   label: "\u6E38\u5955\u4F7F\u5EFA\u8BAE",
-  description: "\u6E38\u5955\u4F7F\u7EC8\u5C40\u56DE\u6267\uFF1A\u6392\u597D\u5E8F\u7684\u4E0B\u4E00\u6B65\u89D2\u8272\u8DEF\u7EBF\u5EFA\u8BAE\u3002",
+  description: "\u6E38\u5955\u4F7F\u7EC8\u5C40\u56DE\u6267\uFF1A\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002",
   promptSnippet: "\u6E38\u5955\u4F7F\u5EFA\u8BAE",
   parameters: navigatorOutputSchema
 };
@@ -22916,12 +23935,13 @@ import { createHash as createHash9 } from "node:crypto";
 init_navigator_invocation_identity();
 init_packaged_role_registry();
 init_activation_ledger_topology();
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 import "@earendil-works/pi-coding-agent";
 import { Type as Type22 } from "typebox";
 
 // src/navigator-public-session.ts
 init_sitian_facade();
+import { basename as basename10 } from "node:path";
 
 // src/navigator-session-contracts.ts
 import { Type as Type21 } from "typebox";
@@ -23109,6 +24129,7 @@ async function resolveNavigatorSeatSelection(context) {
 
 // src/navigator-public-session.ts
 init_host_contracts();
+init_cli_errors();
 async function resolveNavigatorLedgerHome(context) {
   const { tryHomeFromAkRolesPath: tryHomeFromAkRolesPath2 } = await Promise.resolve().then(() => (init_activation_ledger_topology(), activation_ledger_topology_exports));
   const runDirectory = runDirectoryFromHostContext(context);
@@ -23123,7 +24144,42 @@ async function resolveNavigatorLedgerHome(context) {
   }
   return void 0;
 }
-function createNativeNavigatorSessionFactory() {
+var NAVIGATOR_HOST_RUN_POINTER_ENTRY = "ak-navigator-host-run";
+function exactRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function runIdFromNavigatorDirectory(runDirectory) {
+  const entry = basename10(runDirectory);
+  const suffix = "@navigator";
+  if (!entry.endsWith(suffix)) return void 0;
+  const runId = entry.slice(0, entry.length - suffix.length);
+  return runId.length > 0 ? runId : void 0;
+}
+function readNavigatorHostRunPointer(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (!exactRecord2(entry)) continue;
+    if (entry.type === "custom" && entry.customType === NAVIGATOR_HOST_RUN_POINTER_ENTRY) {
+      const data = entry.data;
+      if (exactRecord2(data) && typeof data.runId === "string" && data.runId.trim() !== "") {
+        return data.runId.trim();
+      }
+    }
+  }
+  return void 0;
+}
+async function navigatorHostRunResumable(home, runId) {
+  const { piDurablePrincipalAuthority: piDurablePrincipalAuthority2 } = await Promise.resolve().then(() => (init_durable_principal(), durable_principal_exports));
+  const { loadResumableInstructionSeatRun: loadResumableInstructionSeatRun2 } = await Promise.resolve().then(() => (init_run_lifecycle(), run_lifecycle_exports));
+  try {
+    const loaded = await loadResumableInstructionSeatRun2(home, runId, piDurablePrincipalAuthority2);
+    return loaded.admitted.role === "navigator";
+  } catch (error) {
+    if (error instanceof CliUsageError) return false;
+    throw error;
+  }
+}
+function createNativeNavigatorSessionFactory(deps) {
   return async ({ context, subject, tool }) => {
     let thinkingLevel;
     const { createRecordSession: createRecordSession2, NAVIGATOR_RECORD_KIND: NAVIGATOR_RECORD_KIND2 } = await Promise.resolve().then(() => (init_archivist_record_entry(), archivist_record_entry_exports));
@@ -23139,6 +24195,11 @@ function createNativeNavigatorSessionFactory() {
     let noReceipt;
     let disposed = false;
     let inFlightPrompt;
+    let hostRunId = readNavigatorHostRunPointer(sessionManager.getEntries());
+    const summon = deps?.summonPublicRole ?? (async (options) => {
+      const { summonPublicRole: summonPublicRole2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+      return summonPublicRole2(options);
+    });
     return {
       prompt: async (text) => {
         if (disposed) {
@@ -23148,14 +24209,24 @@ function createNativeNavigatorSessionFactory() {
         noReceipt = void 0;
         const run = (async () => {
           try {
-            const { summonPublicRole: summonPublicRole2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
             const summonHome = await resolveNavigatorLedgerHome(context);
-            const summoned = await summonPublicRole2({
+            const resumeRunId = hostRunId;
+            const baseSummon = {
               role: "navigator",
               argv: [text],
               cwd: context.cwd,
               ...summonHome === void 0 ? {} : { home: summonHome }
-            });
+            };
+            const resumable = deps?.hostRunResumable ?? navigatorHostRunResumable;
+            let summoned;
+            if (resumeRunId === void 0 || summonHome === void 0) {
+              summoned = await summon(baseSummon);
+            } else if (await resumable(summonHome, resumeRunId)) {
+              summoned = await summon({ ...baseSummon, resumeRunId });
+            } else {
+              hostRunId = void 0;
+              summoned = await summon(baseSummon);
+            }
             const outcome = summoned.terminal?.roleOutcome;
             if (outcome === void 0) {
               const detail = summoned.stderr?.trim() || `exit ${summoned.exitCode}`;
@@ -23178,21 +24249,31 @@ function createNativeNavigatorSessionFactory() {
               noReceipt = outcome;
               return;
             }
+            const runDirectory = summoned.runDirectory ?? (typeof summoned.admitted?.runDirectory === "string" ? summoned.admitted.runDirectory : void 0);
+            if (typeof runDirectory === "string" && runDirectory.trim() !== "") {
+              const nextRunId = runIdFromNavigatorDirectory(runDirectory);
+              if (nextRunId !== void 0) {
+                hostRunId = nextRunId;
+                sessionManager.appendCustomEntry(NAVIGATOR_HOST_RUN_POINTER_ENTRY, { runId: nextRunId });
+              }
+            }
             if (outcome.kind !== "accepted") {
               return;
             }
+            const { navigatorProseFromUnknown: navigatorProseFromUnknown2 } = await Promise.resolve().then(() => (init_navigator_output(), navigator_output_exports));
+            const proseParts = [];
             for (const payload of outcome.payloads ?? []) {
-              if (typeof payload !== "object" || payload === null || Array.isArray(payload)) continue;
-              const candidates = payload.candidates;
-              if (!Array.isArray(candidates)) continue;
-              await tool.execute(
-                "navigator-public-prepare",
-                { candidates },
-                void 0,
-                void 0,
-                context
-              );
+              const prose = navigatorProseFromUnknown2(payload);
+              if (prose !== void 0) proseParts.push(prose);
             }
+            if (proseParts.length === 0) return;
+            await tool.execute(
+              "navigator-public-prepare",
+              { prose: proseParts.join("\n\n") },
+              void 0,
+              void 0,
+              context
+            );
           } catch (error) {
             if (error instanceof NavigatorUnavailableError) throw error;
             const fact = navigatorProviderFailureFromError(error);
@@ -23246,9 +24327,9 @@ function createNativeNavigatorSessionFactory() {
 
 // src/navigator-attendance.ts
 init_sitian_facade();
-init_public_command_renderer();
 init_work_subject_identity();
 init_receipt_delivery_policy();
+init_navigator_output();
 var NAVIGATOR_EVENT_TYPE = "ak-navigator-attendance";
 var NAVIGATOR_PREPARE_ACCEPTED_TEXT = "\u6E38\u5955\u4F7F\u51C6\u5907\u5DF2\u63A5\u53D7";
 function resolveNavigatorAuthorityMaterial(roleInput, fileAuthority) {
@@ -23258,107 +24339,40 @@ function resolveNavigatorAuthorityMaterial(roleInput, fileAuthority) {
 }
 var NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY.map(({ role, phases }) => ({ role, phases }));
 var prepareSchema = Type22.Object({
-  candidates: Type22.Optional(Type22.Unknown({
-    description: "\u65B9\u5411\u5019\u9009\uFF1Bcandidates[].next.role \u5FC5\u586B\uFF0Cphase \u53EF\u9009\uFF0Croute/matches/reason/command \u53EF\u9009\u4E0A\u4E0B\u6587\uFF0C\u975E\u53D7\u7406\u95F8"
+  prose: Type22.Optional(Type22.Unknown({
+    description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7ED3\u6784\u3002\u975E\u53D7\u7406\u95F8"
   }))
 }, { additionalProperties: true });
-var ROUTE_ENTRY = "ak-navigator-route";
 var CONTEXT_ENTRY = "ak-navigator-context";
 var INVOCATION_ENTRY = NAVIGATOR_INVOCATION_ENTRY;
 var SETTLEMENT_ENTRY = "ak-navigator-settlement";
-var targetRoles = new Set(NAVIGATOR_TARGETS.map(({ role }) => role));
-function exactRecord2(value) {
+function exactRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rejectedPrepareReason(entries, start) {
   const recent = entries.slice(start);
   const prepareCalls = /* @__PURE__ */ new Set();
   for (const entry of recent) {
-    if (!exactRecord2(entry) || entry.type !== "message" || !exactRecord2(entry.message) || entry.message.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
+    if (!exactRecord3(entry) || entry.type !== "message" || !exactRecord3(entry.message) || entry.message.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
     for (const part of entry.message.content) {
-      if (exactRecord2(part) && part.type === "toolCall" && part.name === NAVIGATOR_PREPARE_TOOL_NAME && typeof part.id === "string") prepareCalls.add(part.id);
-    }
-  }
-  let reason;
-  for (const entry of recent) {
-    if (!exactRecord2(entry) || entry.type !== "message" || !exactRecord2(entry.message) || entry.message.role !== "toolResult" || entry.message.isError !== true) continue;
-    const callId = entry.message.toolCallId;
-    if (entry.message.toolName !== NAVIGATOR_PREPARE_TOOL_NAME || typeof callId !== "string" || !prepareCalls.has(callId)) {
-      return void 0;
+      if (exactRecord3(part) && part.type === "toolCall" && part.name === NAVIGATOR_PREPARE_TOOL_NAME && typeof part.id === "string") prepareCalls.add(part.id);
     }
-    const content = entry.message.content;
-    const text = Array.isArray(content) ? content.flatMap((part) => exactRecord2(part) && typeof part.text === "string" ? [part.text] : []).join("") : typeof content === "string" ? content : "";
-    if (text.trim() !== "") reason = text.trim();
-  }
-  return reason;
-}
-function targetIsValid(value) {
-  if (!exactRecord2(value) || !targetRoles.has(String(value.role))) return false;
-  const metadata = packagedRoleMetadata(String(value.role));
-  return metadata !== void 0 && metadata.phases.includes(value.phase);
-}
-function normalizeTarget(value) {
-  if (!exactRecord2(value)) return void 0;
-  const role = typeof value.role === "string" ? value.role.trim() : "";
-  if (role === "") return void 0;
-  if (value.phase === void 0 || value.phase === null) {
-    return { role, phase: null };
-  }
-  if (value.phase === "plan" || value.phase === "apply") {
-    return { role, phase: value.phase };
-  }
-  return { role, phase: null };
-}
-function normalizeMatches(value) {
-  if (!exactRecord2(value)) return void 0;
-  if (typeof value.role !== "string" || value.role.trim() === "") return void 0;
-  if (value.kind !== "accepted") return void 0;
-  let phase;
-  if (value.phase === void 0 || value.phase === null) phase = null;
-  else if (value.phase === "plan" || value.phase === "apply") phase = value.phase;
-  else return void 0;
-  if (value.statuses !== void 0) {
-    if (!Array.isArray(value.statuses) || value.statuses.some((status) => typeof status !== "string" || status.trim() === "")) {
+  }
+  let reason;
+  for (const entry of recent) {
+    if (!exactRecord3(entry) || entry.type !== "message" || !exactRecord3(entry.message) || entry.message.role !== "toolResult" || entry.message.isError !== true) continue;
+    const callId = entry.message.toolCallId;
+    if (entry.message.toolName !== NAVIGATOR_PREPARE_TOOL_NAME || typeof callId !== "string" || !prepareCalls.has(callId)) {
       return void 0;
     }
-    return {
-      role: value.role,
-      phase,
-      kind: "accepted",
-      statuses: [...value.statuses]
-    };
+    const content = entry.message.content;
+    const text = Array.isArray(content) ? content.flatMap((part) => exactRecord3(part) && typeof part.text === "string" ? [part.text] : []).join("") : typeof content === "string" ? content : "";
+    if (text.trim() !== "") reason = text.trim();
   }
-  return { role: value.role, phase, kind: "accepted" };
-}
-function normalizeCandidate(value) {
-  if (!exactRecord2(value)) return void 0;
-  const next = normalizeTarget(value.next);
-  const route = Array.isArray(value.route) ? value.route.map(normalizeTarget).filter((target) => target !== void 0) : void 0;
-  const matches = normalizeMatches(value.matches);
-  const id = typeof value.id === "string" && value.id.trim() !== "" ? value.id : void 0;
-  const reason = typeof value.reason === "string" && value.reason.trim() !== "" ? value.reason : void 0;
-  const command = typeof value.command === "string" ? value.command : void 0;
-  return {
-    ...id === void 0 ? {} : { id },
-    ...matches === void 0 ? {} : { matches },
-    ...route === void 0 || route.length === 0 ? {} : { route },
-    ...next === void 0 ? {} : { next },
-    ...reason === void 0 ? {} : { reason },
-    ...command === void 0 ? {} : { command }
-  };
-}
-function normalizePrepareOutput(value) {
-  if (!exactRecord2(value) || !Array.isArray(value.candidates)) return [];
-  return value.candidates.map(normalizeCandidate).filter((candidate) => candidate !== void 0);
-}
-function routeEqual(a, b) {
-  return a !== void 0 && a.length === b.length && a.every((target, index) => target.role === b[index].role && target.phase === b[index].phase);
-}
-function routeText(route) {
-  return route.map((target) => target.phase === null ? target.role : `${target.role} ${target.phase}`).join(" \u2192 ");
+  return reason;
 }
-function targetText(target) {
-  return target.phase === null ? target.role : `${target.role} ${target.phase}`;
+function normalizePrepareProse(value) {
+  return navigatorProseFromUnknown(value);
 }
 function navigatorSubjectKey(subjectRoot, subject, provenance = "role_input") {
   if (issueRoot(subjectRoot) !== void 0 || !subjectRoot.includes("/.ak/work/")) return subjectRoot;
@@ -23369,7 +24383,7 @@ function navigatorSubjectKey(subjectRoot, subject, provenance = "role_input") {
 }
 function navigatorSubjectKeyForInput(subjectRoot, reference, cwd = process.cwd()) {
   if (issueRoot(subjectRoot) !== void 0 || !subjectRoot.includes("/.ak/work/")) return subjectRoot;
-  const resolvedReference = resolve16(cwd, reference);
+  const resolvedReference = resolve17(cwd, reference);
   const marker = "/runs/";
   if (resolvedReference.includes(marker)) {
     return subjectRoot;
@@ -23380,7 +24394,7 @@ function createNavigatorPrepareTool(onOutput) {
   return {
     name: NAVIGATOR_PREPARE_TOOL_NAME,
     label: "\u6E38\u5955\u4F7F\u51C6\u5907",
-    description: "\u63D0\u4EA4\u6E38\u5955\u4F7F\u65B9\u5411\u5EFA\u8BAE\u3002",
+    description: "\u63D0\u4EA4\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\u3002",
     parameters: prepareSchema,
     async execute(_id, value) {
       onOutput(value);
@@ -23388,34 +24402,6 @@ function createNavigatorPrepareTool(onOutput) {
     }
   };
 }
-function selectNavigatorCandidate(candidates, settlement) {
-  if (settlement.kind !== "accepted") return void 0;
-  const usable = candidates.filter((candidate) => candidate.next !== void 0);
-  if (usable.length === 0) return void 0;
-  const rolePhaseMatched = usable.filter(
-    (candidate) => candidate.matches !== void 0 && candidate.matches.role === settlement.role && candidate.matches.phase === settlement.phase
-  );
-  if (rolePhaseMatched.length > 0) {
-    if (settlement.status !== void 0) {
-      const statusSpecific = rolePhaseMatched.find(
-        (candidate) => candidate.matches?.statuses !== void 0 && candidate.matches.statuses.includes(settlement.status)
-      );
-      if (statusSpecific !== void 0) {
-        return { candidate: statusSpecific, matchedToSettlement: true };
-      }
-    }
-    const rolePhaseGeneric = rolePhaseMatched.find(
-      (candidate) => candidate.matches?.statuses === void 0
-    );
-    if (rolePhaseGeneric !== void 0) {
-      return { candidate: rolePhaseGeneric, matchedToSettlement: true };
-    }
-    return void 0;
-  }
-  const unbound = usable.find((candidate) => candidate.matches === void 0);
-  if (unbound === void 0) return void 0;
-  return { candidate: unbound, matchedToSettlement: false };
-}
 function formatNavigatorReport(report) {
   const playbookFailure = report.routePlaybookReadFailure === void 0 ? [] : [`\u8DEF\u4E66\u8BFB\u53D6\u5931\u8D25\uFF1A${report.routePlaybookReadFailure}`];
   if (report.disposition === "no-advice") return playbookFailure.join("\n");
@@ -23425,31 +24411,24 @@ function formatNavigatorReport(report) {
   if (report.disposition === "arrival") {
     return [...playbookFailure, ...report.arrivalMessage ? [report.arrivalMessage] : []].join("\n");
   }
-  return [
-    ...playbookFailure,
-    ...report.route === void 0 ? [] : [`\u8DEF\u7EBF\uFF1A${routeText(report.route)}`],
-    ...report.next === void 0 ? [] : [`\u4E0B\u4E00\u6B65\uFF1A${targetText(report.next)}`],
-    ...report.reason === void 0 || report.reason.trim() === "" ? [] : [`\u7406\u7531\uFF1A${report.reason}`],
-    ...report.command === void 0 || report.command.trim() === "" ? [] : [`\u547D\u4EE4\uFF1A${report.command}`]
-  ].join("\n");
+  return [...playbookFailure, ...report.prose ? [report.prose] : []].join("\n");
 }
 function createNavigatorAttendance(options) {
   let preparation;
+  let preparationInFlight = false;
   let sessionReady;
   let session;
   let subjectKey = options.subjectKey;
   let subject = options.subject;
   let authority = options.authority;
   let contextError = options.contextError;
-  let candidates;
+  let preparedProse;
   const invocationPrincipal = options.invocationId ?? mintNavigatorInvocationId();
   let activeInvocationId = invocationPrincipal;
-  let previousRoute;
   let outputSink;
   let settlementTail = Promise.resolve();
   let settlementFailure;
   let preparationFailure;
-  let preparationNoReceipt = false;
   let routePlaybookReadFailure;
   let disposed = false;
   let warmedHelp;
@@ -23476,12 +24455,7 @@ function createNavigatorAttendance(options) {
   };
   let routePlaybookSettlement;
   let prepareBoundSettlement;
-  const prepare = async () => {
-    const boundSettlement = prepareBoundSettlement;
-    prepareBoundSettlement = void 0;
-    preparationNoReceipt = false;
-    const invocationId = invocationPrincipal;
-    activeInvocationId = invocationId;
+  const loadMaterialsAndSession = async (invocationId) => {
     if (contextError !== void 0) throw navigatorUnavailableError("context", contextError);
     if (typeof authority !== "string" || authority.trim() === "") {
       throw navigatorUnavailableError(
@@ -23539,21 +24513,6 @@ function createNavigatorAttendance(options) {
     const helpContext = help.map(({ role, help: text }) => `<role_help role="${role}">
 ${text}
 </role_help>`).join("\n");
-    let output;
-    let prepareBatchRejected = false;
-    outputSink = (value) => {
-      if (output === void 0) {
-        output = value;
-        return;
-      }
-      const prior2 = output.candidates;
-      const next = value.candidates;
-      const merged = [
-        ...Array.isArray(prior2) ? prior2 : prior2 === void 0 ? [] : [prior2],
-        ...Array.isArray(next) ? next : next === void 0 ? [] : [next]
-      ];
-      output = { ...value, candidates: merged };
-    };
     const tool = createNavigatorPrepareTool((value) => {
       outputSink?.(value);
     });
@@ -23561,7 +24520,12 @@ ${text}
       sessionReady = (async () => {
         let created;
         try {
-          created = await options.createSession({ context: options.context, subject: subjectKey, ...options.modelSettingPath === void 0 ? {} : { modelSettingPath: options.modelSettingPath }, tool });
+          created = await options.createSession({
+            context: options.context,
+            subject: subjectKey,
+            ...options.modelSettingPath === void 0 ? {} : { modelSettingPath: options.modelSettingPath },
+            tool
+          });
         } catch (error) {
           throw navigatorUnavailableError("session", error);
         }
@@ -23592,26 +24556,63 @@ ${text}
       session.appendEntry(INVOCATION_ENTRY, { invocationId, role: options.role, phase: options.phase, subjectKey });
     }
     if (disposed) throw navigatorUnavailableError("session", new Error("Navigator attendance was disposed"));
-    const activeSession = session;
-    if (activeSession === void 0) throw new Error("Navigator session was not created");
-    const prior = activeSession.entries().filter((entry) => exactRecord2(entry) && entry.type === "custom" && entry.customType === ROUTE_ENTRY && exactRecord2(entry.data) && entry.data.subjectKey === subjectKey).at(-1)?.data;
-    if (exactRecord2(prior) && Array.isArray(prior.route) && prior.route.every((target) => targetIsValid(target))) {
-      previousRoute = prior.route.map((target) => ({ role: target.role, phase: target.phase }));
-    }
-    const publicSettlementHistory = activeSession.entries().filter((entry) => exactRecord2(entry) && entry.type === "custom" && entry.customType === SETTLEMENT_ENTRY && exactRecord2(entry.data)).map((entry) => entry.data);
+    if (session === void 0) throw new Error("Navigator session was not created");
+    return { soul, routePlaybook, helpContext, modelSetting, model, help, activeSession: session };
+  };
+  const prepare = async (materialsBundle) => {
+    const boundSettlement = prepareBoundSettlement;
+    prepareBoundSettlement = void 0;
+    const invocationId = invocationPrincipal;
+    activeInvocationId = invocationId;
+    let output;
+    let prepareBatchRejected = false;
+    outputSink = (value) => {
+      if (output === void 0) {
+        output = value;
+        return;
+      }
+      const prior = normalizePrepareProse(output) ?? "";
+      const next = normalizePrepareProse(value) ?? "";
+      const merged = [prior, next].filter((part) => part.trim() !== "").join("\n\n");
+      output = { prose: merged };
+    };
+    const { soul, routePlaybook, helpContext, help, activeSession } = materialsBundle ?? await loadMaterialsAndSession(invocationId);
+    const publicSettlementHistory = activeSession.entries().filter((entry) => exactRecord3(entry) && entry.type === "custom" && entry.customType === SETTLEMENT_ENTRY && exactRecord3(entry.data)).map((entry) => entry.data);
     const projection = {
       subjectKey,
       subject,
       authority,
       currentRole: { role: options.role, phase: options.phase },
       ...boundSettlement === void 0 ? {} : { currentSettlement: boundSettlement },
-      priorRoute: exactRecord2(prior) && Array.isArray(prior.route) && prior.route.every((target) => targetIsValid(target)) ? prior.route.map((target) => ({ role: target.role, phase: target.phase })) : null,
       publicSettlementHistory,
       liveRoleHelp: help
     };
     activeSession.appendEntry(CONTEXT_ENTRY, projection);
-    const request = [
-      "\u672C\u6B21\u5BFC\u822A\u6750\u6599\u5982\u4E0B\uFF1A",
+    const request = boundSettlement === void 0 ? [
+      "\u672C\u8F6E\u4E3A\u5F85\u547D\u8F6E\u3002",
+      `<navigator_soul>
+${soul}
+</navigator_soul>`,
+      ...routePlaybookReadFailure === void 0 ? [`<route_playbook>
+${routePlaybook}
+</route_playbook>`] : ["\u53EF\u9009\u8DEF\u7EBF\u624B\u518C\u672A\u80FD\u8BFB\u53D6\u3002"],
+      `<work_subject>
+${subject}
+</work_subject>`,
+      `<controlling_authority>
+${authority}
+</controlling_authority>`,
+      `<current_role>
+${JSON.stringify({ role: options.role, phase: options.phase })}
+</current_role>`,
+      `<public_settlement_history>
+${JSON.stringify(projection.publicSettlementHistory)}
+</public_settlement_history>`,
+      `<live_role_help>
+${helpContext}
+</live_role_help>`
+    ].join("\n\n") : [
+      "\u672C\u8F6E\u4E3A\u7ED3\u7B97\u6295\u5582\u8F6E\u3002",
       `<navigator_soul>
 ${soul}
 </navigator_soul>`,
@@ -23627,12 +24628,9 @@ ${authority}
       `<current_role>
 ${JSON.stringify({ role: options.role, phase: options.phase })}
 </current_role>`,
-      ...boundSettlement === void 0 ? [] : [`<current_settlement>
+      `<current_settlement>
 ${JSON.stringify(boundSettlement)}
-</current_settlement>`],
-      `<prior_route>
-${JSON.stringify(prior ?? null)}
-</prior_route>`,
+</current_settlement>`,
       `<public_settlement_history>
 ${JSON.stringify(projection.publicSettlementHistory)}
 </public_settlement_history>`,
@@ -23673,33 +24671,47 @@ ${helpContext}
           if (deliveryRequest && output === void 0) delivery.recordDeliveryRequest();
         };
         await promptAllowingRejectedPrepare(request, false);
-        while (output === void 0 && delivery.nextAction() === "request-delivery") {
-          await promptAllowingRejectedPrepare(RECEIPT_DELIVERY_PROMPT, true);
-        }
-        if (output === void 0 && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === void 0) {
-          const facts = delivery.facts({ runPointer: activeSession.recordPointer(), attemptPointer: invocationId });
-          activeSession.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
-          preparationNoReceipt = true;
-          candidates = [];
-          return candidates;
+        if (boundSettlement !== void 0) {
+          while (output === void 0 && prepareBatchRejected && delivery.nextAction() === "request-delivery") {
+            await promptAllowingRejectedPrepare(RECEIPT_DELIVERY_PROMPT, true);
+          }
+          if (output === void 0 && delivery.nextAction() === "request-delivery") {
+            while (delivery.nextAction() === "request-delivery") {
+              delivery.recordDeliveryRequest();
+            }
+          }
+          if (output === void 0 && delivery.nextAction() === "no-receipt" && activeSession.providerFailure?.() === void 0) {
+            const facts = delivery.facts({ runPointer: activeSession.recordPointer(), attemptPointer: invocationId });
+            activeSession.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+            preparedProse = void 0;
+            return void 0;
+          }
         }
       } catch (error) {
         throw error instanceof NavigatorUnavailableError ? error : navigatorUnavailableError("transport", error);
       }
       if (output === void 0) {
+        if (boundSettlement === void 0) {
+          preparedProse = void 0;
+          return void 0;
+        }
         const nativeFailure = [...activeSession.entries()].reverse().find((entry) => {
-          if (!exactRecord2(entry) || entry.type !== "message" || !exactRecord2(entry.message)) return false;
+          if (!exactRecord3(entry) || entry.type !== "message" || !exactRecord3(entry.message)) return false;
           return entry.message.role === "assistant" && typeof entry.message.errorMessage === "string" && entry.message.errorMessage.trim() !== "";
         });
-        const nativeMessage = exactRecord2(nativeFailure) && exactRecord2(nativeFailure.message) ? nativeFailure.message : void 0;
+        const nativeMessage = exactRecord3(nativeFailure) && exactRecord3(nativeFailure.message) ? nativeFailure.message : void 0;
         const errorMessage = nativeMessage !== void 0 && typeof nativeMessage.errorMessage === "string" ? nativeMessage.errorMessage : "Navigator did not submit direction advice";
         const providerFailure = activeSession.providerFailure?.();
         const source = providerFailure?.source ?? "unknown";
         const cause = providerFailure?.cause ?? source;
         throw navigatorUnavailableError(source, errorMessage, cause);
       }
-      candidates = normalizePrepareOutput(output);
-      return candidates;
+      if (boundSettlement === void 0) {
+        preparedProse = void 0;
+        return void 0;
+      }
+      preparedProse = normalizePrepareProse(output);
+      return preparedProse;
     } finally {
       outputSink = void 0;
     }
@@ -23710,7 +24722,6 @@ ${helpContext}
       if (next.subjectKey !== subjectKey && session !== void 0) {
         const previous = session;
         session = void 0;
-        previousRoute = void 0;
         closing = previous.dispose();
       }
       subjectKey = next.subjectKey;
@@ -23732,13 +24743,16 @@ ${helpContext}
     prepare() {
       if (disposed || preparation !== void 0) return;
       preparationFailure = void 0;
-      preparation = prepare();
+      preparationInFlight = true;
+      preparation = prepare().finally(() => {
+        preparationInFlight = false;
+      });
       void preparation.catch((error) => {
         preparationFailure = error;
       });
     },
     isPreparing() {
-      return preparation !== void 0 || sessionReady !== void 0;
+      return preparationInFlight;
     },
     knownRoutePlaybookReadFailure() {
       return routePlaybookReadFailure;
@@ -23762,81 +24776,70 @@ ${helpContext}
     if (disposed) return;
     const invocationId = activeInvocationId ?? invocationPrincipal;
     let report;
-    if (settlement.kind === "human_decision" || settlement.kind === "role_infrastructure_failure") {
-      if (sessionReady !== void 0) {
-        try {
-          await sessionReady;
-        } catch (error) {
-          preparationFailure ??= error;
-        }
+    if (sessionReady !== void 0) {
+      try {
+        await sessionReady;
+      } catch (error) {
+        preparationFailure ??= error;
       }
-      if (preparation !== void 0) {
-        try {
-          await preparation;
-        } catch (error) {
-          preparationFailure ??= error;
-        }
+    }
+    if (preparation !== void 0) {
+      try {
+        await preparation;
+      } catch (error) {
+        preparationFailure ??= error;
       }
-      session?.appendEntry(SETTLEMENT_ENTRY, { invocationId, subjectKey, role: settlement.role, phase: settlement.phase, kind: settlement.kind, ...settlement.kind === "human_decision" ? { status: settlement.status } : {} });
+      preparation = void 0;
+    }
+    const settlementFact = {
+      invocationId,
+      subjectKey,
+      role: settlement.role,
+      phase: settlement.phase,
+      kind: settlement.kind,
+      ..."status" in settlement && settlement.status !== void 0 ? { status: settlement.status } : {}
+    };
+    let drainedProse;
+    if (settlement.kind === "arrival") {
+      session?.appendEntry(SETTLEMENT_ENTRY, settlementFact);
       if (preparationFailure !== void 0) {
         report = unavailable(invocationId, preparationFailure);
       } else {
-        report = { disposition: "no-advice" };
+        report = {
+          disposition: "arrival",
+          ...settlement.message === void 0 ? {} : { arrivalMessage: settlement.message }
+        };
       }
-    } else if (settlement.kind === "arrival") {
-      if (sessionReady !== void 0) {
+    } else {
+      if (session !== void 0) preparationFailure = void 0;
+      let coldMaterials;
+      if (session === void 0 && preparationFailure === void 0) {
         try {
-          await sessionReady;
+          coldMaterials = await loadMaterialsAndSession(invocationId);
         } catch (error) {
-          preparationFailure ??= error;
+          preparationFailure = error;
         }
       }
-      if (preparation !== void 0) {
+      session?.appendEntry(SETTLEMENT_ENTRY, settlementFact);
+      if (preparationFailure === void 0) {
+        prepareBoundSettlement = settlement;
+        preparation = prepare(coldMaterials);
+        void preparation.catch((error) => {
+          preparationFailure = error;
+        });
         try {
-          await preparation;
+          drainedProse = await preparation;
         } catch (error) {
           preparationFailure ??= error;
         }
+        preparation = void 0;
       }
-      report = preparationFailure === void 0 ? { disposition: "arrival", ...settlement.message === void 0 ? {} : { arrivalMessage: settlement.message } } : unavailable(invocationId, preparationFailure);
-    } else if (preparation === void 0) {
-      report = unavailable(invocationId, "Navigator preparation did not start");
-    } else {
-      try {
-        if (sessionReady !== void 0) await sessionReady;
-        let prepared = await preparation;
-        session?.appendEntry(SETTLEMENT_ENTRY, { invocationId, subjectKey, role: settlement.role, phase: settlement.phase, kind: settlement.kind, ...settlement.status === void 0 ? {} : { status: settlement.status } });
-        let selected = selectNavigatorCandidate(prepared, settlement);
-        if (selected?.candidate.next !== void 0 && !selected.matchedToSettlement) {
-          if (disposed) return;
-          prepareBoundSettlement = settlement;
-          prepared = await prepare();
-          if (disposed) return;
-          selected = selectNavigatorCandidate(prepared, settlement);
-        }
-        const selectedCandidate = selected?.candidate;
-        if (selectedCandidate?.next === void 0 && preparationNoReceipt) {
-          report = { disposition: "no-advice" };
-        } else if (selectedCandidate?.next === void 0) {
-          throw new Error("Navigator prepared no machine-usable next direction");
-        } else {
-          const selectedRoute = selectedCandidate.route;
-          const routeChanged = selectedRoute !== void 0 && !routeEqual(previousRoute, selectedRoute);
-          const command = typeof selectedCandidate.command === "string" && selectedCandidate.command.trim() !== "" ? selectedCandidate.command : renderPublicAkRoleCommand(selectedCandidate.next);
-          report = {
-            disposition: "recommendation",
-            ...routeChanged ? { route: selectedRoute } : {},
-            next: selectedCandidate.next,
-            ...selectedCandidate.reason === void 0 ? {} : { reason: selectedCandidate.reason },
-            ...command === void 0 ? {} : { command }
-          };
-          if (selectedRoute !== void 0) {
-            previousRoute = selectedRoute;
-            session?.appendEntry(ROUTE_ENTRY, { invocationId, subjectKey, route: selectedRoute });
-          }
-        }
-      } catch (error) {
-        report = unavailable(invocationId, error);
+      if (preparationFailure !== void 0) {
+        report = unavailable(invocationId, preparationFailure);
+      } else if (typeof drainedProse === "string" && drainedProse.trim() !== "") {
+        report = { disposition: "advice", prose: drainedProse };
+      } else {
+        report = { disposition: "no-advice" };
       }
     }
     await routePlaybookSettlement;
@@ -23850,10 +24853,7 @@ ${helpContext}
       role: options.role,
       phase: options.phase,
       subjectKey,
-      ...report.route === void 0 ? {} : { route: report.route },
-      ...report.next === void 0 ? {} : { next: report.next },
-      ...report.reason === void 0 ? {} : { reason: report.reason },
-      ...report.command === void 0 ? {} : { command: report.command },
+      ...report.prose === void 0 ? {} : { prose: report.prose },
       ...report.unavailableReason === void 0 ? {} : { unavailableReason: report.unavailableReason },
       ...report.unavailableSource === void 0 ? {} : { unavailableSource: report.unavailableSource },
       ...report.unavailableCause === void 0 ? {} : { unavailableCause: report.unavailableCause },
@@ -23869,9 +24869,8 @@ ${helpContext}
     }
     preparation = void 0;
     sessionReady = void 0;
-    candidates = void 0;
+    preparedProse = void 0;
     preparationFailure = void 0;
-    preparationNoReceipt = false;
     routePlaybookSettlement = void 0;
     routePlaybookReadFailure = void 0;
   }
@@ -24010,7 +25009,7 @@ var reviewerAmendmentsSchema = Type24.Object({
   }))
 }, {
   additionalProperties: true,
-  description: "\u6240\u9009 lens \u7684 amendments \u627F\u8F7D candidates\u3001\u9010\u6761\u5904\u7F6E\u4E0E verdict \u7684\u5B8C\u6574\u62A5\u544A\uFF08\u975E\u4EC5 verdict \u884C\uFF09\uFF1B\u672A\u9009 lens \u53EF\u7701\u7565\u3002hard-stop\uFF0Fusage error \u4E3A refused \u65F6\uFF0C\u5DF2\u4EA7\u51FA\u62A5\u544A\u4ECD\u7167\u5F55\u8FDB\u6240\u9009 lens \u5B57\u6BB5\u3002\u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\u3002"
+  description: "\u5DF2\u8FD0\u884C lens \u7684 amendments \u627F\u8F7D candidates\u3001\u9010\u6761\u5904\u7F6E\u4E0E verdict \u7684\u5B8C\u6574\u62A5\u544A\uFF08\u975E\u4EC5 verdict \u884C\uFF09\uFF1B\u663E\u5F0F\u5355\u8F74\u65F6\u53E6\u4E00\u8F74\u53EF\u7701\u7565\u3002hard-stop\uFF0Fusage error \u4E3A refused \u65F6\uFF0C\u5DF2\u4EA7\u51FA\u62A5\u544A\u4ECD\u7167\u5F55\u5BF9\u5E94 lens \u5B57\u6BB5\u3002\u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\u3002"
 });
 var REVIEWER_STATUS_DESCRIPTION = "completed | refused \u2014 \u5F62\u72B6\u6307\u5F15\uFF0C\u975E schema \u95F8\u3002\u4E24\u79CD\u6B63\u5E38 lens verdict\uFF08completeness / correctness\uFF09\u5747 completed\uFF1Bhard-stop \u4E0E usage error \u4E3A refused\uFF08\u5DF2\u4EA7\u51FA\u62A5\u544A\u4ECD\u7167\u5F55\u8FDB\u6240\u9009 lens amendments\uFF09\u3002";
 var reviewerOutputVariants = Type24.Union([
@@ -24086,7 +25085,7 @@ init_submission_errors();
 init_submission_errors();
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync12, lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync5, rmdirSync, rmSync } from "node:fs";
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
@@ -24135,7 +25134,7 @@ function escapeGitConfigValueRegex(value) {
 function unsetOwnedHooksPath(file) {
   const owned = [];
   for (const value of tryGetAll(file, "core.hooksPath")) {
-    if (!ownedHook(resolve17(value, HOOK_FILE))) continue;
+    if (!ownedHook(resolve18(value, HOOK_FILE))) continue;
     try {
       gitFile(file, [
         "--unset-all",
@@ -24150,15 +25149,15 @@ function unsetOwnedHooksPath(file) {
   return owned;
 }
 function rmOwnedDir(dir) {
-  const hookPath = resolve17(dir, HOOK_FILE);
+  const hookPath = resolve18(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
   rmSync(hookPath, { force: true });
   if (existsSync12(dir) && readdirSync3(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
-  const root = resolve17(commonDir, "worktrees");
+  const root = resolve18(commonDir, "worktrees");
   if (!existsSync12(root)) return [];
-  return readdirSync3(root).map((name) => resolve17(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
+  return readdirSync3(root).map((name) => resolve18(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
   let inside;
@@ -24172,14 +25171,14 @@ function uninstallPackageWorkerHooks(cwd) {
   const clear = (configFile) => {
     for (const hooks of unsetOwnedHooksPath(configFile)) rmOwnedDir(hooks);
   };
-  clear(resolve17(commonDir, "config"));
-  clear(resolve17(commonDir, "config.worktree"));
-  rmOwnedDir(resolve17(commonDir, HOOKS_DIR));
-  const legacy = resolve17(commonDir, "hooks", HOOK_FILE);
+  clear(resolve18(commonDir, "config"));
+  clear(resolve18(commonDir, "config.worktree"));
+  rmOwnedDir(resolve18(commonDir, HOOKS_DIR));
+  const legacy = resolve18(commonDir, "hooks", HOOK_FILE);
   if (ownedHook(legacy)) rmSync(legacy, { force: true });
   for (const gitDir of linkedGitDirs(commonDir)) {
-    clear(resolve17(gitDir, "config.worktree"));
-    rmOwnedDir(resolve17(gitDir, HOOKS_DIR));
+    clear(resolve18(gitDir, "config.worktree"));
+    rmOwnedDir(resolve18(gitDir, HOOKS_DIR));
   }
 }
 function isRecord13(value) {
@@ -24224,11 +25223,11 @@ function reliableWindow(cwd, baseline, head) {
   const raw = git2(cwd, ["log", "--format=%P%x1e%s", range]);
   if (raw.length === 0) return [];
   return raw.split("\n").flatMap((line2) => {
-    const sep6 = line2.indexOf("");
-    if (sep6 < 0) return [];
+    const sep7 = line2.indexOf("");
+    if (sep7 < 0) return [];
     return [{
-      subject: line2.slice(sep6 + 1),
-      merge: line2.slice(0, sep6).trim().includes(" ")
+      subject: line2.slice(sep7 + 1),
+      merge: line2.slice(0, sep7).trim().includes(" ")
     }];
   });
 }
@@ -24773,7 +25772,7 @@ var REVIEWER_TRANSPORT_FLAGS = Object.freeze([
   Object.freeze({
     name: "ak-review-lens",
     definition: Object.freeze({
-      description: "Caller-selected single review lens: completeness or correctness",
+      description: "Single review lens: completeness or correctness",
       type: "string"
     })
   }),
@@ -25358,6 +26357,21 @@ function createCountersignRoleRuntime(roleHost, dependencies, hostActions) {
     dependencies
   );
 }
+function lastAssistantProse(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+    const texts = [];
+    for (const part of message.content) {
+      if (part.type === "text" && typeof part.text === "string" && part.text.length > 0) {
+        texts.push(part.text);
+      }
+    }
+    if (texts.length === 0) continue;
+    return texts.join("");
+  }
+  return void 0;
+}
 function createRoleRuntimeExtension(dependencies) {
   return (envelopeHost) => {
     let projectClosedSubmission = async () => {
@@ -25416,10 +26430,6 @@ function createRoleRuntimeExtension(dependencies) {
       if (settlement === void 0 || attendance === void 0) return;
       const workContext = navigatorWorkContext;
       const pending = (async () => {
-        if (settlement.kind !== "accepted") {
-          await attendance.settle(settlement);
-          return;
-        }
         const settlePromise = attendance.settle(settlement);
         void settlePromise.catch(() => void 0);
         const raced = await raceNavigatorGrace(settlePromise, NAVIGATOR_POST_ROLE_GRACE_MS);
@@ -25620,10 +26630,8 @@ function createRoleRuntimeExtension(dependencies) {
         pendingSubmissionNonPassByToolCallId.delete(event.toolCallId);
         return { details: submissionNonPass, isError: true };
       }
-      if (event.isError) return;
-      return;
     });
-    roleHost.on("agent_end", (event, ctx) => {
+    roleHost.on("agent_end", async (event, ctx) => {
       const lastMessage = event.messages.at(-1);
       if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
         if (receiptDelivery.nextAction() !== "accepted") {
@@ -25631,6 +26639,47 @@ function createRoleRuntimeExtension(dependencies) {
         }
         return;
       }
+      const role = selectedRole ?? roleHost.getFlag(ROLE_FLAG.name);
+      if (role === "navigator" && receiptDelivery.nextAction() !== "accepted") {
+        const prose = lastAssistantProse(event.messages);
+        if (prose !== void 0 && prose.trim() !== "") {
+          const accepted = { prose };
+          await sealAcceptedSubmission({
+            context: ctx,
+            role: "navigator",
+            accepted,
+            toolCallId: `navigator-prose-exit:${randomUUID8()}`
+          });
+          await projectClosedSubmission(
+            { role: "navigator", kind: "accepted", accepted },
+            ctx
+          );
+          return;
+        }
+        if (!noReceiptRecorded) {
+          const runPointer = runDirectoryFromHostContext(ctx);
+          if (runPointer !== void 0) {
+            noReceiptRecorded = true;
+            while (receiptDelivery.nextAction() === "request-delivery") {
+              receiptDelivery.recordDeliveryRequest();
+            }
+            const facts = receiptDelivery.facts({ runPointer, attemptPointer: `current:${runPointer}` });
+            envelopeHost.appendEntry(NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, facts);
+            try {
+              sitianReport({
+                level: "event",
+                kind: "no-receipt-lifecycle",
+                cwd: ctx.cwd,
+                sessionParent: ctx.sessionManager.getSessionFile(),
+                payload: facts,
+                source: "role-runtime"
+              });
+            } catch {
+            }
+          }
+        }
+        return;
+      }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
         envelopeHost.appendEntry("ak-receipt-delivery-request");
@@ -26228,11 +27277,11 @@ init_role_activation_flags();
 init_submission_correctable_error();
 init_navigator_invocation_identity();
 async function listen(server, path) {
-  await new Promise((resolve21, reject) => {
+  await new Promise((resolve22, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve21();
+      resolve22();
     });
   });
 }
@@ -26265,10 +27314,10 @@ async function prepareRoleEnvelope(options) {
   let rejection;
   let infrastructureRoundFailure;
   const hostAbort = new AbortController();
-  const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID8();
-  await mkdir6(request.runDirectory, { recursive: true });
+  const runId = request.runDirectory.split("/").filter(Boolean).at(-1) ?? randomUUID9();
+  await mkdir7(request.runDirectory, { recursive: true });
   let sessionFile = options.sessionFile ?? join41(request.runDirectory, "session", "session.jsonl");
-  await mkdir6(dirname22(sessionFile), { recursive: true });
+  await mkdir7(dirname22(sessionFile), { recursive: true });
   if (request.continuation.kind !== "resume") {
     try {
       await writeFile12(
@@ -26287,6 +27336,25 @@ async function prepareRoleEnvelope(options) {
       if (error.code !== "EEXIST") throw error;
     }
   }
+  let durableWriteChain = Promise.resolve();
+  let armDurableWriteFailure;
+  const persistPackageSessionEntry = (entry) => {
+    const customType = typeof entry.customType === "string" ? entry.customType : "unknown";
+    const line2 = `${JSON.stringify({
+      ...entry,
+      id: typeof entry.id === "string" ? entry.id : randomUUID9(),
+      timestamp: typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date()).toISOString()
+    })}
+`;
+    durableWriteChain = durableWriteChain.then(async () => {
+      try {
+        await appendFile3(sessionFile, line2, "utf8");
+      } catch (error) {
+        const diagnostic = error instanceof Error ? error.message : String(error);
+        armDurableWriteFailure?.(customType, diagnostic);
+      }
+    });
+  };
   const context = {
     cwd: request.cwd,
     mode: "print",
@@ -26309,6 +27377,7 @@ async function prepareRoleEnvelope(options) {
         const entry = { type: "custom", customType, data };
         sessionEntries.push(entry);
         customEntries.push({ customType, data });
+        persistPackageSessionEntry(entry);
       }
     },
     abort() {
@@ -26322,6 +27391,7 @@ async function prepareRoleEnvelope(options) {
     const entry = { type: "custom_message", customType, ...payload, message: payload };
     sessionEntries.push(entry);
     customEntries.push({ customType, data: message.details ?? message.content });
+    persistPackageSessionEntry(entry);
   };
   const emit = async (event, value) => {
     const results = [];
@@ -26401,7 +27471,7 @@ async function prepareRoleEnvelope(options) {
     }
   };
   createRoleRuntimeExtension(options.dependencies)(envelope);
-  const token = randomUUID8();
+  const token = randomUUID9();
   const server = createServer((socket) => serveSocket(socket));
   function rememberProjectedRejection(details, toolCallId, content) {
     if (typeof details !== "object" || details === null) return;
@@ -26437,6 +27507,17 @@ async function prepareRoleEnvelope(options) {
     };
     hostAbort.abort();
   }
+  armDurableWriteFailure = (customType, diagnostic) => {
+    rememberInfrastructureFailure(
+      {
+        cause: "infrastructure",
+        kind: "role_infrastructure_failure",
+        code: "durable-session-write-failed",
+        customType
+      },
+      [{ type: "text", text: `ak-role: durable session entry flush failed (${customType}): ${diagnostic}` }]
+    );
+  };
   function declareRoundInfrastructureFailure(error) {
     const diagnostic = error instanceof Error ? error.message : String(error);
     const content = [{ type: "text", text: diagnostic }];
@@ -26482,7 +27563,7 @@ async function prepareRoleEnvelope(options) {
   async function invokeAkTool(name, args) {
     const tool = tools.get(name);
     if (tool === void 0) throw new Error(`Unknown AK tool: ${name}`);
-    const toolCallId = randomUUID8();
+    const toolCallId = randomUUID9();
     calls.push({ toolCallId, toolName: name });
     sessionEntries.push({
       type: "message",
@@ -26598,6 +27679,15 @@ async function prepareRoleEnvelope(options) {
   const relay = fileURLToPath2(new URL("./mcp-relay.mjs", import.meta.url));
   await listen(server, options.socketPath);
   let disposed = false;
+  let durableFailureHandedToCloseRound = false;
+  const settleDurableWrites = async () => {
+    await durableWriteChain;
+    if (infrastructureRoundFailure !== void 0) {
+      durableFailureHandedToCloseRound = true;
+      return { accepted: false, failure: infrastructureRoundFailure };
+    }
+    return void 0;
+  };
   const dispose = async () => {
     if (disposed) return;
     disposed = true;
@@ -26607,11 +27697,25 @@ async function prepareRoleEnvelope(options) {
     } catch (error) {
       cleanupFailures.push(error);
     }
+    try {
+      const alreadyHanded = durableFailureHandedToCloseRound;
+      const durableFailure = await settleDurableWrites();
+      if (durableFailure !== void 0 && !alreadyHanded) {
+        cleanupFailures.push(
+          Object.assign(
+            new Error(durableFailure.failure.diagnostic ?? "durable session entry flush failed"),
+            { code: durableFailure.failure.identity?.code ?? "durable-session-write-failed" }
+          )
+        );
+      }
+    } catch (error) {
+      cleanupFailures.push(error);
+    }
     try {
       const closeAll = server.closeAllConnections;
       if (typeof closeAll === "function") closeAll.call(server);
-      await new Promise((resolve21, reject) => {
-        server.close((error) => error ? reject(error) : resolve21());
+      await new Promise((resolve22, reject) => {
+        server.close((error) => error ? reject(error) : resolve22());
       });
     } catch (error) {
       cleanupFailures.push(error);
@@ -26628,6 +27732,7 @@ async function prepareRoleEnvelope(options) {
     if (calls.some((call) => call.toolName === terminatingToolName)) return;
     await invokeAkTool(terminatingToolName, params ?? {});
   }
+  ;
   const closeRound = async () => {
     if (calls.length > 0) {
       const roundCalls = [...calls];
@@ -26635,6 +27740,7 @@ async function prepareRoleEnvelope(options) {
       await emit("turn_end", { turnIndex: 0, calls: roundCalls });
     }
     if (infrastructureRoundFailure !== void 0) {
+      durableFailureHandedToCloseRound = true;
       return { accepted: false, failure: infrastructureRoundFailure };
     }
     let closure;
@@ -26646,6 +27752,8 @@ async function prepareRoleEnvelope(options) {
     }
     if (closure !== void 0) {
       await emit("agent_settled", {});
+      const durableFailure2 = await settleDurableWrites();
+      if (durableFailure2 !== void 0) return durableFailure2;
       return { accepted: true };
     }
     if (rejection !== void 0) {
@@ -26655,9 +27763,13 @@ async function prepareRoleEnvelope(options) {
         message: rejection.message
       };
       rejection = void 0;
+      const durableFailure2 = await settleDurableWrites();
+      if (durableFailure2 !== void 0) return durableFailure2;
       return { accepted: false, retry };
     }
     await emit("agent_settled", {});
+    const durableFailure = await settleDurableWrites();
+    if (durableFailure !== void 0) return durableFailure;
     return { accepted: true };
   };
   try {
@@ -26743,9 +27855,9 @@ import { readFile as readFile22 } from "node:fs/promises";
 import { join as join42 } from "node:path";
 
 // src/canonical-skill-binding.ts
-import { readFile as readFile20, realpath as realpath7 } from "node:fs/promises";
+import { readFile as readFile20, realpath as realpath8 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname as dirname23, resolve as resolve18 } from "node:path";
+import { dirname as dirname23, resolve as resolve19 } from "node:path";
 import { stripFrontmatter } from "@earendil-works/pi-coding-agent";
 function captureCanonicalSkillExpansion(name, snapshot, configuredPath, evidence, originalRequest) {
   const matchedPath = evidence?.location === configuredPath ? configuredPath : evidence?.location === snapshot.path ? snapshot.path : void 0;
@@ -26768,14 +27880,14 @@ var CanonicalSkillUnavailableError = class extends Error {
   code = "canonical-skill-unavailable";
 };
 async function loadCanonicalSkillBinding(name) {
-  const configuredPath = resolve18(
+  const configuredPath = resolve19(
     homedir(),
     `.agents/skills/${name}/SKILL.md`
   );
   let path;
   let raw;
   try {
-    path = await realpath7(configuredPath);
+    path = await realpath8(configuredPath);
     raw = await readFile20(path, "utf8");
   } catch (error) {
     throw new CanonicalSkillUnavailableError(name, configuredPath, error);
@@ -26816,7 +27928,7 @@ init_doctor_evidence();
 init_doctor_evidence();
 init_host_contracts();
 import { readFile as readFile21 } from "node:fs/promises";
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 init_notary_source_run();
 init_packaged_role_registry();
 init_invocation();
@@ -26824,7 +27936,7 @@ function navigatorInputReference(getFlag, role) {
   if (getFlag === void 0) return void 0;
   const name = packagedRoleInputFlag(role);
   const value = name === void 0 ? void 0 : getFlag(name);
-  return typeof value === "string" && value !== "" ? resolve19(value) : void 0;
+  return typeof value === "string" && value !== "" ? resolve20(value) : void 0;
 }
 async function loadNavigatorWorkContext(options) {
   const reference = navigatorInputReference(options.getFlag, options.role);
@@ -26845,7 +27957,7 @@ async function loadNavigatorWorkContext(options) {
   }
   const publicRunDir = runDirectoryFromHostContext(options.context);
   const currentSessionDir = options.context.sessionManager.getSessionDir();
-  const isBoundPublicRun = publicRunDir !== void 0 && resolve19(currentSessionDir) === resolve19(publicRunDir, "session");
+  const isBoundPublicRun = publicRunDir !== void 0 && resolve20(currentSessionDir) === resolve20(publicRunDir, "session");
   if (options.role === "judge" && isBoundPublicRun) {
     let admitted;
     try {
@@ -26878,9 +27990,9 @@ async function loadNavigatorWorkContext(options) {
   }
   const workRoot = subjectRoot.includes("/.ak/work/") ? subjectRoot : void 0;
   const authorityFiles = workRoot === void 0 ? [] : [
-    resolve19(workRoot, "authority.md"),
-    resolve19(workRoot, "authority.txt"),
-    resolve19(workRoot, "design-v2/owner-direction.md")
+    resolve20(workRoot, "authority.md"),
+    resolve20(workRoot, "authority.txt"),
+    resolve20(workRoot, "design-v2/owner-direction.md")
   ];
   let authorityMaterial;
   for (const path of authorityFiles) {
@@ -27064,7 +28176,7 @@ function hostAbortedError(message = "host aborted") {
 function raceAgainstHostAbort(work, abortSignal, message = "host aborted") {
   if (abortSignal?.aborted) return Promise.reject(hostAbortedError(message));
   if (abortSignal === void 0) return work;
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     let settled = false;
     const onAbort = () => {
       if (settled) return;
@@ -27079,7 +28191,7 @@ function raceAgainstHostAbort(work, abortSignal, message = "host aborted") {
         if (settled) return;
         settled = true;
         abortSignal.removeEventListener("abort", onAbort);
-        resolve21(value);
+        resolve22(value);
       },
       (error) => {
         if (settled) return;
@@ -27171,6 +28283,9 @@ function reportHostSessionEvent(input) {
   });
 }
 
+// src/acp-host/role-turn-host.ts
+init_navigator_output();
+
 // src/agent-start-materials.ts
 function renderAgentStartMaterials(body, materials) {
   if (materials.length === 0) return body;
@@ -27183,7 +28298,42 @@ function renderSystemPromptOverride(authority) {
 }
 
 // src/acp-host/role-turn-host.ts
-function failure(cause, name, code, details) {
+function acpAgentTextChunk(params) {
+  let kind;
+  let content;
+  let textFallback;
+  const nested = params.update;
+  if (typeof nested === "object" && nested !== null && !Array.isArray(nested)) {
+    const record4 = nested;
+    kind = record4.sessionUpdate;
+    content = record4.content;
+    textFallback = record4.text;
+  } else {
+    kind = params.sessionUpdate ?? nested;
+    content = params.content;
+    textFallback = params.text;
+  }
+  if (kind !== "agent_message_chunk" && kind !== "agent_message") return void 0;
+  if (typeof content === "string" && content.length > 0) return content;
+  if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+    const record4 = content;
+    if (typeof record4.text === "string" && record4.text.length > 0) return record4.text;
+  }
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (typeof part === "string" && part.length > 0) parts.push(part);
+      else if (typeof part === "object" && part !== null) {
+        const record4 = part;
+        if (typeof record4.text === "string" && record4.text.length > 0) parts.push(record4.text);
+      }
+    }
+    if (parts.length > 0) return parts.join("");
+  }
+  if (typeof textFallback === "string" && textFallback.length > 0) return textFallback;
+  return void 0;
+}
+function failure(cause, name, code, details, diagnostic) {
   return {
     code: null,
     stderr: "",
@@ -27191,10 +28341,24 @@ function failure(cause, name, code, details) {
     knownFailure: {
       cause,
       identity: { name, code },
+      ...diagnostic === void 0 ? {} : { diagnostic },
       ...details === void 0 ? {} : { details }
     }
   };
 }
+function withCleanupFailure(outcome, cleanupError) {
+  const message = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+  if (outcome.knownFailure === void 0) {
+    return failure("session", "AcpDisposeFailure", "dispose-failed", { cleanupError: message }, message);
+  }
+  return {
+    ...outcome,
+    knownFailure: {
+      ...outcome.knownFailure,
+      details: { ...outcome.knownFailure.details ?? {}, cleanupError: message }
+    }
+  };
+}
 function acpError(code, message, cause) {
   return Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), { code });
 }
@@ -27267,8 +28431,8 @@ function connectAcpStdio(options) {
     request(method, params) {
       if (closed) return Promise.reject(terminalError ?? acpError("acp-connection-closed", "ACP connection is closed"));
       const id = ++nextId;
-      return new Promise((resolve21, reject) => {
-        pending.set(id, { resolve: resolve21, reject });
+      return new Promise((resolve22, reject) => {
+        pending.set(id, { resolve: resolve22, reject });
         child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `, (error) => {
           if (error === null || error === void 0) return;
@@ -27295,7 +28459,7 @@ function connectAcpStdio(options) {
       settleClosed(acpError("acp-connection-closed", "ACP connection is closed"));
       child.stdin.end();
       child.kill("SIGTERM");
-      await new Promise((resolve21) => child.once("close", () => resolve21()));
+      await new Promise((resolve22) => child.once("close", () => resolve22()));
     }
   });
 }
@@ -27306,137 +28470,168 @@ function createAcpRoleTurnHost(config) {
     let connection;
     let sessionId;
     let accepted = false;
+    let outcome = failure("session", "AcpNoOutcome", "no-outcome");
     try {
       if (prepared.mcpServers.length === 0) {
-        return failure("activation", "UncontrolledAcpSession", "ak-config-missing");
-      }
-      connection = await config.connect(request);
-      const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
-      const recordAbort = new AbortController();
-      let hostSessionRecordFailure;
-      const hostSessionRecordResult = () => ({
-        code: null,
-        stderr: "",
-        timedOut: false,
-        knownFailure: hostSessionRecordFailure
-      });
-      const noteHostSessionRecordFailure = (error) => {
-        if (hostSessionRecordFailure !== void 0) return;
-        hostSessionRecordFailure = {
-          cause: "session",
-          identity: { name: "HostSessionRecordFailure", code: "host-session-record-failed" },
-          diagnostic: error instanceof Error ? error.message : String(error)
-        };
-        try {
-          recordAbort.abort();
-        } catch {
-        }
-      };
-      const rpc = (method, params) => raceAgainstHostAbort(connection.request(method, params), recordAbort.signal, "host-session-record-failed");
-      connection.onNotification?.((method, params) => {
-        if (method !== "session/update" || hostSessionRecordFailure !== void 0) return;
-        try {
-          reportHostSessionEvent({
-            host: config.hostName,
-            cwd: request.cwd,
-            sessionParent,
-            source: "acp-host",
-            event: { method, params }
-          });
-        } catch (error) {
-          noteHostSessionRecordFailure(error);
-        }
-      });
-      try {
-        const initialized = await rpc("initialize", {
-          protocolVersion: 1,
-          clientCapabilities: {}
+        outcome = failure("activation", "UncontrolledAcpSession", "ak-config-missing");
+      } else {
+        connection = await config.connect(request);
+        const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+        const recordAbort = new AbortController();
+        let hostSessionRecordFailure;
+        const hostSessionRecordResult = () => ({
+          code: null,
+          stderr: "",
+          timedOut: false,
+          knownFailure: hostSessionRecordFailure
         });
-        const initializeMeta = initialized._meta;
-        const availableModels = Array.isArray(initializeMeta?.modelState?.availableModels) ? initializeMeta.modelState.availableModels : void 0;
-        if (request.model !== void 0 && availableModels !== void 0 && !availableModels.some((entry) => typeof entry === "object" && entry !== null && entry.modelId === acpModelId(config.modelPassing, request.model))) {
-          return failure("activation", "AcpHostModelMismatch", "host-model-mismatch", {
-            provider: request.model.provider,
-            model: request.model.model
-          });
-        }
-        const sessionBindParams = {
-          cwd: request.cwd,
-          mcpServers: prepared.mcpServers,
-          _meta: { systemPromptOverride, yoloMode: false }
-        };
-        const loadSession = async (bindSessionId) => {
-          const loaded = await rpc("session/load", {
-            sessionId: bindSessionId,
-            ...sessionBindParams
-          });
-          return typeof loaded.sessionId === "string" && loaded.sessionId !== "" ? loaded.sessionId : bindSessionId;
+        const noteHostSessionRecordFailure = (error) => {
+          if (hostSessionRecordFailure !== void 0) return;
+          hostSessionRecordFailure = {
+            cause: "session",
+            identity: { name: "HostSessionRecordFailure", code: "host-session-record-failed" },
+            diagnostic: error instanceof Error ? error.message : String(error)
+          };
+          try {
+            recordAbort.abort();
+          } catch {
+          }
         };
-        if (request.continuation.kind === "resume" && config.boundResume === "session/load") {
-          const boundSessionId = await config.sessionIdentity.load(request.principal);
-          if (boundSessionId !== void 0 && boundSessionId !== "") {
-            sessionId = await loadSession(boundSessionId);
+        const rpc = (method, params) => raceAgainstHostAbort(connection.request(method, params), recordAbort.signal, "host-session-record-failed");
+        const agentProseChunks = [];
+        let collectAgentProse = false;
+        connection.onNotification?.((method, params) => {
+          if (method !== "session/update" || hostSessionRecordFailure !== void 0) return;
+          if (collectAgentProse) {
+            const chunk = acpAgentTextChunk(params);
+            if (chunk !== void 0) agentProseChunks.push(chunk);
           }
-        }
-        if (sessionId === void 0) {
-          const session = await rpc("session/new", sessionBindParams);
-          sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
-          if (sessionId === void 0 || sessionId === "") {
-            return failure("session", "AcpSessionFailure", "session-id-missing");
+          try {
+            reportHostSessionEvent({
+              host: config.hostName,
+              cwd: request.cwd,
+              sessionParent,
+              source: "acp-host",
+              event: { method, params }
+            });
+          } catch (error) {
+            noteHostSessionRecordFailure(error);
           }
-          await config.sessionIdentity.bind(request.principal, sessionId);
-        }
-        if (config.modelPassing === "set_model" && request.model !== void 0 && sessionId !== void 0) {
-          await rpc("session/set_model", {
-            sessionId,
-            modelId: acpModelId(config.modelPassing, request.model)
+        });
+        try {
+          const initialized = await rpc("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {}
           });
-          sessionId = await loadSession(sessionId);
-        }
-        const activeConnection = connection;
-        const activeSessionId = sessionId;
-        const turnResult = await driveExternalRoleTurnRounds(prepared, request, {
-          roundLimitName: "AcpRoundLimit",
-          currentSessionId: () => sessionId,
-          async runRound({ prompt, abortSignal }) {
-            if (hostSessionRecordFailure !== void 0) return { status: "terminal", result: hostSessionRecordResult() };
-            const abortParts = [recordAbort.signal];
-            if (abortSignal !== void 0) abortParts.push(abortSignal);
-            const combinedAbort = AbortSignal.any(abortParts);
-            let result;
-            try {
-              result = await raceAgainstHostAbort(
-                activeConnection.request("session/prompt", {
-                  sessionId: activeSessionId,
-                  prompt: [{ type: "text", text: prompt }]
-                }),
-                combinedAbort,
-                "ACP host aborted"
-              );
-            } catch (error) {
-              if (hostSessionRecordFailure !== void 0) {
-                return { status: "terminal", result: hostSessionRecordResult() };
+          const initializeMeta = initialized._meta;
+          const availableModels = Array.isArray(initializeMeta?.modelState?.availableModels) ? initializeMeta.modelState.availableModels : void 0;
+          if (request.model !== void 0 && availableModels !== void 0 && !availableModels.some((entry) => typeof entry === "object" && entry !== null && entry.modelId === acpModelId(config.modelPassing, request.model))) {
+            outcome = failure("activation", "AcpHostModelMismatch", "host-model-mismatch", {
+              provider: request.model.provider,
+              model: request.model.model
+            });
+          } else {
+            const sessionBindParams = {
+              cwd: request.cwd,
+              mcpServers: prepared.mcpServers,
+              _meta: { systemPromptOverride, yoloMode: false }
+            };
+            const loadSession = async (bindSessionId) => {
+              const loaded = await rpc("session/load", {
+                sessionId: bindSessionId,
+                ...sessionBindParams
+              });
+              return typeof loaded.sessionId === "string" && loaded.sessionId !== "" ? loaded.sessionId : bindSessionId;
+            };
+            if (request.continuation.kind === "resume" && config.boundResume === "session/load") {
+              const boundSessionId = await config.sessionIdentity.load(request.principal);
+              if (boundSessionId !== void 0 && boundSessionId !== "") {
+                sessionId = await loadSession(boundSessionId);
               }
-              throw error;
             }
-            if (result.stopReason === "refusal") {
-              return {
-                status: "terminal",
-                result: failure("output", "AcpRefusal", "refusal", { sessionId })
-              };
+            let sessionReady = true;
+            if (sessionId === void 0) {
+              const session = await rpc("session/new", sessionBindParams);
+              sessionId = typeof session.sessionId === "string" ? session.sessionId : void 0;
+              if (sessionId === void 0 || sessionId === "") {
+                outcome = failure("session", "AcpSessionFailure", "session-id-missing");
+                sessionReady = false;
+              } else {
+                await config.sessionIdentity.bind(request.principal, sessionId);
+              }
+            }
+            if (sessionReady) {
+              if (config.modelPassing === "set_model" && request.model !== void 0 && sessionId !== void 0) {
+                await rpc("session/set_model", {
+                  sessionId,
+                  modelId: acpModelId(config.modelPassing, request.model)
+                });
+                sessionId = await loadSession(sessionId);
+              }
+              const activeConnection = connection;
+              const activeSessionId = sessionId;
+              const turnResult = await driveExternalRoleTurnRounds(prepared, request, {
+                roundLimitName: "AcpRoundLimit",
+                currentSessionId: () => sessionId,
+                async runRound({ prompt, abortSignal }) {
+                  if (hostSessionRecordFailure !== void 0) return { status: "terminal", result: hostSessionRecordResult() };
+                  const abortParts = [recordAbort.signal];
+                  if (abortSignal !== void 0) abortParts.push(abortSignal);
+                  const combinedAbort = AbortSignal.any(abortParts);
+                  let result;
+                  agentProseChunks.length = 0;
+                  collectAgentProse = prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME;
+                  try {
+                    result = await raceAgainstHostAbort(
+                      activeConnection.request("session/prompt", {
+                        sessionId: activeSessionId,
+                        prompt: [{ type: "text", text: prompt }]
+                      }),
+                      combinedAbort,
+                      "ACP host aborted"
+                    );
+                  } catch (error) {
+                    collectAgentProse = false;
+                    agentProseChunks.length = 0;
+                    if (hostSessionRecordFailure !== void 0) {
+                      return { status: "terminal", result: hostSessionRecordResult() };
+                    }
+                    throw error;
+                  }
+                  collectAgentProse = false;
+                  if (result.stopReason === "refusal") {
+                    agentProseChunks.length = 0;
+                    return {
+                      status: "terminal",
+                      result: failure("output", "AcpRefusal", "refusal", { sessionId })
+                    };
+                  }
+                  if (prepared.terminatingToolName === NAVIGATOR_OUTPUT_TOOL_NAME) {
+                    const prose = agentProseChunks.join("");
+                    agentProseChunks.length = 0;
+                    if (navigatorProseFromUnknown(prose) !== void 0) {
+                      await prepared.ingestStructuredOutput({ prose });
+                    }
+                  } else {
+                    agentProseChunks.length = 0;
+                  }
+                  return { status: "delivered", stderr: activeConnection.stderr?.() ?? "" };
+                },
+                async afterAccepted() {
+                  await rpc("session/close", { sessionId: activeSessionId });
+                  accepted = true;
+                }
+              });
+              outcome = hostSessionRecordFailure !== void 0 ? hostSessionRecordResult() : turnResult;
             }
-            return { status: "delivered", stderr: activeConnection.stderr?.() ?? "" };
-          },
-          async afterAccepted() {
-            await rpc("session/close", { sessionId: activeSessionId });
-            accepted = true;
           }
-        });
-        if (hostSessionRecordFailure !== void 0) return hostSessionRecordResult();
-        return turnResult;
-      } catch (error) {
-        if (hostSessionRecordFailure !== void 0) return hostSessionRecordResult();
-        throw error;
+        } catch (error) {
+          if (hostSessionRecordFailure !== void 0) {
+            outcome = hostSessionRecordResult();
+          } else {
+            throw error;
+          }
+        }
       }
     } finally {
       if (connection !== void 0) {
@@ -27453,16 +28648,18 @@ function createAcpRoleTurnHost(config) {
       }
       try {
         await prepared.dispose?.();
-      } catch {
+      } catch (cleanupError) {
+        outcome = withCleanupFailure(outcome, cleanupError);
       }
     }
+    return outcome;
   });
 }
 
 // src/acp-host/seat-profile-soul.ts
 import { constants as constants3 } from "node:fs";
-import { access as access4, copyFile, lstat as lstat8, mkdir as mkdir7, readlink as readlink2, symlink as symlink2, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname25, join as join44, relative as relative3, resolve as resolve20 } from "node:path";
+import { access as access4, copyFile, lstat as lstat8, mkdir as mkdir8, readlink as readlink2, symlink as symlink2, unlink as unlink3 } from "node:fs/promises";
+import { dirname as dirname25, join as join44, relative as relative4, resolve as resolve21 } from "node:path";
 function seatProfileName(spec, role) {
   return `${spec.namePrefix}${role}`;
 }
@@ -27480,7 +28677,7 @@ async function pathExists2(path) {
 async function ensureSeatProfileSoul(options) {
   const { spec, operatorHome, packageRoot, role } = options;
   const profileName = seatProfileName(spec, role);
-  const soulTarget = resolve20(packageRoleSoulPath(packageRoot, role));
+  const soulTarget = resolve21(packageRoleSoulPath(packageRoot, role));
   if (!await pathExists2(soulTarget)) {
     throw new Error(`packaged role soul missing: ${soulTarget}`);
   }
@@ -27489,16 +28686,16 @@ async function ensureSeatProfileSoul(options) {
   const hostRoot = dirname25(profilesRoot);
   const soulPath = join44(profileDir, spec.soulFileName);
   if (!await pathExists2(profileDir)) {
-    await mkdir7(profileDir, { recursive: true });
+    await mkdir8(profileDir, { recursive: true });
     for (const name of ["auth.json", ".env", "config.yaml"]) {
       const source = join44(hostRoot, name);
       if (!await pathExists2(source)) continue;
       await copyFile(source, join44(profileDir, name));
     }
   } else {
-    await mkdir7(profileDir, { recursive: true });
+    await mkdir8(profileDir, { recursive: true });
   }
-  const desiredLink = relative3(profileDir, soulTarget);
+  const desiredLink = relative4(profileDir, soulTarget);
   let current;
   try {
     const st = await lstat8(soulPath);
@@ -27526,7 +28723,7 @@ function createComposedAcpRoleTurnHost(config) {
       request,
       dependencies: config.roleRuntimeDependencies,
       sessionFile: config.sessionIdentity.resolveSessionFile(request.principal),
-      socketPath: config.socketPath?.(request) ?? `/tmp/ak-acp-mcp-${randomUUID9()}.sock`
+      socketPath: config.socketPath?.(request) ?? `/tmp/ak-acp-mcp-${randomUUID10()}.sock`
     })
   });
 }