@akagilnc/pi-workflow-roles 0.1.5775 → 0.1.5805

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

@@ -711,6 +711,12 @@ function appendSitianRecordBlock(input, block) {
 function resolveSitianVolumeCategory(kind) {
   return kind;
 }
+function runDirectoryOwningSessionParent(sessionParentDir) {
+  if (basename3(sessionParentDir) !== "session") return void 0;
+  const runDirectory = dirname3(sessionParentDir);
+  if (parseRunLeaf(basename3(runDirectory)) === void 0) return void 0;
+  return runDirectory;
+}
 function sitianVolumeDirectory(sessionDirectory, category) {
   return join3(sessionDirectory, category);
 }
@@ -742,8 +748,8 @@ function resolveSitianRecordPathInLedger(input, ledgerHome) {
       throw new Error("Sitian record ownership requires a parent session inside the ledger home");
     }
     const sessionParentDir = dirname3(input.sessionParent);
-    const runDirectory = dirname3(sessionParentDir);
-    if (basename3(sessionParentDir) === "session" && parseRunLeaf(basename3(runDirectory)) !== void 0) {
+    const runDirectory = runDirectoryOwningSessionParent(sessionParentDir);
+    if (runDirectory !== void 0) {
       sessionDir = runDirectory;
       recordFile = join3(runDirectory, RUN_HISTORY_KINDS.has(input.kind) ? RUN_HISTORY_FILE : RUN_STATE_KINDS.has(input.kind) ? RUN_STATE_FILE : RUN_LOG_FILE);
     } else {
@@ -976,7 +982,9 @@ function render(runDirectory, history, state, log, unreadable) {
       original = payload.landingPath;
     }
   }
-  if (typeof original === "string") original = join4(runDirectory, "session", basename4(original));
+  if (typeof original === "string") {
+    original = join4(sessionDirectoryOf(runDirectory), basename4(original));
+  }
   whole.host = { sessions, ...original === void 0 ? {} : { original } };
   whole.submission = latest === void 0 ? {} : { latest };
   if (Object.keys(unreadable).length > 0) whole.unreadable = unreadable;
@@ -1214,6 +1222,16 @@ function parseRunLeaf(name) {
   if (at <= 0 || at === name.length - 1) return void 0;
   return { runId: name.slice(0, at), role: name.slice(at + 1) };
 }
+function subjectDirectoryOfRun(runDirectory) {
+  const runsParent = dirname4(runDirectory);
+  if (basename5(runsParent) !== "runs") return void 0;
+  const subjectDirectory = dirname4(runsParent);
+  const subjectName = basename5(subjectDirectory);
+  if (subjectName === "unbound" || /^[1-9]\d*$/.test(subjectName)) {
+    return subjectDirectory;
+  }
+  return void 0;
+}
 function sessionDirectoryOf(runDirectory) {
   return join6(runDirectory, "session");
 }
@@ -1306,6 +1324,7 @@ function ensureRoleRunDirectory(ledgerHome, directory) {
   return ensureRealDirectoryTree(ledgerHome, directory);
 }
 function ensureRoleRunPlacement(ledgerHome, placement) {
+  ensureRoleRunDirectory(ledgerHome, placement.runDirectory);
   ensureRoleRunDirectory(ledgerHome, placement.sessionDirectory);
 }
 var ROLE_RUN_SESSION_FILENAME;
@@ -1406,18 +1425,29 @@ async function runEngineDetourOnce(input) {
 function isEngineDetourFailure(result) {
   return result.code !== 0 || result.stdout.trim() === "";
 }
-function engineDetourFailureDiagnostic(result) {
-  if (result.stderr.trim().length > 0) return result.stderr;
-  if (result.stdout.trim() === "") return ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC;
-  const rows = result.stdout.split("\n");
-  let lastRow = "";
-  for (let index = rows.length - 1; index >= 0; index -= 1) {
-    if (rows[index].trim() !== "") {
-      lastRow = rows[index];
-      break;
-    }
+function engineDetourFailureSeatText(result) {
+  const parts = [];
+  if (result.stdout.length > 0) parts.push(result.stdout);
+  if (result.stderr.length > 0) parts.push(result.stderr);
+  let text = "";
+  if (parts.length > 0) {
+    text = parts[0];
+    for (let index = 1; index < parts.length; index += 1) {
+      if (!text.endsWith("\n")) text += "\n";
+      text += parts[index];
+    }
+  }
+  const append = (line2) => {
+    if (text.length > 0 && !text.endsWith("\n")) text += "\n";
+    text += line2;
+  };
+  if (result.code !== 0) {
+    append(`\u52B3\u52A1\u5F15\u64CE\u4EE5 code ${result.code} \u9000\u51FA`);
   }
-  return `\u52B3\u52A1\u5F15\u64CE\u4EE5 code ${result.code} \u9000\u51FA\uFF1A${lastRow}`;
+  if (result.stdout.trim() === "") {
+    append(ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC);
+  }
+  return text.length > 0 ? text : ENGINE_DETOUR_EMPTY_STDOUT_DIAGNOSTIC;
 }
 function engineNameFromEnv() {
   return normalizeEngineName(
@@ -4110,7 +4140,8 @@ var init_role_activation_flags = __esm({
 
 // src/user-dialogue-stdin.ts
 function encodeUserDialogueStdin(body) {
-  return JSON.stringify({ kind: USER_DIALOGUE_STDIN_KIND, body });
+  const envelope = { kind: USER_DIALOGUE_STDIN_KIND, body };
+  return JSON.stringify(envelope);
 }
 var USER_DIALOGUE_STDIN_KIND;
 var init_user_dialogue_stdin = __esm({
@@ -4485,17 +4516,6 @@ var init_submission_correctable_error = __esm({
   }
 });
 
-// src/sha256.ts
-import { createHash } from "node:crypto";
-function sha256Hex(bytes) {
-  return createHash("sha256").update(bytes).digest("hex");
-}
-var init_sha256 = __esm({
-  "src/sha256.ts"() {
-    "use strict";
-  }
-});
-
 // src/package-contracts/terminating-tools.ts
 function isTerminatingToolName(name) {
   return TERMINATING_TOOL_NAMES.includes(name);
@@ -4556,9 +4576,256 @@ var init_terminating_tools = __esm({
   }
 });
 
+// src/ticket-progress.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import {
+  appendFileSync as appendFileSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename as basename7, dirname as dirname6, join as join8, relative as relative2, sep as sep3 } from "node:path";
+function parseProgressText(text, pathForDiagnostic) {
+  if (text.trim() === "") return [];
+  const { records, diagnostics } = parseSitianRecordText(text);
+  for (const diagnostic of diagnostics) {
+    process.stderr.write(
+      `[ticket-progress] ${pathForDiagnostic} has malformed row(s); keeps reachable rows and retains the diagnostic: line ${diagnostic.line}: ${diagnostic.error}
+`
+    );
+  }
+  const lines = [];
+  for (const record of records) {
+    const parsed = record;
+    if (!isRecord(parsed)) continue;
+    if (typeof parsed.seat !== "string" || typeof parsed.round !== "string") continue;
+    lines.push(parsed);
+  }
+  return lines;
+}
+function readProgressFile(path) {
+  if (!existsSync2(path)) return [];
+  return parseProgressText(readFileSync2(path, "utf8"), path);
+}
+function readTicketProgressLines(subjectDirectory) {
+  if (basename7(subjectDirectory) === "unbound") {
+    const runsDir = join8(subjectDirectory, "runs");
+    if (!existsSync2(runsDir)) return [];
+    const out = [];
+    for (const name of readdirSync2(runsDir).sort()) {
+      out.push(...readProgressFile(join8(runsDir, name, LEG_PROGRESS_FILENAME)));
+    }
+    return out;
+  }
+  return readProgressFile(join8(subjectDirectory, CURRENT_FILENAME));
+}
+function roundBaseNumber(round) {
+  if (round.trim() === "") return 0;
+  const base = round.includes(".") ? round.slice(0, round.indexOf(".")) : round;
+  const n = Number(base);
+  return Number.isSafeInteger(n) && n > 0 ? n : 0;
+}
+function roundLens(round) {
+  return round.includes(".") ? round.slice(round.indexOf(".") + 1) : void 0;
+}
+function nextRoundFromLines(lines, seat, lens) {
+  const want = lens === void 0 || lens.trim() === "" ? void 0 : lens;
+  let max = 0;
+  for (const line2 of lines) {
+    if (line2.seat !== seat) continue;
+    if (roundLens(line2.round) !== want) continue;
+    max = Math.max(max, roundBaseNumber(line2.round));
+  }
+  const base = max + 1;
+  return want === void 0 ? String(base) : `${base}.${want}`;
+}
+function nextLegReceiptIndex(runDirectory) {
+  const dir = join8(runDirectory, RECEIPTS_DIRNAME);
+  if (!existsSync2(dir)) return 1;
+  let max = 0;
+  for (const name of readdirSync2(dir)) {
+    const match = /^(\d+)\.json$/.exec(name);
+    if (match === null) continue;
+    const n = Number(match[1]);
+    if (Number.isSafeInteger(n) && n > max) max = n;
+  }
+  return max + 1;
+}
+function statusAndSummaryFromPayload(seat, payload) {
+  if (!isRecord(payload)) return {};
+  const toolName = packagedRoleOutputTool(seat);
+  const status = toolName !== void 0 && isTerminatingToolName(toolName) ? acceptedFacts(toolName, payload).status : void 0;
+  const summary = typeof payload.summary === "string" ? payload.summary : void 0;
+  return {
+    ...status === void 0 ? {} : { status },
+    ...summary === void 0 ? {} : { summary }
+  };
+}
+function captureWorktreeHead(projectRoot) {
+  try {
+    const result = spawnSync2("git", ["rev-parse", "HEAD"], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024
+    });
+    if (result.error != null) {
+      const err = result.error;
+      const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+      return { head: "", fault: `git rev-parse HEAD spawn failed cwd=${projectRoot}: ${detail}` };
+    }
+    if (result.status !== 0) {
+      const detail = [result.stderr, result.stdout].map((part) => typeof part === "string" ? part.trim() : "").filter((part) => part !== "").join(" | ");
+      const status = result.status === null ? "null" : String(result.status);
+      const signal = result.signal == null ? "" : ` signal=${result.signal}`;
+      return {
+        head: "",
+        fault: detail === "" ? `git rev-parse HEAD failed (status=${status}${signal}) cwd=${projectRoot}` : `git rev-parse HEAD failed (status=${status}${signal}) cwd=${projectRoot}: ${detail}`
+      };
+    }
+    return { head: (result.stdout ?? "").trim() };
+  } catch (error) {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    return { head: "", fault: `git rev-parse HEAD threw cwd=${projectRoot}: ${message}` };
+  }
+}
+function progressSessionAbsolute(runDirectory, context) {
+  const host = typeof context.host === "string" ? context.host.trim() : "";
+  const sessionDirectory = sessionDirectoryOf(runDirectory);
+  if (host !== "" && host !== "pi" && host !== "hermes") {
+    return resolveHostDossierLandingPath({ host, sessionDirectory });
+  }
+  const issued = context.sessionManager.getSessionFile?.();
+  if (typeof issued === "string" && issued.trim() !== "") {
+    return issued;
+  }
+  return sessionFileOf(runDirectory);
+}
+function lensFromRunDirectory(runDirectory, role) {
+  if (role !== "reviewer") return void 0;
+  const lens = readPageSync(runDirectory, "admitted")?.lens;
+  return lens === "completeness" || lens === "correctness" ? lens : void 0;
+}
+function landTicketProgressForSealedSubmission(input) {
+  const runDirectory = runDirectoryFromHostContext(input.context);
+  if (runDirectory === void 0) return void 0;
+  const subjectDirectory = subjectDirectoryOfRun(runDirectory);
+  if (subjectDirectory === void 0) return void 0;
+  const lens = input.lens === "completeness" || input.lens === "correctness" ? input.lens : lensFromRunDirectory(runDirectory, input.role);
+  const leaf = basename7(runDirectory);
+  const unbound = basename7(subjectDirectory) === "unbound";
+  const progressPath = unbound ? join8(runDirectory, LEG_PROGRESS_FILENAME) : join8(subjectDirectory, CURRENT_FILENAME);
+  const receiptIndex = nextLegReceiptIndex(runDirectory);
+  const relativePath = `runs/${leaf}/${RECEIPTS_DIRNAME}/${receiptIndex}.json`;
+  const absolutePath = join8(subjectDirectory, relativePath);
+  mkdirSync3(dirname6(absolutePath), { recursive: true });
+  writeFileSync2(absolutePath, `${JSON.stringify(input.accepted, null, 2)}
+`, "utf8");
+  if (!unbound) {
+    relocateTicketProgressForLeg({ runDirectory });
+  }
+  const existing = unbound ? readProgressFile(progressPath) : readTicketProgressLines(subjectDirectory);
+  const round = unbound ? "" : nextRoundFromLines(existing, input.role, lens);
+  const sessionFile = progressSessionAbsolute(runDirectory, input.context);
+  const sessionRelative = relative2(subjectDirectory, sessionFile).split(sep3).join("/");
+  const { status, summary } = statusAndSummaryFromPayload(input.role, input.accepted);
+  const instruction = typeof input.context.summonsInstruction === "string" ? input.context.summonsInstruction : "";
+  const line2 = {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    seat: input.role,
+    round,
+    instruction,
+    head: input.sealHead.head,
+    ...status === void 0 ? {} : { status },
+    ...summary === void 0 ? {} : { summary },
+    receipt: relativePath,
+    session: sessionRelative
+  };
+  mkdirSync3(dirname6(progressPath), { recursive: true });
+  appendFileSync2(progressPath, `${JSON.stringify(line2)}
+`, "utf8");
+  if (input.sealHead.fault !== void 0) {
+    process.stderr.write(`${input.sealHead.fault}
+`);
+  }
+  return line2;
+}
+function relocateTicketProgressForLeg(input) {
+  if (isUnboundRunDirectory(input.runDirectory)) return;
+  const subjectDirectory = subjectDirectoryOfRun(input.runDirectory);
+  if (subjectDirectory === void 0) return;
+  const stagedPath = join8(input.runDirectory, LEG_PROGRESS_FILENAME);
+  const mine = readProgressFile(stagedPath);
+  if (mine.length === 0) {
+    if (existsSync2(stagedPath)) {
+      rmSync3(stagedPath, { force: true });
+    }
+    return;
+  }
+  const ticketLines = [...readTicketProgressLines(subjectDirectory)];
+  const publishedReceipts = new Set(
+    ticketLines.map((line2) => line2.receipt).filter((receipt) => typeof receipt === "string" && receipt !== "")
+  );
+  const pending = mine.filter((line2) => !publishedReceipts.has(line2.receipt));
+  if (pending.length === 0) {
+    rmSync3(stagedPath, { force: true });
+    return;
+  }
+  const movedLines = [];
+  for (const line2 of pending) {
+    const lens = lensFromRunDirectory(input.runDirectory, line2.seat);
+    const round = nextRoundFromLines(ticketLines, line2.seat, lens);
+    const moved = {
+      ...line2,
+      round
+    };
+    movedLines.push(moved);
+    ticketLines.push(moved);
+  }
+  const newCurrent = join8(subjectDirectory, CURRENT_FILENAME);
+  mkdirSync3(dirname6(newCurrent), { recursive: true });
+  appendFileSync2(
+    newCurrent,
+    `${movedLines.map((line2) => JSON.stringify(line2)).join("\n")}
+`,
+    "utf8"
+  );
+  rmSync3(stagedPath, { force: true });
+}
+var CURRENT_FILENAME, RECEIPTS_DIRNAME, LEG_PROGRESS_FILENAME;
+var init_ticket_progress = __esm({
+  "src/ticket-progress.ts"() {
+    "use strict";
+    init_host_session_record();
+    init_host_contracts();
+    init_terminating_tools();
+    init_packaged_role_registry();
+    init_role_run_placement();
+    init_run_dossier();
+    init_sitian_reader();
+    init_unknown_value();
+    CURRENT_FILENAME = "current.jsonl";
+    RECEIPTS_DIRNAME = "receipts";
+    LEG_PROGRESS_FILENAME = "progress.jsonl";
+  }
+});
+
+// src/sha256.ts
+import { createHash } from "node:crypto";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+var init_sha256 = __esm({
+  "src/sha256.ts"() {
+    "use strict";
+  }
+});
+
 // src/doctor-evidence.ts
 import { readdir as readdir2, readFile as readFile4, realpath, stat } from "node:fs/promises";
-import { dirname as dirname6, relative as relative2, resolve as resolve4, sep as sep3 } from "node:path";
+import { dirname as dirname7, relative as relative3, resolve as resolve4, sep as sep4 } from "node:path";
 async function discoverCaseFiles(root) {
   const found = [];
   async function walk(dir, depth) {
@@ -4587,11 +4854,11 @@ async function stableRunsIdentity(root) {
   while (true) {
     try {
       const git3 = await stat(resolve4(cursor, ".git"));
-      if (git3.isDirectory() || git3.isFile()) return relative2(cursor, root).split(sep3).join("/");
+      if (git3.isDirectory() || git3.isFile()) return relative3(cursor, root).split(sep4).join("/");
     } catch (error) {
       if (!isMissingPathError(error)) throw error;
     }
-    const parent = dirname6(cursor);
+    const parent = dirname7(cursor);
     if (parent === cursor) return root;
     cursor = parent;
   }
@@ -4664,12 +4931,12 @@ async function loadDoctorCase(runsPath, projectRoot) {
   if (projectRoot !== void 0 && !physicallyContainedIn(projectRoot, root)) {
     throw new Error("doctor --runs escapes the project root");
   }
-  const match = root.split(sep3).join("/").match(/\/\.ak-roles\/books\/[^/]+\/(?:issues\/)?([1-9]\d*)\/runs$/);
+  const match = root.split(sep4).join("/").match(/\/\.ak-roles\/books\/[^/]+\/(?:issues\/)?([1-9]\d*)\/runs$/);
   if (!match) throw new Error("Doctor case must be an .ak-roles/books/<book>/<n>/runs directory");
   const evidence = [], sessions = [], statuses = [], commits = [];
   const turns = { count: 0, sources: [] }, calls = { count: 0, sources: [] }, tokens = { count: 0, sources: [] };
   for (const path of await discoverCaseFiles(root)) {
-    const id = relative2(root, path).split(sep3).join("/");
+    const id = relative3(root, path).split(sep4).join("/");
     const bytes = await readFile4(path);
     const content = bytes.toString("utf8");
     const kind = id.split("/").length === 2 && id.endsWith("/log.jsonl") ? "log" : "session";
@@ -4965,13 +5232,13 @@ var init_session_dialogue = __esm({
 
 // src/ticket-provenance.ts
 import { readFile as readFile6 } from "node:fs/promises";
-import { join as join8, resolve as resolve6 } from "node:path";
+import { join as join9, resolve as resolve6 } from "node:path";
 function dialogueSessionSourceRoots(home) {
   const machineHome = typeof home === "string" && home.trim() !== "" ? home : packageMachineHome();
   return [
-    join8(machineHome, ".claude", "projects"),
-    join8(machineHome, ".codex", "sessions"),
-    join8(machineHome, ".pi", "agent", "sessions")
+    join9(machineHome, ".claude", "projects"),
+    join9(machineHome, ".codex", "sessions"),
+    join9(machineHome, ".pi", "agent", "sessions")
   ];
 }
 function isLedgerRoleSessionFile(absolute, home) {
@@ -5012,7 +5279,7 @@ async function rehomeUnboundTicketProvenance(runDirectory, ticketNumber, cwd, ho
   const ticketInput = ticketProvenanceRecordInput(ticketNumber, cwd, home);
   let history;
   try {
-    history = await readFile6(join8(runDirectory, RUN_HISTORY_FILE), "utf8");
+    history = await readFile6(join9(runDirectory, RUN_HISTORY_FILE), "utf8");
   } catch (error) {
     if (errnoCode(error) === "ENOENT") return;
     throw error;
@@ -5229,7 +5496,7 @@ var init_uuidv7 = __esm({
 });
 
 // src/notary-source-run.ts
-import { dirname as dirname7, isAbsolute as isAbsolute4, join as join9, resolve as resolve7, basename as basename7 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute4, join as join10, resolve as resolve7, basename as basename8 } from "node:path";
 import { lstat, realpath as realpath2 } from "node:fs/promises";
 async function readRetainedIdentity(runDirectory) {
   try {
@@ -5265,10 +5532,10 @@ async function requireRunDirectory(candidate, display) {
       `notary --source-run must be a run directory: ${display}`
     );
   }
-  const identity = parseRunLeaf(basename7(real));
+  const identity = parseRunLeaf(basename8(real));
   if (identity === void 0) {
     throw new NotarySourceRunError(
-      `notary --source-run must be named <runId>@<role>: ${basename7(real)}`
+      `notary --source-run must be named <runId>@<role>: ${basename8(real)}`
     );
   }
   return real;
@@ -5281,26 +5548,26 @@ async function resolveNotarySourceRunLocator(options) {
   const ledgerHome = resolveActivationLedgerHome(options.home);
   const bookKey = resolveBookKeyFromGit(options.projectRoot);
   const bookDirectory = activationBookDirectory(ledgerHome, bookKey);
-  const bookRunsRoot = join9(bookDirectory, "runs");
+  const bookRunsRoot = join10(bookDirectory, "runs");
   let candidate;
   const bare = parseRunLeaf(raw);
   if (bare !== void 0 && !raw.includes("/") && !raw.includes("\\")) {
-    candidate = await findRunDirectoryById(options.home, bare.runId, bookKey, bare.role) ?? join9(bookRunsRoot, formatRunLeaf(bare.runId, bare.role));
+    candidate = await findRunDirectoryById(options.home, bare.runId, bookKey, bare.role) ?? join10(bookRunsRoot, formatRunLeaf(bare.runId, bare.role));
   } else {
     candidate = isAbsolute4(raw) ? raw : resolve7(options.projectRoot, raw);
-    const identity2 = parseRunLeaf(basename7(candidate));
-    const subjectDirectory = dirname7(dirname7(candidate));
-    const isLegacyUnboundLocator = identity2 !== void 0 && basename7(dirname7(candidate)) === "runs" && basename7(subjectDirectory) === "unbound" && resolve7(dirname7(subjectDirectory)) === resolve7(bookDirectory);
+    const identity2 = parseRunLeaf(basename8(candidate));
+    const subjectDirectory = dirname8(dirname8(candidate));
+    const isLegacyUnboundLocator = identity2 !== void 0 && basename8(dirname8(candidate)) === "runs" && basename8(subjectDirectory) === "unbound" && resolve7(dirname8(subjectDirectory)) === resolve7(bookDirectory);
     if (isLegacyUnboundLocator) {
       candidate = await resolveLiveRunDirectoryPath(candidate, options.home ?? ledgerHome, bookKey) ?? candidate;
     }
   }
   const real = await requireRunDirectory(candidate, raw);
-  const identity = parseRunLeaf(basename7(real));
+  const identity = parseRunLeaf(basename8(real));
   const bookIdentity = physicalPathIdentity(bookDirectory);
-  const parentIdentity = physicalPathIdentity(dirname7(real));
-  const subjectBookIdentity = physicalPathIdentity(dirname7(dirname7(dirname7(real))));
-  if (parentIdentity !== physicalPathIdentity(bookRunsRoot) && !(basename7(dirname7(real)) === "runs" && subjectBookIdentity === bookIdentity)) {
+  const parentIdentity = physicalPathIdentity(dirname8(real));
+  const subjectBookIdentity = physicalPathIdentity(dirname8(dirname8(dirname8(real))));
+  if (parentIdentity !== physicalPathIdentity(bookRunsRoot) && !(basename8(dirname8(real)) === "runs" && subjectBookIdentity === bookIdentity)) {
     throw new NotarySourceRunError(
       "notary --source-run must resolve to a retained run under the project machine-ledger book"
     );
@@ -5334,7 +5601,7 @@ async function resolveNotarySourceRunLocator(options) {
 }
 async function loadNotarySourceRunLocator(path) {
   const real = await requireRunDirectory(path, path);
-  const identity = parseRunLeaf(basename7(real));
+  const identity = parseRunLeaf(basename8(real));
   const runState = await readRetainedIdentity(real);
   if (runState === void 0) {
     throw new NotarySourceRunError(
@@ -6502,14 +6769,14 @@ var init_option_definitions = __esm({
 
 // src/public-cli/invocation.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import {
   readFile as readFile7,
   realpath as realpath3,
   rename,
   writeFile
 } from "node:fs/promises";
-import { dirname as dirname8, isAbsolute as isAbsolute5, join as join10, resolve as resolve8 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute5, join as join11, resolve as resolve8 } from "node:path";
 function admittedSourceRunPath(admitted) {
   if (!isRecord(admitted)) return void 0;
   const path = admitted.sourceRunPath;
@@ -6668,35 +6935,36 @@ async function recordAdmittedCorrelation(admitted, correlationId) {
   mutable.correlationId = correlationId;
   mutable.correlationIds = correlationIds;
 }
-async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
-  if (admitted.ticketNumber === void 0 || !isUnboundRunDirectory(admitted.runDirectory)) return void 0;
-  const oldRunDirectory = admitted.runDirectory;
-  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(oldRunDirectory));
-  const target = roleRunPlacement(ledgerHome, {
-    bookKey: admitted.bookKey,
-    subject: { ticketNumber: admitted.ticketNumber },
-    runId: admitted.runId,
-    role: admitted.role
-  });
-  ensureRoleRunDirectory(ledgerHome, dirname8(target.runDirectory));
-  const principal = authority.seal(target);
-  if (admitted.role !== "diarist") {
-    const childRunIds = readPageSync(oldRunDirectory, "admitted")?.childDiaristRunIds;
-    for (const childRunId of Array.isArray(childRunIds) ? childRunIds : []) {
-      if (typeof childRunId !== "string") continue;
-      const childDirectory = join10(dirname8(oldRunDirectory), formatRunLeaf(childRunId, "diarist"));
-      if (!existsSync2(childDirectory)) continue;
-      const childTarget = roleRunPlacement(ledgerHome, {
-        bookKey: admitted.bookKey,
-        subject: { ticketNumber: admitted.ticketNumber },
-        runId: childRunId,
-        role: "diarist"
+async function relocateRegisteredChildDiarists(input) {
+  const childRunIds = readPageSync(input.parentRunDirectory, "admitted")?.childDiaristRunIds;
+  for (const childRunId of Array.isArray(childRunIds) ? childRunIds : []) {
+    if (typeof childRunId !== "string") continue;
+    const childTarget = roleRunPlacement(input.ledgerHome, {
+      bookKey: input.bookKey,
+      subject: { ticketNumber: input.ticketNumber },
+      runId: childRunId,
+      role: "diarist"
+    });
+    const unboundChildDirectory = roleRunPlacement(input.ledgerHome, {
+      bookKey: input.bookKey,
+      subject: { unbound: true },
+      runId: childRunId,
+      role: "diarist"
+    }).runDirectory;
+    if (existsSync3(unboundChildDirectory)) {
+      input.authority.seal(childTarget);
+      await bindTicketNumberOnRunDirectory(unboundChildDirectory, input.ticketNumber);
+      await rehomeUnboundTicketProvenance(
+        unboundChildDirectory,
+        input.ticketNumber,
+        input.projectRoot,
+        homeFromRunDirectory(input.parentRunDirectory)
+      );
+      ensureRoleRunDirectory(input.ledgerHome, dirname9(childTarget.runDirectory));
+      await rename(unboundChildDirectory, childTarget.runDirectory);
+      relocateTicketProgressForLeg({
+        runDirectory: childTarget.runDirectory
       });
-      authority.seal(childTarget);
-      await bindTicketNumberOnRunDirectory(childDirectory, admitted.ticketNumber);
-      await rehomeUnboundTicketProvenance(childDirectory, admitted.ticketNumber, admitted.projectRoot, homeFromRunDirectory(oldRunDirectory));
-      ensureRoleRunDirectory(ledgerHome, dirname8(childTarget.runDirectory));
-      await rename(childDirectory, childTarget.runDirectory);
       try {
         renderCurrentSync(childTarget.runDirectory);
       } catch (error) {
@@ -6705,18 +6973,71 @@ async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
 `
         );
       }
+      continue;
+    }
+    if (existsSync3(childTarget.runDirectory)) {
+      relocateTicketProgressForLeg({
+        runDirectory: childTarget.runDirectory
+      });
     }
   }
+}
+async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
+  if (admitted.ticketNumber === void 0) return void 0;
+  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(admitted.runDirectory));
+  if (!isUnboundRunDirectory(admitted.runDirectory)) {
+    relocateTicketProgressForLeg({
+      runDirectory: admitted.runDirectory
+    });
+    if (admitted.role !== "diarist") {
+      await relocateRegisteredChildDiarists({
+        parentRunDirectory: admitted.runDirectory,
+        bookKey: admitted.bookKey,
+        ticketNumber: admitted.ticketNumber,
+        projectRoot: admitted.projectRoot,
+        ledgerHome,
+        authority
+      });
+    }
+    return void 0;
+  }
+  const oldRunDirectory = admitted.runDirectory;
+  const target = roleRunPlacement(ledgerHome, {
+    bookKey: admitted.bookKey,
+    subject: { ticketNumber: admitted.ticketNumber },
+    runId: admitted.runId,
+    role: admitted.role
+  });
+  ensureRoleRunDirectory(ledgerHome, dirname9(target.runDirectory));
+  authority.seal(target);
+  if (admitted.role !== "diarist") {
+    await relocateRegisteredChildDiarists({
+      parentRunDirectory: oldRunDirectory,
+      bookKey: admitted.bookKey,
+      ticketNumber: admitted.ticketNumber,
+      projectRoot: admitted.projectRoot,
+      ledgerHome,
+      authority
+    });
+  }
   if (admitted.role === "diarist") {
     await rehomeUnboundTicketProvenance(oldRunDirectory, admitted.ticketNumber, admitted.projectRoot, homeFromRunDirectory(oldRunDirectory));
   }
   await rename(oldRunDirectory, target.runDirectory);
   heldLease?.relocate(target.runDirectory);
+  const actualSessionDirectory = sessionDirectoryOf(target.runDirectory);
+  const principal = authority.seal({
+    sessionDirectory: actualSessionDirectory,
+    sessionFile: sessionFileIn(actualSessionDirectory)
+  });
   rewriteAdmittedRoleRunPage(
     admitted,
     [{ oldRunDirectory, newRunDirectory: target.runDirectory }]
   );
   admitted.principal = principal;
+  relocateTicketProgressForLeg({
+    runDirectory: target.runDirectory
+  });
   renderCurrentSync(target.runDirectory);
   return { oldRunDirectory, newRunDirectory: target.runDirectory };
 }
@@ -6752,7 +7073,7 @@ async function recordLaunchedPiIdentity(runDirectory, identity) {
 async function observeLaunchedRolePackageIdentity(packageRoot, selectedRoleEntry) {
   const rolePackageRoot = packageRoot;
   const raw = JSON.parse(
-    await readFile7(join10(rolePackageRoot, "package.json"), "utf8")
+    await readFile7(join11(rolePackageRoot, "package.json"), "utf8")
   );
   if (typeof raw.version !== "string" || raw.version.trim() === "") {
     throw new Error(
@@ -7310,7 +7631,7 @@ async function admitPublicRole(role, parsed, env, override) {
             resolutionScope: [...derived.resolutionScope],
             authorizedChecks: []
           });
-          const mergerInputPath = join10(placed.runDirectory, "merger-input.json");
+          const mergerInputPath = join11(placed.runDirectory, "merger-input.json");
           await writeFile(
             mergerInputPath,
             `${JSON.stringify(mergerInput, null, 2)}
@@ -7592,7 +7913,7 @@ function parseDoctorIssueNumber(raw) {
 }
 async function resolveDoctorCaseRunsPath(options) {
   const ledgerHome = resolveActivationLedgerHome(options.home);
-  const defaultRuns = join10(
+  const defaultRuns = join11(
     activationBookDirectory(ledgerHome, options.bookKey),
     String(options.issueNumber),
     "runs"
@@ -7665,11 +7986,11 @@ function parseAnalystCohortIssueToken(raw, flag) {
       `${flag} requires a comma-separated list of N or book:N`
     );
   }
-  const sep5 = trimmed.lastIndexOf(":");
-  if (sep5 > 0) {
-    const rhs = trimmed.slice(sep5 + 1);
+  const sep6 = trimmed.lastIndexOf(":");
+  if (sep6 > 0) {
+    const rhs = trimmed.slice(sep6 + 1);
     if (parseTicketNumber(rhs) !== void 0) {
-      const bookKey = trimmed.slice(0, sep5);
+      const bookKey = trimmed.slice(0, sep6);
       if (bookKey.trim() === "") {
         throw new CliUsageError(
           `${flag} book:N requires a non-empty book key, got ${raw}`
@@ -7866,6 +8187,7 @@ var init_invocation = __esm({
     init_activation_ledger_topology();
     init_activation_ledger_git();
     init_role_run_placement();
+    init_ticket_progress();
     init_packaged_role_registry();
     init_run_ticket_number();
     init_role_run_relocation();
@@ -7888,7 +8210,7 @@ var init_invocation = __esm({
 
 // src/report-ticket-tool.ts
 import { Type as Type15 } from "typebox";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 function pageString(page, key) {
   const value = page?.[key];
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
@@ -7930,7 +8252,7 @@ async function reportTicketFromHostContext(context, rawTicketNumber, authority =
   if (runDirectory === void 0) {
     throw new Error("ak_report_ticket requires a per-turn run directory");
   }
-  if (!existsSync3(runDirectory)) {
+  if (!existsSync4(runDirectory)) {
     throw new Error(`ak_report_ticket run directory missing: ${runDirectory}`);
   }
   const admitted = admittedForLiveTicketReport(runDirectory, authority);
@@ -7949,7 +8271,11 @@ async function reportTicketFromHostContext(context, rawTicketNumber, authority =
       context.sessionManager.setSessionFile?.(projectedSessionFile);
     }
   };
-  const relocation = alreadyPlaced ? void 0 : await relocateAdmittedRunToTicket(admitted, authority, { relocate: applyLiveHandles });
+  const relocation = await relocateAdmittedRunToTicket(
+    admitted,
+    authority,
+    alreadyPlaced ? void 0 : { relocate: applyLiveHandles }
+  );
   const nextDirectory = relocation?.newRunDirectory ?? admitted.runDirectory;
   if (relocation === void 0) applyLiveHandles(nextDirectory);
   return {
@@ -8206,6 +8532,7 @@ async function sealAcceptedSubmission(options) {
   const attemptId = attemptIdentity(options.context, runId);
   const sessionParent = sessionParentFromHostContext(options.context);
   const home = homeFromHostContext(options.context, options.home);
+  const sealHead = captureWorktreeHead(options.context.cwd);
   sitianReport({
     level: "event",
     kind: "sealed",
@@ -8222,6 +8549,12 @@ async function sealAcceptedSubmission(options) {
     ...home !== void 0 ? { home } : {},
     ...sessionParent === void 0 ? {} : { sessionParent }
   });
+  landTicketProgressForSealedSubmission({
+    context: options.context,
+    role: options.role,
+    accepted: options.accepted,
+    sealHead
+  });
 }
 function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (error) => {
   throw error;
@@ -8346,6 +8679,7 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
             kind: "accepted",
             accepted: params
           };
+          const sealHead = captureWorktreeHead(context.cwd);
           append({
             type: "sealed",
             attemptId,
@@ -8353,6 +8687,14 @@ function createSubmissionLedgerHost(host, outputTools, failInfrastructure2 = (er
             role,
             accepted: params
           });
+          const rawLens = typeof host.getFlag === "function" ? host.getFlag("ak-review-lens") : void 0;
+          landTicketProgressForSealedSubmission({
+            context,
+            role,
+            accepted: params,
+            sealHead,
+            ...rawLens === "completeness" || rawLens === "correctness" ? { lens: rawLens } : {}
+          });
           await projectClosure(closed, context);
           return result;
         }
@@ -8374,6 +8716,7 @@ var init_submission_ledger = __esm({
     init_report_ticket_tool();
     init_review_submission();
     init_run_ticket_number();
+    init_ticket_progress();
     init_unknown_value();
   }
 });
@@ -8560,7 +8903,7 @@ var init_engine_detour_usage = __esm({
 });
 
 // src/dossier-resolution.ts
-import { existsSync as existsSync4, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync5, statSync as statSync4 } from "node:fs";
 import { resolve as resolve9 } from "node:path";
 function isHostContext(value) {
   return "sessionManager" in value;
@@ -8580,7 +8923,7 @@ function resolveAuditDossier(source) {
   }
   const runDirectory = resolve9(raw);
   try {
-    if (!existsSync4(runDirectory) || !statSync4(runDirectory).isDirectory()) {
+    if (!existsSync5(runDirectory) || !statSync4(runDirectory).isDirectory()) {
       return { status: "incomplete", observation: { kind: "missing-dossier" } };
     }
   } catch {
@@ -9898,12 +10241,12 @@ var init_settlement = __esm({
 });
 
 // src/external-host-turn-loop.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { basename as basename8 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { basename as basename9 } from "node:path";
 async function syncTurnRequestLivePlacement(request, authority) {
   const live = await resolveLiveRunDirectoryPath(request.runDirectory, request.home);
   if (live === void 0) {
-    const parsed = parseRunLeaf(basename8(request.runDirectory));
+    const parsed = parseRunLeaf(basename9(request.runDirectory));
     throw new Error(
       `admitted run ${parsed?.runId ?? "(unparseable)"} missing after host turn; not found under ${request.home}`
     );
@@ -9922,7 +10265,7 @@ async function trySyncTurnRequestLivePlacement(request, authority) {
 }
 async function retainPackageFaultBesideLivePlacement(request, input) {
   let runDirectory = request.runDirectory;
-  if (!existsSync5(runDirectory)) {
+  if (!existsSync6(runDirectory)) {
     try {
       const found = await resolveLiveRunDirectoryPath(request.runDirectory, request.home);
       if (found === void 0) {
@@ -10093,6 +10436,7 @@ async function driveExternalRoleTurnRounds(prepared, request, driver) {
       }
     }
     prompt = closure.retry.message;
+    prepared.recordSentInstruction?.(prompt);
     driver.afterRetry?.();
   }
 }
@@ -10135,9 +10479,9 @@ var init_external_host_turn_loop = __esm({
 });
 
 // src/session-identity.ts
-import { dirname as dirname9, join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function createSessionIdentityAuthority(authority, hostName) {
-  const runDirectoryOf = (principal) => dirname9(authority.decode(principal).sessionDirectory);
+  const runDirectoryOf = (principal) => runDirectoryFromSessionDirectory(authority.decode(principal).sessionDirectory);
   return {
     principalAuthority: authority,
     resolveSessionFile(principal) {
@@ -10145,7 +10489,7 @@ function createSessionIdentityAuthority(authority, hostName) {
     },
     async load(principal) {
       const runDirectory = runDirectoryOf(principal);
-      const { records, diagnostics } = await readSitianRecords(join11(runDirectory, RUN_STATE_FILE));
+      const { records, diagnostics } = await readSitianRecords(join12(runDirectory, RUN_STATE_FILE));
       if (diagnostics.length > 0) {
         throw new Error(
           `${RUN_STATE_FILE} has ${diagnostics.length} malformed row(s); refusing stale session binding: ${runDirectory}`
@@ -10192,6 +10536,7 @@ var init_session_identity = __esm({
   "src/session-identity.ts"() {
     "use strict";
     init_host_descriptions();
+    init_role_run_placement();
     init_run_dossier();
     init_sitian_facade();
     init_unknown_value();
@@ -10214,14 +10559,14 @@ __export(role_turn_host_exports, {
 });
 import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { constants } from "node:fs";
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { access as access2, appendFile, realpath as realpath4 } from "node:fs/promises";
-import { delimiter, dirname as dirname10, isAbsolute as isAbsolute6, join as join12, resolve as resolve11 } from "node:path";
+import { delimiter, dirname as dirname10, isAbsolute as isAbsolute6, join as join13, resolve as resolve11 } from "node:path";
 import { platform } from "node:process";
 import { promisify as promisify2 } from "node:util";
 import { randomUUID as randomUUID4 } from "node:crypto";
 function resolveInternalRoleEntrypoint(packageRoot) {
-  return join12(packageRoot, INTERNAL_ROLE_ENTRYPOINT_RELATIVE2);
+  return join13(packageRoot, INTERNAL_ROLE_ENTRYPOINT_RELATIVE2);
 }
 function buildExplicitInternalActivationArgs(selectedRoleEntry, extraArgs = []) {
   return ["--no-extensions", "-e", selectedRoleEntry, ...extraArgs];
@@ -10411,7 +10756,7 @@ function createDefaultPiSpawnRunner(options) {
                   homeFromRunDirectory(spawnDir)
                 );
               } catch (resolveError) {
-                runDirectory = existsSync6(spawnDir) ? spawnDir : void 0;
+                runDirectory = existsSync7(spawnDir) ? spawnDir : void 0;
                 const resolveDiagnostic = `live run path resolve failed beside Pi transport fault: ${describeErrorIdentity(resolveError)}`;
                 if (runDirectory !== void 0) {
                   await retainPackageFault({
@@ -10464,7 +10809,8 @@ function createPiRoleTurnHost(config) {
         config.extraPiArgs ?? []
       );
       const args = buildExplicitInternalActivationArgs(roleEntry, extraArgs);
-      const stdin = encodeUserDialogueStdin(piUserDialogueBody(turnRequest));
+      const transportBody = piUserDialogueBody(turnRequest);
+      const stdin = encodeUserDialogueStdin(transportBody);
       const env = {
         ...process.env,
         HOME: request.home,
@@ -10480,6 +10826,7 @@ function createPiRoleTurnHost(config) {
       else env.AK_ROLE_INVOCATION_SCOPE = request.invocationScopeId;
       if (request.host === void 0 || request.host.trim() === "") delete env.AK_ROLE_HOST;
       else env.AK_ROLE_HOST = request.host.trim();
+      delete env.AK_ROLE_SUMMONS_INSTRUCTION;
       if (request.deliveryRequestLimit === void 0) delete env[RECEIPT_DELIVERY_LIMIT_ENV];
       else env[RECEIPT_DELIVERY_LIMIT_ENV] = String(request.deliveryRequestLimit);
       applyEngineChildEnv(env, request.engine);
@@ -10612,8 +10959,8 @@ var init_role_turn_host = __esm({
 });
 
 // src/package-resources/engine-material.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join14 } from "node:path";
 function pickEngineAxis(source) {
   return {
     ...source.engine === void 0 ? {} : { engine: source.engine },
@@ -10634,14 +10981,14 @@ function isEngineNameSyntax(name) {
   return true;
 }
 function resolveEngineMaterialDirectory(packageRoot) {
-  return join13(packageRoot, ENGINE_MATERIAL_RELATIVE_ROOT);
+  return join14(packageRoot, ENGINE_MATERIAL_RELATIVE_ROOT);
 }
 function resolveEngineDispatchMaterialPath(packageRoot) {
-  return join13(packageRoot, ENGINE_DISPATCH_RELATIVE_PATH);
+  return join14(packageRoot, ENGINE_DISPATCH_RELATIVE_PATH);
 }
 function resolveEngineMaterialPath(packageRoot, name) {
   const legal = assertLegalEngineName(name);
-  return join13(resolveEngineMaterialDirectory(packageRoot), `${legal}.md`);
+  return join14(resolveEngineMaterialDirectory(packageRoot), `${legal}.md`);
 }
 function assertLegalEngineName(name) {
   if (!isEngineNameSyntax(name)) {
@@ -10658,12 +11005,12 @@ function engineSessionMaterialFromOptions(options) {
   const model = options.engineModel === void 0 ? void 0 : assertLegalEngineModel(options.engineModel);
   const materialPath = resolveEngineMaterialPath(options.packageRoot, name);
   const modelField = model === void 0 ? {} : { model };
-  if (!existsSync7(materialPath)) {
+  if (!existsSync8(materialPath)) {
     return Object.freeze({ name, ...modelField });
   }
-  const handbook = readFileSync2(materialPath, "utf8");
+  const handbook = readFileSync3(materialPath, "utf8");
   const dispatchPath = resolveEngineDispatchMaterialPath(options.packageRoot);
-  const dispatchField = existsSync7(dispatchPath) ? { dispatchHandbook: readFileSync2(dispatchPath, "utf8") } : {};
+  const dispatchField = existsSync8(dispatchPath) ? { dispatchHandbook: readFileSync3(dispatchPath, "utf8") } : {};
   return Object.freeze({ name, handbook, ...dispatchField, ...modelField });
 }
 function engineSessionReadingMaterial(engineMaterial) {
@@ -10740,7 +11087,7 @@ __export(config_exports, {
   validatePublicCliConfigAxes: () => validatePublicCliConfigAxes
 });
 import { mkdir, readFile as readFile8, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname11, join as join14 } from "node:path";
+import { dirname as dirname11, join as join15 } from "node:path";
 function isGateOfficerSeat(value) {
   return packagedProvinceConfig(value);
 }
@@ -10748,7 +11095,7 @@ function publicCliConfigPath(home) {
   if (typeof home !== "string" || home.trim() === "") {
     throw new Error("home must be explicitly provided");
   }
-  return join14(home, ".ak-roles", "public-cli.json");
+  return join15(home, ".ak-roles", "public-cli.json");
 }
 async function loadPublicCliConfig(home) {
   const path = publicCliConfigPath(home);
@@ -11208,11 +11555,11 @@ function credentialProvidersFromAuthData(data) {
   };
 }
 function resolvePublicAgentDir(explicit, home) {
-  return explicit ?? process.env.PI_CODING_AGENT_DIR ?? join14(home, ".pi", "agent");
+  return explicit ?? process.env.PI_CODING_AGENT_DIR ?? join15(home, ".pi", "agent");
 }
 async function loadCredentialProviders(agentDir) {
   try {
-    const raw = await readFile8(join14(agentDir, "auth.json"), "utf8");
+    const raw = await readFile8(join15(agentDir, "auth.json"), "utf8");
     return credentialProvidersFromAuthData(JSON.parse(raw));
   } catch (error) {
     if (isEnoent(error)) return { "openai-codex": false, xai: false };
@@ -11236,16 +11583,16 @@ var init_config = __esm({
 });
 
 // src/public-cli/host-providers.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { join as join15 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join16 } from "node:path";
 function hostProvidersPath(home) {
   if (typeof home !== "string" || home.trim() === "") {
     throw new Error("home must be explicitly provided");
   }
-  return join15(home, ".ak-roles", "host-providers.json");
+  return join16(home, ".ak-roles", "host-providers.json");
 }
 function hermesProviderModelsCachePath(home) {
-  return join15(home, ".hermes", "provider_models_cache.json");
+  return join16(home, ".hermes", "provider_models_cache.json");
 }
 function parseHostProvidersTable(value) {
   if (!isRecord(value)) {
@@ -11282,7 +11629,7 @@ function parseHostProvidersTable(value) {
 function loadHostProvidersTable(home) {
   const path = hostProvidersPath(home);
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     return parseHostProvidersTable(JSON.parse(raw));
   } catch (error) {
     if (isEnoent(error)) return {};
@@ -11298,7 +11645,7 @@ function listHermesProvidersForModel(home, seatModel) {
   const path = hermesProviderModelsCachePath(home);
   let text;
   try {
-    text = readFileSync3(path, "utf8");
+    text = readFileSync4(path, "utf8");
   } catch (error) {
     if (isEnoent(error)) return [];
     throw error;
@@ -11395,17 +11742,17 @@ var init_host_providers = __esm({
 });
 
 // src/public-cli/load-production-acp-host.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join17 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadProductionAcpHostFactory(packageRoot, host) {
   const description = lookupHostDescription(host);
   if (description === void 0) {
     throw new Error(`unregistered host: ${host}`);
   }
-  const built = join16(packageRoot, "dist/acp-host/production-host.js");
-  const source = join16(packageRoot, "src/acp-host/production-host.ts");
-  const target = existsSync8(built) ? built : source;
+  const built = join17(packageRoot, "dist/acp-host/production-host.js");
+  const source = join17(packageRoot, "src/acp-host/production-host.ts");
+  const target = existsSync9(built) ? built : source;
   const href = pathToFileURL(target).href;
   const mod = await import(href);
   const create = mod.createProductionAcpRoleTurnHost;
@@ -11419,17 +11766,17 @@ var init_load_production_acp_host = __esm({
 });
 
 // src/public-cli/load-production-headless-host.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join18 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function loadProductionHeadlessHostFactory(packageRoot, host) {
   const description = lookupHeadlessHostDescription(host);
   if (description === void 0) {
     throw new Error(`unregistered headless host: ${host}`);
   }
-  const built = join17(packageRoot, "dist/headless-host/production-host.js");
-  const source = join17(packageRoot, "src/headless-host/production-host.ts");
-  const target = existsSync9(built) ? built : source;
+  const built = join18(packageRoot, "dist/headless-host/production-host.js");
+  const source = join18(packageRoot, "src/headless-host/production-host.ts");
+  const target = existsSync10(built) ? built : source;
   const href = pathToFileURL2(target).href;
   const mod = await import(href);
   const create = mod.createProductionHeadlessRoleTurnHost;
@@ -11596,14 +11943,14 @@ var init_role_seat_runtime = __esm({
 });
 
 // src/session-opening-materials.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { readFile as readFile9 } from "node:fs/promises";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname12, join as join19 } from "node:path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolvePackageRootDir(moduleUrl = import.meta.url) {
   let dir = dirname12(fileURLToPath(moduleUrl));
   for (let i = 0; i < 8; i += 1) {
-    if (existsSync10(join18(dir, "package.json")) && existsSync10(join18(dir, "souls"))) {
+    if (existsSync11(join19(dir, "package.json")) && existsSync11(join19(dir, "souls"))) {
       return dir;
     }
     const parent = dirname12(dir);
@@ -11963,7 +12310,7 @@ __export(auditor_soul_exports, {
   readAuditorResumeBinding: () => readAuditorResumeBinding,
   resolveAuditorSubject: () => resolveAuditorSubject
 });
-import { basename as basename9 } from "node:path";
+import { basename as basename10 } from "node:path";
 function auditorSoulRelativePath(role) {
   return `souls/${role}-auditor.md`;
 }
@@ -11999,7 +12346,7 @@ function loadAuditorReferenceMaterialsFromSubjectInput(raw) {
   return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
 }
 function subjectFromSourceDirectory(sourceRunDirectory) {
-  const role = parseRunLeaf(basename9(sourceRunDirectory))?.role;
+  const role = parseRunLeaf(basename10(sourceRunDirectory))?.role;
   return isAuditorSoulRole(role) ? role : void 0;
 }
 async function readAuditorResumeBinding(admitted) {
@@ -12042,16 +12389,16 @@ var init_auditor_soul = __esm({
 // src/public-cli/machine-method-skills.ts
 import { accessSync, constants as constants2, statSync as statSync5 } from "node:fs";
 import { lstat as lstat2, mkdir as mkdir2, symlink } from "node:fs/promises";
-import { join as join20 } from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { join as join21 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
 function skillRoot(home) {
-  return join20(home, ".agents/skills");
+  return join21(home, ".agents/skills");
 }
 function installedMethodSkillPath(home, name) {
   return installedSkillPath(skillRoot(home), name);
 }
 function installedSkillPath(root, name) {
-  const path = join20(root, name, "SKILL.md");
+  const path = join21(root, name, "SKILL.md");
   try {
     if (!statSync5(path).isFile()) return void 0;
     accessSync(path, constants2.R_OK);
@@ -12064,9 +12411,9 @@ function installedSkillPath(root, name) {
 }
 function linkedSkillRoot(home, host) {
   if (host === "claude" || host === "claude-code") {
-    return join20(process.env.CLAUDE_CONFIG_DIR?.trim() || join20(home, ".claude"), "skills");
+    return join21(process.env.CLAUDE_CONFIG_DIR?.trim() || join21(home, ".claude"), "skills");
   }
-  if (host === "hermes") return join20(home, ".hermes/skills");
+  if (host === "hermes") return join21(home, ".hermes/skills");
   return void 0;
 }
 async function occupied(path) {
@@ -12094,7 +12441,7 @@ async function warnMissingMethodSkills(home, host, role, skills, stdout) {
   }
 }
 function runSkillsCli(args, home) {
-  const result = spawnSync2("npx", ["--yes", "skills", ...args], {
+  const result = spawnSync3("npx", ["--yes", "skills", ...args], {
     stdio: "inherit",
     env: { ...process.env, HOME: home }
   });
@@ -12123,7 +12470,7 @@ async function runMachineSkillSetup(home, stdout) {
   const missingBySource = /* @__PURE__ */ new Map();
   let unsourced = false;
   for (const name of packagedMethodSkillNames()) {
-    const path = join20(canonical, name);
+    const path = join21(canonical, name);
     if (await occupied(path)) {
       warnOccupied(path, stdout);
       continue;
@@ -12153,9 +12500,9 @@ async function runMachineSkillSetup(home, stdout) {
       throw error;
     }
     for (const name of packagedMethodSkillNames()) {
-      const target = join20(canonical, name);
+      const target = join21(canonical, name);
       if (installedMethodSkillPath(home, name) === void 0) continue;
-      const link = join20(root, name);
+      const link = join21(root, name);
       if (await occupied(link)) {
         warnOccupied(link, stdout);
         continue;
@@ -12215,7 +12562,8 @@ function projectRoleTurnRequest(admitted, roleDetails, options) {
     ...options.invocationScopeId === void 0 || options.invocationScopeId.length === 0 ? {} : { invocationScopeId: options.invocationScopeId },
     ...options.stationChild === void 0 ? {} : { stationChild: options.stationChild },
     ...options.navigatorByStatusPrepare === void 0 ? {} : { navigatorByStatusPrepare: options.navigatorByStatusPrepare },
-    ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit }
+    ...options.deliveryRequestLimit === void 0 ? {} : { deliveryRequestLimit: options.deliveryRequestLimit },
+    ...options.host === void 0 || options.host.trim() === "" ? {} : { host: options.host.trim() }
   };
 }
 function packagedSettleSkill(admitted) {
@@ -14183,7 +14531,7 @@ async function resolveReviewSeatDialogueBody(input) {
   if (sourceRunPath === void 0) return void 0;
   return await loadLedgerPeerBody(sourceRunPath, input.projectRoot, input.home);
 }
-async function resolveInitialPrompt(admitted, env) {
+async function resolveInitialTurnPrompt(admitted, env) {
   const record = roleRecord(admitted.role);
   if ("reaskPrompt" in record && record.reaskPrompt === true) {
     const sourceRunPath = admittedSourceRunPath(admitted);
@@ -14280,7 +14628,7 @@ async function dispatchAdmitted(admitted, env, io) {
     if (activeEnv.correlationId !== void 0 && activeEnv.correlationId.trim() !== "") {
       await recordAdmittedCorrelation(admitted, activeEnv.correlationId);
     }
-    const initialPromptText = await resolveInitialPrompt(admitted, activeEnv);
+    const initialPrompt = await resolveInitialTurnPrompt(admitted, activeEnv);
     const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
     if (auto) {
       return await runPostAdmissionResumable({
@@ -14291,14 +14639,14 @@ async function dispatchAdmitted(admitted, env, io) {
           admitted,
           roleTurnOptions(activeEnv, admitted, {
             kind: "initial",
-            prompt: initialPromptText
+            prompt: initialPrompt
           })
         ),
         buildResumeRequest: () => buildInstructionSeatTurnRequest(
           admitted,
           roleTurnOptions(activeEnv, admitted, {
             kind: "resume",
-            prompt: initialPromptText
+            prompt: initialPrompt
           })
         ),
         adapters,
@@ -14313,7 +14661,7 @@ async function dispatchAdmitted(admitted, env, io) {
         admitted,
         roleTurnOptions(activeEnv, admitted, {
           kind: "initial",
-          prompt: initialPromptText
+          prompt: initialPrompt
         })
       ),
       adapters,
@@ -14489,7 +14837,7 @@ async function runCountersignBody(parsed, env, io) {
       }
       const turnProjection = roleTurnOptions(env, admitted, {
         kind: "initial",
-        prompt: await resolveInitialPrompt(admitted, env)
+        prompt: await resolveInitialTurnPrompt(admitted, env)
       });
       const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
       const result = await runPostAdmissionOneShot({
@@ -15372,10 +15720,10 @@ var init_analyst_book_key = __esm({
 // src/atomic-write.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { rename as rename2, rm, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { dirname as dirname14, join as join22 } from "node:path";
 async function writeFileAtomically(destination, contents, options) {
   const parent = dirname14(destination);
-  const temporary = join21(parent, `.atomic-write-${randomUUID6()}.tmp`);
+  const temporary = join22(parent, `.atomic-write-${randomUUID6()}.tmp`);
   try {
     await writeFile3(temporary, contents, options);
     await rename2(temporary, destination);
@@ -15392,12 +15740,12 @@ var init_atomic_write = __esm({
 
 // src/analyst-index.ts
 import { open, readFile as readFile10, unlink } from "node:fs/promises";
-import { dirname as dirname15, join as join22 } from "node:path";
+import { dirname as dirname15, join as join23 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   const indexPath = analystLibraryIndexPath(ledgerHome);
   ensureRealDirectoryTree(ledgerHome, dirname15(indexPath));
-  const lockPath = join22(dirname15(indexPath), LIBRARY_INDEX_LOCK_NAME);
+  const lockPath = join23(dirname15(indexPath), LIBRARY_INDEX_LOCK_NAME);
   assertLedgerFileInsideHome(lockPath, ledgerHome);
   const startedAt = Date.now();
   while (true) {
@@ -15424,7 +15772,7 @@ async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   }
 }
 function analystLibraryIndexPath(ledgerHome) {
-  return join22(ledgerHome, "analyst", "library-index.json");
+  return join23(ledgerHome, "analyst", "library-index.json");
 }
 function rowFromIssueMetricsPage(page) {
   return {
@@ -15718,7 +16066,7 @@ var init_analyst_cohort = __esm({
 });
 
 // src/archivist-record-pointer.ts
-import { basename as basename10, join as join23 } from "node:path";
+import { basename as basename11, join as join24 } from "node:path";
 async function resolveOfficerPointer(raw, parentRunDirectory) {
   const where = `${parentRunDirectory} officers`;
   if (!isRecord(raw) || raw.kind !== DIRECT_OFFICER_RUN_POINTER_KIND || raw.version !== 1) {
@@ -15731,7 +16079,7 @@ async function resolveOfficerPointer(raw, parentRunDirectory) {
   let runDirectory = typeof raw.runDirectory === "string" && raw.runDirectory.trim() !== "" ? raw.runDirectory : void 0;
   let sessionFile = raw.sessionFile;
   const recordedRunDirectory = runDirectory ?? runDirectoryOfSessionFile(sessionFile);
-  const leaf = parseRunLeaf(basename10(recordedRunDirectory));
+  const leaf = parseRunLeaf(basename11(recordedRunDirectory));
   const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
   if (leaf !== void 0 && parentIdentity !== void 0) {
     const currentRunDirectory = await resolveLiveRunDirectoryPath(
@@ -15751,7 +16099,7 @@ async function resolveOfficerPointer(raw, parentRunDirectory) {
   };
 }
 async function readBookedOfficerPointers(parentRunDirectory) {
-  const { records, diagnostics } = await readSitianRecords(join23(parentRunDirectory, RUN_HISTORY_FILE));
+  const { records, diagnostics } = await readSitianRecords(join24(parentRunDirectory, RUN_HISTORY_FILE));
   if (diagnostics.length > 0) {
     throw new Error(
       `${RUN_HISTORY_FILE} has ${diagnostics.length} malformed row(s); officer pointers unreadable: ${parentRunDirectory}`
@@ -16034,7 +16382,7 @@ var init_analyst_gate_cycles_read = __esm({
 
 // src/analyst-ledger.ts
 import { readdir as readdir3 } from "node:fs/promises";
-import { basename as basename11, join as join24 } from "node:path";
+import { basename as basename12, join as join25 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
 }
@@ -16054,7 +16402,7 @@ function ghostLeaseCheckFromAutopsy(autopsy) {
   }
 }
 async function classifyGhostCandidate(input) {
-  const autopsy = await autopsyWriterLock(join24(input.runDirectory, "writer.lock"));
+  const autopsy = await autopsyWriterLock(join25(input.runDirectory, "writer.lock"));
   const leaseCheck = ghostLeaseCheckFromAutopsy(autopsy);
   if (leaseCheck === void 0) return { kind: "live" };
   return {
@@ -16344,7 +16692,7 @@ async function classifyScopedRun(input) {
 async function scanAnalystIssueRuns(input) {
   const ledgerHome = resolveActivationLedgerHome(input.home);
   const scopeTicketNumber = input.ticketNumber;
-  const booksRoot = join24(ledgerHome, "books");
+  const booksRoot = join25(ledgerHome, "books");
   let wholeBook = false;
   let scopeRootIdentity;
   let bookNames;
@@ -16377,7 +16725,7 @@ async function scanAnalystIssueRuns(input) {
   const ghostLegs = [];
   const scopeConflicts = [];
   for (const book of bookNames) {
-    const bookDir = join24(booksRoot, book);
+    const bookDir = join25(booksRoot, book);
     let runDirectories;
     try {
       runDirectories = await listBookRunDirectories(bookDir);
@@ -16386,7 +16734,7 @@ async function scanAnalystIssueRuns(input) {
       throw error;
     }
     for (const runDirectory of runDirectories) {
-      const runName = basename11(runDirectory);
+      const runName = basename12(runDirectory);
       const parsed = parseRunLeaf(runName);
       if (parsed === void 0) continue;
       let scopeFields;
@@ -17123,7 +17471,7 @@ var init_analyst_metric_family = __esm({
 });
 
 // src/analyst-page.ts
-import { dirname as dirname16, join as join25 } from "node:path";
+import { dirname as dirname16, join as join26 } from "node:path";
 function analystIssuePageKey(address) {
   const parts = ["book", address.bookKey];
   if (address.issueNumber !== void 0) {
@@ -17134,7 +17482,7 @@ function analystIssuePageKey(address) {
   return sha256Hex(parts.join("\0")).slice(0, 32);
 }
 function analystIssuePagePath(ledgerHome, address) {
-  return join25(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
+  return join26(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
 }
 function analystIssuePageAddressFromPage(page) {
   return {
@@ -18690,9 +19038,9 @@ __export(public_role_summons_exports, {
   summonPublicRole: () => summonPublicRole
 });
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { realpath as realpath6 } from "node:fs/promises";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 function createCapturingIo() {
   const chunks = [];
@@ -18716,7 +19064,7 @@ function parentDir(path) {
 function walkPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 12; i += 1) {
-    if (existsSync11(join26(dir, "package.json")) && existsSync11(join26(dir, "souls"))) {
+    if (existsSync12(join27(dir, "package.json")) && existsSync12(join27(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -19264,7 +19612,7 @@ var init_compliance_transport = __esm({
 });
 
 // src/role-run-relocation.ts
-import { dirname as dirname17, join as join27 } from "node:path";
+import { dirname as dirname17, join as join28 } from "node:path";
 async function retainedRunPathsMatch(recordedPath, currentPath, currentRunDirectory) {
   if (recordedPath === currentPath) return true;
   if (typeof recordedPath !== "string") return false;
@@ -19330,9 +19678,9 @@ __export(run_lifecycle_exports, {
   resolveLiveRunDirectoryPath: () => resolveLiveRunDirectoryPath,
   writeRoleRunState: () => writeRoleRunState
 });
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { chmod, lstat as lstat3, open as open2, readdir as readdir4, readFile as readFile14, unlink as unlink2 } from "node:fs/promises";
-import { basename as basename12, join as join28 } from "node:path";
+import { basename as basename13, join as join29 } from "node:path";
 async function writeRoleRunState(runDirectory, record) {
   const payload = { ...record, runDirectory };
   writeSectionSync(runDirectory, "runState", { ...payload });
@@ -19414,13 +19762,14 @@ async function readRoleRunStateDisk(runDirectory) {
   if (typeof record.sessionDirectory !== "string") throw new TypeError("Invalid state.jsonl run-state");
   const storedRunDirectory = typeof record.runDirectory === "string" && record.runDirectory.trim() !== "" ? record.runDirectory : runDirectory;
   const runDir = runDirectory;
+  const principalCoords = {
+    sessionDirectory: record.sessionDirectory,
+    ...typeof record.sessionFile === "string" ? { sessionFile: record.sessionFile } : {}
+  };
+  rewritePrincipalSessionPaths(principalCoords, storedRunDirectory, runDirectory);
   const principalWire = {
-    sessionDirectory: rewriteRunDirectoryPathValue(
-      record.sessionDirectory,
-      storedRunDirectory,
-      runDirectory
-    ),
-    ...typeof record.sessionFile === "string" ? { sessionFile: rewriteRunDirectoryPathValue(record.sessionFile, storedRunDirectory, runDirectory) } : {}
+    sessionDirectory: principalCoords.sessionDirectory,
+    ...typeof principalCoords.sessionFile === "string" ? { sessionFile: principalCoords.sessionFile } : {}
   };
   const phase = record.phase === "plan" || record.phase === "apply" ? record.phase : void 0;
   const currentCourt = parseCurrentCourtState(record.currentCourt);
@@ -19626,7 +19975,7 @@ async function createWriterLease(lockPath, runDirectory, reportCleanupFailure) {
     },
     relocate(nextRunDirectory) {
       currentRunDirectory = nextRunDirectory;
-      currentLockPath = join28(nextRunDirectory, WRITER_LOCK_FILE);
+      currentLockPath = join29(nextRunDirectory, WRITER_LOCK_FILE);
     },
     async release() {
       if (released) return;
@@ -19665,10 +20014,10 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
   };
   const reportReadFailure = (error) => {
     reportDiagnostic(
-      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join28(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
+      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join29(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
     );
   };
-  const lockPath = join28(runDirectory, WRITER_LOCK_FILE);
+  const lockPath = join29(runDirectory, WRITER_LOCK_FILE);
   let lastAutopsy = { verdict: "absent" };
   let lastReclaimFailure;
   for (let reclaimsLeft = WRITER_LEASE_RECLAIM_ROUNDS; ; reclaimsLeft -= 1) {
@@ -19724,7 +20073,7 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
 }
 async function findRunDirectoryById(home, runId, onlyBookKey, onlyRole, knownRunDirectory) {
   if (typeof knownRunDirectory === "string" && knownRunDirectory.trim() !== "") {
-    const parsed = parseRunLeaf(basename12(knownRunDirectory));
+    const parsed = parseRunLeaf(basename13(knownRunDirectory));
     if (parsed === void 0 || parsed.runId !== runId) {
       throw new CliUsageError(
         `run directory does not match run id ${runId}: ${knownRunDirectory}`
@@ -19734,7 +20083,7 @@ async function findRunDirectoryById(home, runId, onlyBookKey, onlyRole, knownRun
   }
   if (runId.trim() === "") return void 0;
   const ledgerHome = resolveActivationLedgerHome(home);
-  const booksRoot = join28(ledgerHome, "books");
+  const booksRoot = join29(ledgerHome, "books");
   let bookKeys;
   try {
     bookKeys = await readdir4(booksRoot);
@@ -19749,8 +20098,8 @@ async function findRunDirectoryById(home, runId, onlyBookKey, onlyRole, knownRun
   );
 }
 async function resolveLiveRunDirectoryPath(recordedPath, home, onlyBookKey) {
-  if (existsSync12(recordedPath)) return recordedPath;
-  const parsed = parseRunLeaf(basename12(recordedPath));
+  if (existsSync13(recordedPath)) return recordedPath;
+  const parsed = parseRunLeaf(basename13(recordedPath));
   const bookKey = onlyBookKey ?? tryBookKeyFromAkRolesPath(recordedPath);
   if (parsed === void 0 || bookKey === void 0) return void 0;
   return findRunDirectoryById(home, parsed.runId, bookKey, parsed.role);
@@ -19784,7 +20133,7 @@ async function findLatestRunForSeatTicket(input) {
   let runDirectories;
   try {
     runDirectories = await listBookRunDirectories(
-      input.ticketNumber === void 0 ? bookDir : join28(bookDir, String(input.ticketNumber))
+      input.ticketNumber === void 0 ? bookDir : join29(bookDir, String(input.ticketNumber))
     );
   } catch (error) {
     if (errorCodeOf(error) === "ENOENT") return void 0;
@@ -19792,7 +20141,7 @@ async function findLatestRunForSeatTicket(input) {
   }
   let best;
   for (const runDirectory of runDirectories) {
-    const parsed = parseRunLeaf(basename12(runDirectory));
+    const parsed = parseRunLeaf(basename13(runDirectory));
     if (parsed === void 0 || parsed.role !== input.role) continue;
     const runId = parsed.runId;
     const parentPath = await readRunParentPath(runDirectory);
@@ -20547,7 +20896,7 @@ init_filed_submission();
 init_report_ticket_tool();
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { writeSync as writeSync2 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 import { Value as Value3 } from "typebox/value";
 
 // src/activation-trace.ts
@@ -20597,7 +20946,7 @@ import {
   lstatSync as lstatSync2,
   realpathSync as realpathSync2,
   statSync as statSync7,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import { isAbsolute as isAbsolute10, resolve as resolve14 } from "node:path";
 var ActivationSessionFileMissingError = class extends Error {
@@ -20618,7 +20967,7 @@ function materializeDeferredSessionFile(sessionManager, resolvedFile) {
     throw new ActivationSessionFileMissingError(resolvedFile);
   }
   try {
-    writeFileSync2(resolvedFile, `${JSON.stringify(header)}
+    writeFileSync3(resolvedFile, `${JSON.stringify(header)}
 `, { flag: "wx" });
   } catch (error) {
     if (errnoCode(error) !== "EEXIST") {
@@ -20727,6 +21076,7 @@ init_engine_material();
 init_engine_detour();
 init_engine_detour_usage();
 init_run_terminal_artifacts();
+init_serialize_thrown_value();
 import { Type as Type18 } from "typebox";
 var engineDetourArgsSchema = Type18.Object(
   {
@@ -20747,6 +21097,27 @@ function isCallerCancellation(error, signal) {
 function asError(error, fallback) {
   return error instanceof Error ? error : new Error(String(error).trim() || fallback);
 }
+function engineFailureResult(input) {
+  const details = {
+    tool: ENGINE_DETOUR_TOOL_NAME,
+    ...input.code === void 0 ? {} : { code: input.code },
+    ...input.stdout === void 0 ? {} : { stdout: input.stdout },
+    ...input.stderr === void 0 ? {} : { stderr: input.stderr },
+    ...input.errorCode === void 0 ? {} : { errorCode: input.errorCode },
+    ...input.ledgerError === void 0 ? {} : { ledgerError: input.ledgerError }
+  };
+  let text = input.text;
+  if (input.ledgerError !== void 0 && input.ledgerError.length > 0) {
+    if (text.length > 0 && !text.endsWith("\n")) text += "\n";
+    text += input.ledgerError;
+  }
+  return {
+    content: [{ type: "text", text }],
+    details,
+    // Identified detour failure is a tool error, not a seat-run death (#1213).
+    isError: true
+  };
+}
 function createEngineDetourToolDefinition(input) {
   const engineName = input.engineName;
   const engineModel = input.engineModel;
@@ -20760,13 +21131,6 @@ function createEngineDetourToolDefinition(input) {
     async execute(toolCallId, params, signal, _onUpdate, ctx) {
       const args = params;
       const argv = Array.isArray(args.argv) ? args.argv : [];
-      if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
-        input.fail(
-          new Error("\u52B3\u52A1\u5F15\u64CE argv \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4"),
-          toolCallId,
-          ctx
-        );
-      }
       const sessionParent = ctx.sessionManager?.getSessionFile?.();
       const startedAt = Date.now();
       const runDirectory = typeof ctx.runDirectory === "string" && ctx.runDirectory.length > 0 ? ctx.runDirectory : void 0;
@@ -20787,25 +21151,21 @@ function createEngineDetourToolDefinition(input) {
           ...observed2.stdoutByteLength === void 0 ? {} : { stdoutByteLength: observed2.stdoutByteLength }
         });
       };
-      const failAfterLedger = (engineCause, observed2, aggregateMessage) => {
+      const recordCallOrLedgerError = (observed2) => {
         try {
           recordCall(observed2);
+          return void 0;
         } catch (recordError) {
-          input.fail(
-            new AggregateError(
-              [
-                engineCause,
-                asError(recordError, "engine detour usage ledger write failed")
-              ],
-              aggregateMessage,
-              { cause: engineCause }
-            ),
-            toolCallId,
-            ctx
-          );
+          return serializeThrownValue(recordError);
         }
-        input.fail(engineCause, toolCallId, ctx);
       };
+      if (argv.length === 0 || argv.some((part) => typeof part !== "string" || part.length === 0)) {
+        const ledgerError = recordCallOrLedgerError({});
+        return engineFailureResult({
+          text: "\u52B3\u52A1\u5F15\u64CE argv \u987B\u4E3A\u975E\u7A7A\u5B57\u7B26\u4E32\u6570\u7EC4",
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
+      }
       let result;
       try {
         result = await runEngineDetourOnce({
@@ -20815,20 +21175,26 @@ function createEngineDetourToolDefinition(input) {
         });
       } catch (error) {
         if (isCallerCancellation(error, signal)) throw error;
-        return failAfterLedger(
-          asError(error, "\u52B3\u52A1\u5F15\u64CE spawn \u5931\u8D25"),
-          {},
-          "engine detour spawn and usage ledger both failed"
-        );
+        const engineError = asError(error, "\u52B3\u52A1\u5F15\u64CE spawn \u5931\u8D25");
+        const ledgerError = recordCallOrLedgerError({});
+        const errno = typeof engineError.code === "string" ? engineError.code : void 0;
+        return engineFailureResult({
+          text: engineError.message,
+          ...errno === void 0 ? {} : { errorCode: errno },
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
       }
       const stdoutByteLength = engineDetourStdoutByteLength(result.stdout);
       const observed = { code: result.code, stdoutByteLength };
       if (isEngineDetourFailure(result)) {
-        return failAfterLedger(
-          new Error(engineDetourFailureDiagnostic(result)),
-          observed,
-          "engine detour child-close and usage ledger both failed"
-        );
+        const ledgerError = recordCallOrLedgerError(observed);
+        return engineFailureResult({
+          text: engineDetourFailureSeatText(result),
+          code: result.code,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          ...ledgerError === void 0 ? {} : { ledgerError }
+        });
       }
       recordCall(observed);
       return {
@@ -20842,7 +21208,7 @@ function createEngineDetourToolDefinition(input) {
     }
   };
 }
-function registerEngineDetourTool(roleHost, hostActions) {
+function registerEngineDetourTool(roleHost) {
   const getFlag = (name) => roleHost.getFlag(name);
   const engineName = resolveEngineName(getFlag);
   if (engineName === void 0) {
@@ -20851,10 +21217,7 @@ function registerEngineDetourTool(roleHost, hostActions) {
   const engineModel = resolveEngineModel(getFlag);
   const definition = createEngineDetourToolDefinition({
     engineName,
-    ...engineModel === void 0 ? {} : { engineModel },
-    fail(error, toolCallId, ctx) {
-      hostActions.failInfrastructure(error, ctx, toolCallId);
-    }
+    ...engineModel === void 0 ? {} : { engineModel }
   });
   roleHost.registerTool(definition);
   return true;
@@ -21054,10 +21417,10 @@ init_run_ticket_number();
 
 // src/audited-run-identity.ts
 init_role_run_placement();
-import { basename as basename13 } from "node:path";
+import { basename as basename14 } from "node:path";
 var AUDITED_RUN_IDENTITY_KIND = "audited-run-identity";
 function auditedRunIdentityFromDirectory(runDirectory) {
-  const parsed = parseRunLeaf(basename13(runDirectory));
+  const parsed = parseRunLeaf(basename14(runDirectory));
   if (parsed === void 0) return void 0;
   return formatRunLeaf(parsed.runId, parsed.role);
 }
@@ -21236,7 +21599,7 @@ import "typebox";
 
 // src/navigator-public-session.ts
 init_host_session_record();
-import { basename as basename14 } from "node:path";
+import { basename as basename15 } from "node:path";
 
 // src/navigator-session-contracts.ts
 init_unknown_value();
@@ -21440,7 +21803,7 @@ async function resolveNavigatorLedgerHome(context) {
   return void 0;
 }
 function runIdFromNavigatorDirectory(runDirectory) {
-  const parsed = parseRunLeaf(basename14(runDirectory));
+  const parsed = parseRunLeaf(basename15(runDirectory));
   if (parsed === void 0 || parsed.role !== "navigator") return void 0;
   return parsed.runId;
 }
@@ -22071,7 +22434,7 @@ init_unknown_value();
 init_submission_errors();
 init_worker_submission_contracts();
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync13, lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, rmdirSync, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync14, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync4 } from "node:fs";
 import { resolve as resolve16 } from "node:path";
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
 var WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE = "commit-reminder-bounce";
@@ -22101,7 +22464,7 @@ function statusOf(error) {
   return typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
 }
 function tryGetAll(file, key) {
-  if (!existsSync13(file)) return [];
+  if (!existsSync14(file)) return [];
   try {
     const out = gitFile(file, ["--get-all", key]);
     return out.length === 0 ? [] : out.split("\n");
@@ -22111,8 +22474,8 @@ function tryGetAll(file, key) {
   }
 }
 function ownedHook(path) {
-  if (!existsSync13(path)) return false;
-  return readFileSync4(path, "utf8").includes(HOOK_MARKER);
+  if (!existsSync14(path)) return false;
+  return readFileSync5(path, "utf8").includes(HOOK_MARKER);
 }
 function escapeGitConfigValueRegex(value) {
   return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
@@ -22137,13 +22500,13 @@ function unsetOwnedHooksPath(file) {
 function rmOwnedDir(dir) {
   const hookPath = resolve16(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
-  rmSync3(hookPath, { force: true });
-  if (existsSync13(dir) && readdirSync3(dir).length === 0) rmdirSync(dir);
+  rmSync4(hookPath, { force: true });
+  if (existsSync14(dir) && readdirSync4(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
   const root = resolve16(commonDir, "worktrees");
-  if (!existsSync13(root)) return [];
-  return readdirSync3(root).map((name) => resolve16(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
+  if (!existsSync14(root)) return [];
+  return readdirSync4(root).map((name) => resolve16(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
   let inside;
@@ -22161,7 +22524,7 @@ function uninstallPackageWorkerHooks(cwd) {
   clear(resolve16(commonDir, "config.worktree"));
   rmOwnedDir(resolve16(commonDir, HOOKS_DIR));
   const legacy = resolve16(commonDir, "hooks", HOOK_FILE);
-  if (ownedHook(legacy)) rmSync3(legacy, { force: true });
+  if (ownedHook(legacy)) rmSync4(legacy, { force: true });
   for (const gitDir of linkedGitDirs(commonDir)) {
     clear(resolve16(gitDir, "config.worktree"));
     rmOwnedDir(resolve16(gitDir, HOOKS_DIR));
@@ -22239,11 +22602,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 sep5 = line2.indexOf("");
-    if (sep5 < 0) return [];
+    const sep6 = line2.indexOf("");
+    if (sep6 < 0) return [];
     return [{
-      subject: line2.slice(sep5 + 1),
-      merge: line2.slice(0, sep5).trim().includes(" ")
+      subject: line2.slice(sep6 + 1),
+      merge: line2.slice(0, sep6).trim().includes(" ")
     }];
   });
 }
@@ -22981,7 +23344,7 @@ function readRoleRunCoordinates(ctx, label) {
   if (runDirectory === void 0) throw new Error(`${label} requires AK_ROLE_RUN_DIR`);
   const admitted = readPageSync(runDirectory, "admitted");
   if (typeof admitted?.projectRoot !== "string" || admitted.projectRoot.trim() === "") {
-    throw new Error(`${label} state.jsonl admitted-request row missing projectRoot (${join30(runDirectory, RUN_STATE_FILE)})`);
+    throw new Error(`${label} state.jsonl admitted-request row missing projectRoot (${join31(runDirectory, RUN_STATE_FILE)})`);
   }
   return {
     runDirectory,
@@ -23247,7 +23610,10 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         settleNavigatorProjection
       );
     };
-    roleHost.on("input", (_event) => {
+    roleHost.on("input", (event, ctx) => {
+      if (typeof event.text === "string" && ctx.summonsInstruction === void 0) {
+        ctx.summonsInstruction = event.text;
+      }
       const role = roleHost.getFlag(ROLE_FLAG.name);
       if (role !== void 0 && !admitted) return { action: "handled" };
       return { action: "continue" };
@@ -23402,6 +23768,8 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
       }
       if (receiptDelivery.nextAction() === "request-delivery") {
         receiptDelivery.recordDeliveryRequest();
+        const deliveryContent = turnDialoguePrompt ?? "";
+        ctx.summonsInstruction = deliveryContent;
         const scopeId = ctx.invocationScopeId?.trim() ?? "";
         envelopeHost.appendEntry(
           RECEIPT_DELIVERY_REQUEST_ENTRY,
@@ -23417,7 +23785,7 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         });
         envelopeHost.sendMessage({
           customType: "ak-receipt-delivery-prompt",
-          content: turnDialoguePrompt ?? "",
+          content: deliveryContent,
           display: false
         }, { triggerTurn: true, deliverAs: "followUp" });
       } else if (receiptDelivery.nextAction() === "no-receipt" && !noReceiptRecorded) {
@@ -23785,7 +24153,7 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
         ]);
         roleReferenceMaterials = await dependencies.loadRoleReferenceMaterials?.(entry.role) ?? "";
         if (!engineDetourRegistered) {
-          engineDetourRegistered = registerEngineDetourTool(roleHost, hostActions);
+          engineDetourRegistered = registerEngineDetourTool(roleHost);
         }
         if (secretariat.claimsEngineDetour === true && engineDetourRegistered) {
           roleHost.setActiveTools([
@@ -24158,7 +24526,7 @@ async function prepareRoleEnvelope(options) {
       const projected = await projectToolResult(toolCallId, name, {
         content: result.content,
         details: result.details,
-        isError: false
+        isError: result.isError === true
       });
       if (result.terminate === false) {
         rejection = {
@@ -24349,6 +24717,7 @@ async function prepareRoleEnvelope(options) {
       const record = value;
       if (record.action === "transform" && typeof record.text === "string") prompt = record.text;
     }
+    context.summonsInstruction = prompt;
     if (typeof prompt === "string" && prompt.trim() !== "") {
       sessionEntries.push({
         type: "message",
@@ -24390,6 +24759,9 @@ async function prepareRoleEnvelope(options) {
       }],
       systemPrompt: { body: systemPromptBody, materials: readingMaterials },
       prompt,
+      recordSentInstruction(text) {
+        context.summonsInstruction = text;
+      },
       abortSignal: hostAbort.signal,
       closeRound,
       dispose,
@@ -24970,12 +25342,12 @@ function createAcpRoleTurnHost(config) {
 // src/acp-host/seat-profile-soul.ts
 import { constants as constants3 } from "node:fs";
 import { access as access3, copyFile, lstat as lstat4, mkdir as mkdir4, readlink, symlink as symlink2, unlink as unlink3 } from "node:fs/promises";
-import { dirname as dirname20, join as join31, relative as relative3, resolve as resolve18 } from "node:path";
+import { dirname as dirname20, join as join32, relative as relative4, resolve as resolve18 } from "node:path";
 function seatProfileName(spec, role) {
   return `${spec.namePrefix}${role}`;
 }
 function packageRoleSoulPath(packageRoot, role) {
-  return join31(packageRoot, "souls", `${role}.md`);
+  return join32(packageRoot, "souls", `${role}.md`);
 }
 async function pathExists2(path) {
   try {
@@ -24992,21 +25364,21 @@ async function ensureSeatProfileSoul(options) {
   if (!await pathExists2(soulTarget)) {
     throw new Error(`packaged role soul missing: ${soulTarget}`);
   }
-  const profilesRoot = join31(operatorHome, ...spec.profilesRootFromHome);
-  const profileDir = join31(profilesRoot, profileName);
+  const profilesRoot = join32(operatorHome, ...spec.profilesRootFromHome);
+  const profileDir = join32(profilesRoot, profileName);
   const hostRoot = dirname20(profilesRoot);
-  const soulPath = join31(profileDir, spec.soulFileName);
+  const soulPath = join32(profileDir, spec.soulFileName);
   if (!await pathExists2(profileDir)) {
     await mkdir4(profileDir, { recursive: true });
     for (const name of ["auth.json", ".env", "config.yaml"]) {
-      const source = join31(hostRoot, name);
+      const source = join32(hostRoot, name);
       if (!await pathExists2(source)) continue;
-      await copyFile(source, join31(profileDir, name));
+      await copyFile(source, join32(profileDir, name));
     }
   } else {
     await mkdir4(profileDir, { recursive: true });
   }
-  const desiredLink = relative3(profileDir, soulTarget);
+  const desiredLink = relative4(profileDir, soulTarget);
   let current;
   try {
     const st = await lstat4(soulPath);