@akagilnc/pi-workflow-roles 0.1.5614 → 0.1.5650

package/dist/public-cli/main.js

@@ -572,6 +572,7 @@ __export(activation_ledger_topology_exports, {
   physicallyContainedIn: () => physicallyContainedIn,
   resolveActivationLedgerHome: () => resolveActivationLedgerHome,
   resolveActivationLedgerHomeForPath: () => resolveActivationLedgerHomeForPath,
+  tryBookKeyFromAkRolesPath: () => tryBookKeyFromAkRolesPath,
   tryHomeFromAkRolesPath: () => tryHomeFromAkRolesPath
 });
 import {
@@ -593,6 +594,17 @@ function tryHomeFromAkRolesPath(path) {
   }
   return path.slice(0, match.index);
 }
+function tryBookKeyFromAkRolesPath(path) {
+  const home = tryHomeFromAkRolesPath(path);
+  if (home === void 0 || home.length === 0) return void 0;
+  const booksRoot = join2(resolveActivationLedgerHome(home), "books");
+  const rel = relative(booksRoot, resolve2(path));
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute2(rel)) {
+    return void 0;
+  }
+  const bookKey = rel.split(sep)[0];
+  return bookKey === void 0 || bookKey === "" ? void 0 : bookKey;
+}
 function homeFromRunDirectory(runDirectory) {
   const home = tryHomeFromAkRolesPath(runDirectory);
   if (home === void 0 || home.length === 0) {
@@ -1483,8 +1495,7 @@ function roleRunPlacement(ledgerHome, input) {
   return {
     runDirectory,
     sessionDirectory,
-    sessionFile: sessionFileIn(sessionDirectory),
-    attachmentsDirectory: join6(runDirectory, "attachments")
+    sessionFile: sessionFileIn(sessionDirectory)
   };
 }
 function isUnboundRunDirectory(runDirectory) {
@@ -14937,15 +14948,9 @@ async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
   }
   await rename(oldRunDirectory, target.runDirectory);
   heldLease?.relocate(target.runDirectory);
-  const admittedRecord = admitted;
-  rewriteRunDirectoryPathFields(
-    admittedRecord,
-    [
-      "runDirectory",
-      "mergerInputPath"
-    ],
-    oldRunDirectory,
-    target.runDirectory
+  rewriteAdmittedRoleRunPage(
+    admitted,
+    [{ oldRunDirectory, newRunDirectory: target.runDirectory }]
   );
   admitted.principal = principal;
   renderCurrentSync(target.runDirectory);
@@ -15576,7 +15581,6 @@ async function placeRoleAdmission(options) {
     sessionDirectory,
     sessionFile,
     runDirectory,
-    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
@@ -15597,7 +15601,6 @@ async function placeRoleAdmission(options) {
     sessionDirectory,
     sessionFile,
     attachments,
-    attachmentsDirectory,
     ledgerHome,
     ticketFields
   };
@@ -16322,19 +16325,24 @@ function roleOutcomeFromRows(role, rows) {
   if (terminal.length === 0) return void 0;
   const payloads = mine.map((row) => row.accepted);
   const latest = terminal[terminal.length - 1];
+  const submissionToolCallId = typeof latest.toolCallId === "string" && latest.toolCallId.length > 0 ? latest.toolCallId : void 0;
+  const belonging = submissionToolCallId === void 0 ? {} : { submissionToolCallId };
   if (latest.kind === "audit-escalation") {
     return {
-      kind: "audit_escalation",
-      role,
-      status: "audit_escalation",
-      payloads,
-      ...Object.hasOwn(latest, "auditReceipt") ? { decisiveFacts: {
-        auditEscalationReceipt: latest.auditReceipt,
-        ...Object.hasOwn(latest, "auditOfficer") ? { auditEscalationOfficer: latest.auditOfficer } : {}
-      } } : {}
+      outcome: {
+        kind: "audit_escalation",
+        role,
+        status: "audit_escalation",
+        payloads,
+        ...Object.hasOwn(latest, "auditReceipt") ? { decisiveFacts: {
+          auditEscalationReceipt: latest.auditReceipt,
+          ...Object.hasOwn(latest, "auditOfficer") ? { auditEscalationOfficer: latest.auditOfficer } : {}
+        } } : {}
+      },
+      ...belonging
     };
   }
-  return { kind: "accepted", role, payloads };
+  return { outcome: { kind: "accepted", role, payloads }, ...belonging };
 }
 async function sealedLedgerOutcome(admitted, role, scope) {
   const home = sealedLedgerHome(admitted);
@@ -16969,8 +16977,8 @@ function entriesOf(read) {
 }
 async function settleSealedSeat(admitted, authority, scope, options) {
   const coordinates = coordinatesFromAdmitted(authority, admitted);
-  const roleOutcome = await sealedLedgerOutcome(admitted, admitted.role, scope);
-  if (roleOutcome === void 0 || options.acceptedOnly && roleOutcome.kind !== "accepted") {
+  const settled = await sealedLedgerOutcome(admitted, admitted.role, scope);
+  if (settled === void 0 || options.acceptedOnly && settled.outcome.kind !== "accepted") {
     return void 0;
   }
   const read = await readLawfulSettlementEntries(coordinates.sessionFile);
@@ -16981,15 +16989,23 @@ async function settleSealedSeat(admitted, authority, scope, options) {
       `session read failed beside lawful terminal: ${describeErrorIdentity(read.error)}`
     );
   }
-  return finishLawfulSeat(admitted, coordinates, entriesOf(read), roleOutcome, scope);
+  return finishLawfulSeat(
+    admitted,
+    coordinates,
+    entriesOf(read),
+    settled.outcome,
+    scope,
+    settled.submissionToolCallId
+  );
 }
-async function finishLawfulSeat(admitted, coordinates, entries, roleOutcome, scope) {
+async function finishLawfulSeat(admitted, coordinates, entries, roleOutcome, scope, submissionToolCallId) {
   const artifacts = scope?.previewOnly === true ? [] : await publishDeclaredSeatTerminal(admitted, roleOutcome, coordinates, entries, scope);
   const terminal = await attachEngineDetourToolUsage({
     roleOutcome,
     navigator: extractNavigatorFact(entries),
     artifacts,
-    runId: admitted.runId
+    runId: admitted.runId,
+    ...submissionToolCallId === void 0 || submissionToolCallId.length === 0 ? {} : { submissionToolCallId }
   }, coordinates.sessionDirectory, detourUsageContext(admitted, scope));
   return attachRecordedSubmissions(admitted, terminal, scope);
 }
@@ -17341,6 +17357,77 @@ var init_settlement = __esm({
   }
 });
 
+// src/external-host-turn-loop.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { basename as basename8 } from "node:path";
+async function resolveLiveRunDirectoryPath(recordedPath, home) {
+  if (existsSync5(recordedPath)) return recordedPath;
+  const parsed = parseRunLeaf(basename8(recordedPath));
+  const bookKey = tryBookKeyFromAkRolesPath(recordedPath);
+  if (parsed === void 0 || bookKey === void 0) return void 0;
+  return await findRunDirectoryById(
+    home,
+    parsed.runId,
+    bookKey,
+    parsed.role
+  );
+}
+async function syncTurnRequestLivePlacement(request) {
+  const live = await resolveLiveRunDirectoryPath(request.runDirectory, request.home);
+  if (live === void 0) {
+    const parsed = parseRunLeaf(basename8(request.runDirectory));
+    throw new Error(
+      `admitted run ${parsed?.runId ?? "(unparseable)"} missing after host turn; not found under ${request.home}`
+    );
+  }
+  if (live !== request.runDirectory) {
+    projectTurnRequestLiveRunDirectory(
+      request,
+      live
+    );
+  }
+  return live;
+}
+async function trySyncTurnRequestLivePlacement(request) {
+  try {
+    return { runDirectory: await syncTurnRequestLivePlacement(request) };
+  } catch (resolveError) {
+    return { resolveError };
+  }
+}
+async function retainPackageFaultBesideLivePlacement(request, input) {
+  const live = await trySyncTurnRequestLivePlacement(request);
+  if ("resolveError" in live) {
+    const resolveDiagnostic = `live run path resolve failed beside fault: ${describeErrorIdentity(live.resolveError)}`;
+    try {
+      process.stderr.write(`${input.diagnostic}
+`);
+      process.stderr.write(`${resolveDiagnostic}
+`);
+    } catch {
+    }
+    return;
+  }
+  await retainPackageFault({
+    runDirectory: live.runDirectory,
+    diagnostic: input.diagnostic,
+    ...Object.hasOwn(input, "error") ? { error: input.error } : {}
+  });
+}
+var init_external_host_turn_loop = __esm({
+  "src/external-host-turn-loop.ts"() {
+    "use strict";
+    init_activation_ledger_topology();
+    init_settlement();
+    init_run_lifecycle();
+    init_receipt_delivery_policy();
+    init_role_run_placement();
+    init_role_run_relocation();
+    init_sitian_facade();
+    init_submission_errors();
+  }
+});
+
 // src/session-identity.ts
 import { dirname as dirname11, join as join15 } from "node:path";
 function createSessionIdentityAuthority(authority, hostName) {
@@ -17420,6 +17507,7 @@ __export(role_turn_host_exports, {
 });
 import { execFile as execFile2, spawn } from "node:child_process";
 import { constants as constants2 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { access as access2, appendFile, realpath as realpath4 } from "node:fs/promises";
 import { delimiter as delimiter2, dirname as dirname12, isAbsolute as isAbsolute6, join as join16, resolve as resolve10 } from "node:path";
 import { platform } from "node:process";
@@ -17605,7 +17693,32 @@ function createDefaultPiSpawnRunner(options) {
           if (stdinDeliveryError !== void 0) packageErrors.push(stdinDeliveryError);
           for (const error of packageErrors) {
             const diagnostic = `Pi transport handling failed beside host terminal: ${describeErrorIdentity(error)}`;
-            const runDirectory = spawnOptions.env.AK_ROLE_RUN_DIR;
+            const spawnDir = spawnOptions.env.AK_ROLE_RUN_DIR;
+            let runDirectory;
+            if (typeof spawnDir === "string" && spawnDir.trim() !== "") {
+              try {
+                runDirectory = await resolveLiveRunDirectoryPath(
+                  spawnDir,
+                  homeFromRunDirectory(spawnDir)
+                );
+              } catch (resolveError) {
+                runDirectory = existsSync6(spawnDir) ? spawnDir : void 0;
+                const resolveDiagnostic = `live run path resolve failed beside Pi transport fault: ${describeErrorIdentity(resolveError)}`;
+                if (runDirectory !== void 0) {
+                  await retainPackageFault({
+                    runDirectory,
+                    diagnostic: resolveDiagnostic,
+                    error: resolveError
+                  });
+                } else {
+                  try {
+                    process.stderr.write(`${resolveDiagnostic}
+`);
+                  } catch {
+                  }
+                }
+              }
+            }
             if (runDirectory !== void 0) {
               await retainPackageFault({ runDirectory, diagnostic, error });
             } else {
@@ -17687,6 +17800,7 @@ function createPiRoleTurnHost(config) {
         ...request.signal === void 0 ? {} : { signal: request.signal }
       });
       try {
+        await syncTurnRequestLivePlacement(request);
         const { sessionFile, sessionDirectory } = config.principalAuthority.decode(request.principal);
         const sessionId = await readPiSessionHeaderId(sessionFile);
         if (sessionId !== void 0) {
@@ -17704,8 +17818,7 @@ function createPiRoleTurnHost(config) {
           });
         }
       } catch (error) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
+        await retainPackageFaultBesideLivePlacement(request, {
           diagnostic: `pi host dossier record failed beside host terminal: ${describeErrorIdentity(error)}`,
           error
         });
@@ -17774,6 +17887,8 @@ var init_role_turn_host = __esm({
     init_user_dialogue_stdin();
     init_ledger_session_read();
     init_host_session_record();
+    init_external_host_turn_loop();
+    init_activation_ledger_topology();
     init_settlement();
     init_run_lifecycle();
     init_receipt_delivery_policy();
@@ -17793,7 +17908,7 @@ var init_role_turn_host = __esm({
 });
 
 // src/public-cli/load-production-acp-host.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { join as join17 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadProductionAcpHostFactory(packageRoot2, host) {
@@ -17803,7 +17918,7 @@ async function loadProductionAcpHostFactory(packageRoot2, host) {
   }
   const built = join17(packageRoot2, "dist/acp-host/production-host.js");
   const source = join17(packageRoot2, "src/acp-host/production-host.ts");
-  const target = existsSync5(built) ? built : source;
+  const target = existsSync7(built) ? built : source;
   const href = pathToFileURL(target).href;
   const mod = await import(href);
   const create = mod.createProductionAcpRoleTurnHost;
@@ -17817,7 +17932,7 @@ var init_load_production_acp_host = __esm({
 });
 
 // src/public-cli/load-production-headless-host.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { join as join18 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function loadProductionHeadlessHostFactory(packageRoot2, host) {
@@ -17827,7 +17942,7 @@ async function loadProductionHeadlessHostFactory(packageRoot2, host) {
   }
   const built = join18(packageRoot2, "dist/headless-host/production-host.js");
   const source = join18(packageRoot2, "src/headless-host/production-host.ts");
-  const target = existsSync6(built) ? built : source;
+  const target = existsSync8(built) ? built : source;
   const href = pathToFileURL2(target).href;
   const mod = await import(href);
   const create = mod.createProductionHeadlessRoleTurnHost;
@@ -17993,8 +18108,78 @@ var init_role_seat_runtime = __esm({
   }
 });
 
+// src/report-ticket-tool.ts
+var reportTicketArgsSchema, MISSING_TICKET_REASK_MATERIAL;
+var init_report_ticket_tool = __esm({
+  "src/report-ticket-tool.ts"() {
+    "use strict";
+    init_build();
+    init_host_contracts();
+    init_durable_principal();
+    init_invocation();
+    init_role_run_placement();
+    init_run_dossier();
+    init_run_ticket_number();
+    init_unknown_value();
+    reportTicketArgsSchema = typebox_exports.Object(
+      {
+        ticketNumber: typebox_exports.Unknown({
+          description: "\u672C\u7968\u53F7\uFF08\u6B63\u6574\u6570\u3001\u6570\u5B57\u4E32\u6216\u524D\u5BFC #N\uFF09\u3002\u5DF2\u77E5\u7968\u53F7\u65F6\u5F00\u5DE5\u5373\u62A5\uFF1B\u5C1A\u65E0\u7968\u53F7\u65F6\u4E0D\u8981\u8C03\u7528\u3002"
+        })
+      },
+      { additionalProperties: true }
+    );
+    MISSING_TICKET_REASK_MATERIAL = "resources/missing-ticket-reask.md";
+  }
+});
+
+// src/session-opening-materials.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile9 } from "node:fs/promises";
+import { dirname as dirname13, join as join19 } from "node:path";
+import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
+function resolvePackageRootDir(moduleUrl = import.meta.url) {
+  let dir = dirname13(fileURLToPath(moduleUrl));
+  for (let i = 0; i < 8; i += 1) {
+    if (existsSync9(join19(dir, "package.json")) && existsSync9(join19(dir, "souls"))) {
+      return dir;
+    }
+    const parent = dirname13(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return fileURLToPath(new URL("..", moduleUrl));
+}
+async function readPackageMaterial(relativePath) {
+  return readFile9(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
+}
+async function joinPackageMaterials(relativePaths) {
+  const chunks = [];
+  for (const relativePath of relativePaths) chunks.push(await readPackageMaterial(relativePath));
+  return chunks.join("\n\n");
+}
+var packageRootUrl, MAIN_ROLE_SESSION_MATERIALS, GATEKEEPER_SESSION_MATERIALS;
+var init_session_opening_materials = __esm({
+  "src/session-opening-materials.ts"() {
+    "use strict";
+    init_packaged_role_registry();
+    packageRootUrl = pathToFileURL3(resolvePackageRootDir() + "/").href;
+    MAIN_ROLE_SESSION_MATERIALS = {
+      ...Object.fromEntries(
+        PUBLIC_ROLE_RECORDS.map((record) => [record.role, record.sessionMaterials])
+      )
+    };
+    GATEKEEPER_SESSION_MATERIALS = {
+      // #639: single authority — the public gatekeeper record owns the province list.
+      gatekeeper: packagedRoleSessionMaterials("gatekeeper"),
+      inspector: INSPECTOR_SESSION_MATERIALS,
+      notary: NOTARY_SESSION_MATERIALS
+    };
+  }
+});
+
 // src/archivist-record-pointer.ts
-import { basename as basename8, join as join19 } from "node:path";
+import { basename as basename9, join as join20 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
@@ -18020,7 +18205,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(basename8(recordedRunDirectory));
+  const leaf = parseRunLeaf(basename9(recordedRunDirectory));
   const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
   if (leaf !== void 0 && parentIdentity !== void 0) {
     const currentRunDirectory = await findRunDirectoryById(
@@ -18043,7 +18228,7 @@ async function resolveOfficerPointer(raw, parentRunDirectory) {
   };
 }
 async function readBookedOfficerPointers(parentRunDirectory) {
-  const { records, diagnostics } = await readSitianRecords(join19(parentRunDirectory, RUN_HISTORY_FILE));
+  const { records, diagnostics } = await readSitianRecords(join20(parentRunDirectory, RUN_HISTORY_FILE));
   if (diagnostics.length > 0) {
     throw new Error(
       `${RUN_HISTORY_FILE} has ${diagnostics.length} malformed row(s); officer pointers unreadable: ${parentRunDirectory}`
@@ -18334,51 +18519,6 @@ var init_submission_gate = __esm({
   }
 });
 
-// src/session-opening-materials.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { readFile as readFile9 } from "node:fs/promises";
-import { dirname as dirname13, join as join20 } from "node:path";
-import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
-function resolvePackageRootDir(moduleUrl = import.meta.url) {
-  let dir = dirname13(fileURLToPath(moduleUrl));
-  for (let i = 0; i < 8; i += 1) {
-    if (existsSync7(join20(dir, "package.json")) && existsSync7(join20(dir, "souls"))) {
-      return dir;
-    }
-    const parent = dirname13(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return fileURLToPath(new URL("..", moduleUrl));
-}
-async function readPackageMaterial(relativePath) {
-  return readFile9(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
-}
-async function joinPackageMaterials(relativePaths) {
-  const chunks = [];
-  for (const relativePath of relativePaths) chunks.push(await readPackageMaterial(relativePath));
-  return chunks.join("\n\n");
-}
-var packageRootUrl, MAIN_ROLE_SESSION_MATERIALS, GATEKEEPER_SESSION_MATERIALS;
-var init_session_opening_materials = __esm({
-  "src/session-opening-materials.ts"() {
-    "use strict";
-    init_packaged_role_registry();
-    packageRootUrl = pathToFileURL3(resolvePackageRootDir() + "/").href;
-    MAIN_ROLE_SESSION_MATERIALS = {
-      ...Object.fromEntries(
-        PUBLIC_ROLE_RECORDS.map((record) => [record.role, record.sessionMaterials])
-      )
-    };
-    GATEKEEPER_SESSION_MATERIALS = {
-      // #639: single authority — the public gatekeeper record owns the province list.
-      gatekeeper: packagedRoleSessionMaterials("gatekeeper"),
-      inspector: INSPECTOR_SESSION_MATERIALS,
-      notary: NOTARY_SESSION_MATERIALS
-    };
-  }
-});
-
 // src/auditor-soul.ts
 var auditor_soul_exports = {};
 __export(auditor_soul_exports, {
@@ -18394,7 +18534,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`;
 }
@@ -18430,7 +18570,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(runDirectory) {
@@ -18977,10 +19117,14 @@ function unreadablePostSubmissionStatus(admitted, terminal) {
   const status = receivedDiscriminator(payload, "status");
   return typeof status === "string" && route.statuses.has(status) ? void 0 : route.reask ?? officerConclusionReask(status);
 }
+function withoutSoftTicketReaskTurn(env) {
+  const { softTicketReaskTurn: _softTicketReaskTurn, ...rest } = env;
+  return rest;
+}
 function withUnreadableReask(env) {
   const spent = env.unreadableReasksSpent ?? 0;
   if (spent >= deliveryLimitFromConfig(env.autoResumeLimit)) return void 0;
-  return { ...env, unreadableReasksSpent: spent + 1 };
+  return { ...withoutSoftTicketReaskTurn(env), unreadableReasksSpent: spent + 1 };
 }
 function isUnreadableReaskExhausted(value) {
   return value === UNREADABLE_REASK_EXHAUSTED;
@@ -19039,6 +19183,110 @@ async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io,
     io
   );
 }
+async function reaskMissingTicketOnce(admitted, terminal, env, io) {
+  if ((env.ticketReasksSpent ?? 0) >= 1) return { kind: "none" };
+  if (admitted.ticketNumber !== void 0) return { kind: "none" };
+  if (!isUnboundRunDirectory(admitted.runDirectory)) return { kind: "none" };
+  if (terminal?.roleOutcome.kind !== "accepted" && terminal?.roleOutcome.kind !== "audit_escalation") {
+    return { kind: "none" };
+  }
+  const payloads = terminal.roleOutcome.payloads ?? [];
+  if (payloads.length === 0) return { kind: "none" };
+  const instruction = (await readPackageMaterial(MISSING_TICKET_REASK_MATERIAL)).trim();
+  const softTicketReaskOwnership = { sealedSubstitute: false };
+  const softReaskEnv = {
+    ...env,
+    ticketReasksSpent: 1,
+    softTicketReaskTurn: true,
+    softTicketReaskOwnership
+  };
+  const result = await runPublicInstructionSeatResume(
+    { runId: admitted.runId, summons: { instruction } },
+    softReaskEnv,
+    io
+  );
+  if (softTicketReaskOwnership.sealedSubstitute || terminalCarriesSealedSubmission(result.terminal)) {
+    return { kind: "nested_owns", result };
+  }
+  return { kind: "no_substitute", result };
+}
+function envForCourtContinue(env) {
+  return { ...withoutSoftTicketReaskTurn(env), unreadableReasksSpent: 0 };
+}
+function terminalCarriesSealedSubmission(terminal) {
+  const kind = terminal?.roleOutcome.kind;
+  if (kind !== "accepted" && kind !== "audit_escalation") return false;
+  return (terminal?.roleOutcome.payloads ?? []).length > 0;
+}
+function projectKeptOriginalArtifactsOntoLiveAdmitted(original, kept) {
+  const oldRunDirectory = original.admitted?.runDirectory;
+  const newRunDirectory = kept.admitted?.runDirectory;
+  if (oldRunDirectory === void 0 || newRunDirectory === void 0 || oldRunDirectory === newRunDirectory || kept.terminal === void 0) {
+    return;
+  }
+  for (const artifact of kept.terminal.artifacts) {
+    artifact.path = rewriteRunDirectoryPathValue(
+      artifact.path,
+      oldRunDirectory,
+      newRunDirectory
+    );
+  }
+}
+function mergeMissingTicketReaskKeepOriginal(original, ticketReask) {
+  if (ticketReask.exitCode !== 0) return ticketReask;
+  const admitted = ticketReask.admitted ?? original.admitted;
+  if (admitted === void 0) return { ...original };
+  const kept = { ...original, admitted };
+  projectKeptOriginalArtifactsOntoLiveAdmitted(original, kept);
+  return kept;
+}
+async function continueAfterPostSubmissionGuards(result, admittedRole, env, io, held) {
+  const live = result.admitted;
+  if (live === void 0) {
+    await presentOriginalVolume(held, result.terminal, io);
+    return result;
+  }
+  const unreadableReask = await reaskUnreadablePostSubmissionStatus(
+    live,
+    result.terminal,
+    env,
+    io
+  );
+  let afterStatus = result;
+  if (isUnreadableReaskExhausted(unreadableReask)) {
+    const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
+    afterStatus = terminal === void 0 ? { ...result, admitted: live } : { ...result, admitted: live, terminal };
+  } else if (unreadableReask !== void 0) {
+    return unreadableReask;
+  }
+  const forTicket = afterStatus.admitted ?? live;
+  const softReask = await reaskMissingTicketOnce(
+    forTicket,
+    afterStatus.terminal ?? result.terminal,
+    env,
+    io
+  );
+  if (softReask.kind === "nested_owns") {
+    return softReask.result;
+  }
+  const continued = softReask.kind === "none" ? afterStatus : mergeMissingTicketReaskKeepOriginal(afterStatus, softReask.result);
+  const continuedAdmitted = continued.admitted ?? live;
+  const continuedEnv = softReask.kind !== "none" ? { ...env, ticketReasksSpent: 1 } : env;
+  if (AUDITED_ROLES.has(admittedRole) && continued.terminal?.roleOutcome.kind === "accepted") {
+    return auditSubmittedRole(
+      { ...continued, admitted: continuedAdmitted },
+      continuedEnv,
+      io
+    );
+  }
+  await presentOriginalVolume(
+    held,
+    continued.terminal,
+    io,
+    continuedAdmitted.runDirectory
+  );
+  return { ...continued, admitted: continuedAdmitted };
+}
 function roleRecord(role) {
   const record = packagedRoleMetadata(role);
   if (record === void 0) {
@@ -19213,23 +19461,14 @@ async function dispatchAdmitted(admitted, env, io) {
     });
   };
   const result = await execute(env);
-  const unreadableReask = await reaskUnreadablePostSubmissionStatus(
-    admitted,
-    result.terminal,
+  const live = result.admitted ?? admitted;
+  return continueAfterPostSubmissionGuards(
+    { ...result, admitted: live },
+    admitted.role,
     env,
-    io
+    io,
+    held
   );
-  if (isUnreadableReaskExhausted(unreadableReask)) {
-    const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
-    await presentOriginalVolume(held, terminal, io, admitted.runDirectory);
-    return terminal === void 0 ? result : { ...result, terminal };
-  }
-  if (unreadableReask !== void 0) return unreadableReask;
-  if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
-    return auditSubmittedRole(result, env, io);
-  }
-  await presentOriginalVolume(held, result.terminal, io, admitted.runDirectory);
-  return result;
 }
 async function runOmittedLensBatch(argv2, parsed, env, io) {
   const { summonParallelReviewerLenses: summonParallelReviewerLenses2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
@@ -19415,9 +19654,7 @@ async function runPublicInstructionSeat(argv2, env, io, role, parseArgv2) {
       stdout: (value) => held.push(value),
       stderr: io.stderr
     });
-    if (result.terminal?.roleOutcome.kind === "accepted") return auditSubmittedRole(result, env, io);
-    await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
-    return result;
+    return continueAfterPostSubmissionGuards(result, "countersign", env, io, held);
   }
   if ("parallelLenses" in record && record.parallelLenses === true) {
     if (parsed.baseRevision === void 0) {
@@ -19691,23 +19928,17 @@ async function runPublicInstructionSeatResume(request, env, io) {
       },
       ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
     });
-    const unreadableReask = result.admitted === void 0 ? void 0 : await reaskUnreadablePostSubmissionStatus(
-      result.admitted,
-      result.terminal,
+    if (result.admitted === void 0) {
+      await presentOriginalVolume(held, result.terminal, io);
+      return result;
+    }
+    return continueAfterPostSubmissionGuards(
+      result,
+      result.admitted.role,
       env,
-      io
+      io,
+      held
     );
-    if (isUnreadableReaskExhausted(unreadableReask)) {
-      const terminal = result.terminal === void 0 ? void 0 : withUnsettledDirection(result.terminal);
-      await presentOriginalVolume(held, terminal, io, result.admitted?.runDirectory);
-      return terminal === void 0 ? result : { ...result, terminal };
-    }
-    if (unreadableReask !== void 0) return unreadableReask;
-    if (result.admitted !== void 0 && AUDITED_ROLES.has(result.admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
-      return auditSubmittedRole(result, env, io);
-    }
-    await presentOriginalVolume(held, result.terminal, io, result.admitted?.runDirectory);
-    return result;
   };
   let binding;
   try {
@@ -19740,7 +19971,7 @@ async function queueConclusionFromChild(child, env, io) {
     return { stop: { exitCode: 0, ...terminal === void 0 ? {} : { terminal } } };
   }
   let current = child;
-  let budgetEnv = { ...env, unreadableReasksSpent: 0 };
+  let budgetEnv = envForCourtContinue(env);
   for (; ; ) {
     const terminal = await trySettlePublicSeat(
       current,
@@ -19811,7 +20042,7 @@ async function continueParentAfterChild(parentRunId, child, env, io) {
     return runPublicInstructionSeatResume({
       runId: parentRunId,
       summons: { instruction: readableGateItem(latestQueuePayload(resolved.terminal)) }
-    }, { ...env, unreadableReasksSpent: 0 }, io);
+    }, envForCourtContinue(env), io);
   }
   const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
   showResumeErrorPointer(io, result.exitCode, result.terminal);
@@ -19841,6 +20072,7 @@ async function officerPassedCurrentSubmission(input) {
   return latestQueueStatus(terminal) === "converged";
 }
 async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
+  env = withoutSoftTicketReaskTurn(env);
   const admitted = turn.admitted;
   if (admitted === void 0 || !AUDITED_ROLES.has(admitted.role) || turn.terminal?.roleOutcome.kind !== "accepted") return turn;
   const accepted = turn.terminal.roleOutcome.payloads?.at(-1);
@@ -19874,10 +20106,10 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
     await presentTerminal(turn.terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
     return turn;
   }
-  const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, env.home);
-  const acceptedRow = [...rows].reverse().find((row) => row.role === admitted.role && row.kind === "accepted");
-  const toolCallId = acceptedRow?.toolCallId;
-  if (toolCallId === void 0) throw new Error("accepted submission has no tool call identity");
+  const toolCallId = turn.terminal.submissionToolCallId;
+  if (toolCallId === void 0 || toolCallId.length === 0) {
+    throw new Error("accepted submission has no tool call identity");
+  }
   const sessionFile = env.principalAuthority.decode(admitted.principal).sessionFile;
   const entries = admitted.role === "doctor" ? await readBoundSessionEntries(sessionFile) : [];
   const context = {
@@ -19943,7 +20175,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         return runPublicInstructionSeatResume({
           runId: admitted.runId,
           summons: { instruction: readableGateItem(decision.receipt ?? decision.violations) }
-        }, { ...env, unreadableReasksSpent: 0 }, io);
+        }, envForCourtContinue(env), io);
       }
       if (decision.status === "received") {
         if (lastSummon?.terminal === void 0) {
@@ -20043,7 +20275,7 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
       return runPublicInstructionSeatResume({
         runId: admitted.runId,
         summons: { instruction: readableGateItem(chain.passes.at(-1)?.receipt) }
-      }, { ...env, unreadableReasksSpent: 0 }, io);
+      }, envForCourtContinue(env), io);
     }
     if (admitted.role === "secretariat") {
       const pass = chain.passes.at(-1);
@@ -20072,7 +20304,10 @@ var AUDITED_ROLES, SECRETARIAT_STATUS_REASK, WORKER_ROUTING_STATUSES, WORKER_STA
 var init_instruction_seat_run = __esm({
   "src/public-cli/instruction-seat-run.ts"() {
     "use strict";
+    init_report_ticket_tool();
     init_role_run_placement();
+    init_role_run_relocation();
+    init_session_opening_materials();
     init_archivist_record_pointer();
     init_doctor_auditor();
     init_gatekeeper_role();
@@ -20155,7 +20390,7 @@ __export(public_role_summons_exports, {
   summonPublicRole: () => summonPublicRole
 });
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { realpath as realpath5 } from "node:fs/promises";
 import { join as join22 } from "node:path";
 import { promisify as promisify3 } from "node:util";
@@ -20181,7 +20416,7 @@ function parentDir(path) {
 function walkPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 12; i += 1) {
-    if (existsSync8(join22(dir, "package.json")) && existsSync8(join22(dir, "souls"))) {
+    if (existsSync10(join22(dir, "package.json")) && existsSync10(join22(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -20843,6 +21078,24 @@ function rewriteRunDirectoryPathFields(record, fields, oldRunDirectory, newRunDi
     { oldRunDirectory, newRunDirectory }
   ]);
 }
+function rewritePrincipalSessionPaths(principal, oldRunDirectory, newRunDirectory) {
+  rewriteRunDirectoryPathFields(
+    principal,
+    PRINCIPAL_SESSION_PATH_FIELDS,
+    oldRunDirectory,
+    newRunDirectory
+  );
+}
+function projectTurnRequestLiveRunDirectory(request, newRunDirectory) {
+  const old = request.runDirectory;
+  if (old === newRunDirectory) return;
+  request.runDirectory = newRunDirectory;
+  rewritePrincipalSessionPaths(
+    request.principal,
+    old,
+    newRunDirectory
+  );
+}
 function rewriteRunDirectoryPathFieldsAgainstRewrites(record, fields, rewrites) {
   for (const field of fields) {
     if (field in record) {
@@ -20867,12 +21120,12 @@ function rewriteAdmittedRoleRunPage(page, rewrites) {
   if (isRecord(page.principal)) {
     rewriteRunDirectoryPathFieldsAgainstRewrites(
       page.principal,
-      ["sessionDirectory", "sessionFile"],
+      PRINCIPAL_SESSION_PATH_FIELDS,
       rewrites
     );
   }
 }
-var ADMITTED_PAGE_FIELDS, SOURCE_RUN_LOCATOR_FIELDS;
+var ADMITTED_PAGE_FIELDS, PRINCIPAL_SESSION_PATH_FIELDS, SOURCE_RUN_LOCATOR_FIELDS;
 var init_role_run_relocation = __esm({
   "src/role-run-relocation.ts"() {
     "use strict";
@@ -20894,6 +21147,10 @@ var init_role_run_relocation = __esm({
       "mergerInputPath",
       "sourceRunPath"
     ];
+    PRINCIPAL_SESSION_PATH_FIELDS = [
+      "sessionDirectory",
+      "sessionFile"
+    ];
     SOURCE_RUN_LOCATOR_FIELDS = ["runDirectory"];
   }
 });
@@ -20924,7 +21181,7 @@ __export(run_lifecycle_exports, {
   writeRoleRunState: () => writeRoleRunState
 });
 import { chmod, lstat as lstat3, open, readdir as readdir3, readFile as readFile10, unlink } from "node:fs/promises";
-import { basename as basename10, join as join24 } from "node:path";
+import { basename as basename11, join as join24 } from "node:path";
 function buildAutoResumeContinuationPrompt() {
   return RESUME_TRANSPORT_ENVELOPE;
 }
@@ -21371,7 +21628,7 @@ async function findLatestRunIdForSeatTicket(input) {
   }
   let best;
   for (const runDirectory of runDirectories) {
-    const parsed = parseRunLeaf(basename10(runDirectory));
+    const parsed = parseRunLeaf(basename11(runDirectory));
     if (parsed === void 0 || parsed.role !== input.role) continue;
     const runId = parsed.runId;
     const parentPath = await readRunParentPath(runDirectory);
@@ -21566,7 +21823,7 @@ async function loadResumableRunRecord(home, runId, authority) {
       );
     }
   }
-  const sourceRunLeaf = parseRunLeaf(basename10(sourceRunPath ?? ""));
+  const sourceRunLeaf = parseRunLeaf(basename11(sourceRunPath ?? ""));
   const referencedRunId = sourceRun?.runId ?? sourceRunLeaf?.runId;
   const referencedRole = sourceRun?.role ?? sourceRunLeaf?.role;
   if (referencedRunId !== void 0 && referencedRunId !== "") {
@@ -21883,6 +22140,7 @@ var init_run_lifecycle = __esm({
 
 // src/public-cli/post-admission.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
+import { existsSync as existsSync11 } from "node:fs";
 function describeCaughtError(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -21915,6 +22173,91 @@ function projectRelocatedTurnIdentity(request, result, admitted, relocation) {
     }
   }
 }
+async function refreshAdmittedPlacementAfterHostTurn(admitted, authority, heldLease) {
+  const home = homeFromRunDirectory(admitted.runDirectory);
+  const found = await findRunDirectoryById(home, admitted.runId, admitted.bookKey, admitted.role);
+  if (found === void 0 && !existsSync11(admitted.runDirectory)) {
+    throw new Error(
+      `admitted run ${admitted.runId} missing after host turn; not found under ${home}`
+    );
+  }
+  let relocation;
+  if (found !== void 0 && found !== admitted.runDirectory) {
+    const oldRunDirectory = admitted.runDirectory;
+    const coords = { ...authority.decode(admitted.principal) };
+    rewritePrincipalSessionPaths(
+      coords,
+      oldRunDirectory,
+      found
+    );
+    const principal = authority.seal(coords);
+    rewriteAdmittedRoleRunPage(
+      admitted,
+      [{ oldRunDirectory, newRunDirectory: found }]
+    );
+    admitted.principal = principal;
+    heldLease?.relocate(found);
+    relocation = { oldRunDirectory, newRunDirectory: found };
+  }
+  if (admitted.ticketNumber === void 0) {
+    const boardTicket = await readBoardTicketNumber(found ?? admitted.runDirectory);
+    if (boardTicket !== void 0) {
+      admitted.ticketNumber = boardTicket;
+    }
+  }
+  return relocation;
+}
+function applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed) {
+  projectRelocatedTurnIdentity(request, {}, admitted, refreshed);
+  return {
+    ...turnRequest,
+    runDirectory: admitted.runDirectory,
+    principal: admitted.principal
+  };
+}
+async function settleHostThrowAfterLivePlacementRefresh(input) {
+  let refreshError;
+  let turnRequest = input.turnRequest;
+  try {
+    const refreshed = await refreshAdmittedPlacementAfterHostTurn(
+      input.admitted,
+      input.env.principalAuthority,
+      input.lease
+    );
+    if (refreshed !== void 0) {
+      turnRequest = applyRefreshedPlacementToTurn(
+        input.request,
+        turnRequest,
+        input.admitted,
+        refreshed
+      );
+    }
+  } catch (err) {
+    refreshError = err;
+  }
+  const processCancelName = processCancelSignalName(input.env.signal);
+  const hostThrowSecondary = refreshError !== void 0 && input.hostTurnCompleted === false ? { knownDetails: { hostThrow: describeCaughtError(input.hostError) } } : {};
+  const settled = await settleAfterTurnStarted(
+    input.admitted,
+    withEngineDetourInvocationScope({
+      timedOut: false,
+      code: null,
+      stderr: "",
+      // Prefer the refresh failure when the live path is gone; otherwise the
+      // host throw remains the cause (失败诚实：不在旧 unbound 上结算写回).
+      ...processCancelName === void 0 ? {} : { cancelName: processCancelName },
+      thrown: refreshError ?? input.hostError,
+      ...hostThrowSecondary
+    }, input.request.invocationScopeId),
+    input.adapters,
+    input.env.principalAuthority,
+    input.io,
+    input.persistRunState,
+    input.notePackageFault,
+    input.courtAttemptId
+  );
+  return { settled, turnRequest };
+}
 function withProcessCancelSkipAutoResume(result, signal) {
   if (processCancelSignalName(signal) === void 0) {
     return result;
@@ -22301,6 +22644,12 @@ async function dispatchPostAdmissionTurn(input) {
     }
     if (pendingSettlement !== void 0 && pendingTerminal !== void 0 && result.terminal === pendingTerminal) {
       try {
+        const softTicketReaskNoSeal = pendingSettlement !== "sealed" && env.softTicketReaskTurn === true;
+        const noSealScope = softTicketReaskNoSeal ? {
+          ...courtScope,
+          previewOnly: true,
+          recordAttemptHistory: true
+        } : { ...courtScope, recordAttemptHistory: true };
         const terminal = pendingSettlement === "sealed" ? await adapters.trySettle(
           admitted,
           env.principalAuthority,
@@ -22310,13 +22659,16 @@ async function dispatchPostAdmissionTurn(input) {
           await settleHostEndedNoReceipt(
             admitted,
             env.principalAuthority,
-            { ...courtScope, recordAttemptHistory: true },
+            noSealScope,
             receiptDelivery.issuedDeliveryRequests()
           ),
-          courtScope
+          noSealScope
         );
         if (terminal === void 0) throw new Error("settled host attempt vanished before publication");
         result = { ...result, terminal, exitCode: exitCodeForTerminalOutcome(terminal.roleOutcome) };
+        if (pendingSettlement === "sealed" && env.softTicketReaskTurn === true && env.softTicketReaskOwnership !== void 0) {
+          env.softTicketReaskOwnership.sealedSubstitute = true;
+        }
         if (pendingSettlement === "sealed" && terminal.roleOutcome.kind === "accepted" && request.courtAttemptId !== void 0 && request.courtAttemptId.length > 0) {
           try {
             await clearCurrentCourt(admitted.runDirectory, request.courtAttemptId);
@@ -22426,32 +22778,38 @@ async function dispatchPostAdmissionTurn(input) {
       env.engineModel
     );
     let result;
+    let hostTurnCompleted = false;
     try {
       turnDispatched = true;
       result = await env.roleTurnHost.executeTurn(turnRequest);
+      hostTurnCompleted = true;
+      const refreshed = await refreshAdmittedPlacementAfterHostTurn(
+        admitted,
+        env.principalAuthority,
+        lease
+      );
+      if (refreshed !== void 0) {
+        turnRequest = applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed);
+      }
     } catch (error) {
-      const processCancelName = processCancelSignalName(env.signal);
-      const settled = await settleAfterTurnStarted(
+      const thrown = await settleHostThrowAfterLivePlacementRefresh({
         admitted,
-        withEngineDetourInvocationScope({
-          timedOut: false,
-          code: null,
-          stderr: "",
-          // The thrown value is the host's report. A cancel received on this
-          // call is a second fact; it must not become a new Error in its place.
-          ...processCancelName === void 0 ? {} : { cancelName: processCancelName },
-          thrown: error
-        }, request.invocationScopeId),
+        hostError: error,
+        hostTurnCompleted,
+        request,
+        turnRequest,
+        lease,
         adapters,
-        env.principalAuthority,
+        env,
         io,
         persistRunState,
-        courtScope.notePackageFault,
-        courtScope.courtAttemptId
-      );
+        notePackageFault: courtScope.notePackageFault,
+        ...courtScope.courtAttemptId === void 0 ? {} : { courtAttemptId: courtScope.courtAttemptId }
+      });
+      turnRequest = thrown.turnRequest;
       return await finishAfterTurn(
         withProcessCancelSkipAutoResume(
-          { ...settled, turnDispatched: true, ...deferredPersist },
+          { ...thrown.settled, turnDispatched: true, ...deferredPersist },
           env.signal
         )
       );
@@ -22477,6 +22835,7 @@ async function dispatchPostAdmissionTurn(input) {
     while (akSeamDeliversReceipt && receiptDelivery.nextAction() === "request-delivery") {
       let deliveryResult;
       let deliveryTurnRequest;
+      let deliveryHostTurnCompleted = false;
       try {
         const deliveryRequest = buildReceiptDeliveryRequest({
           request: turnRequest,
@@ -22490,24 +22849,40 @@ async function dispatchPostAdmissionTurn(input) {
         };
         receiptDelivery.recordDeliveryRequest();
         deliveryResult = await env.roleTurnHost.executeTurn(deliveryTurnRequest);
+        deliveryHostTurnCompleted = true;
+        const refreshed = await refreshAdmittedPlacementAfterHostTurn(
+          admitted,
+          env.principalAuthority,
+          lease
+        );
+        if (refreshed !== void 0) {
+          turnRequest = applyRefreshedPlacementToTurn(request, turnRequest, admitted, refreshed);
+          deliveryTurnRequest = {
+            ...deliveryTurnRequest,
+            runDirectory: admitted.runDirectory,
+            principal: admitted.principal
+          };
+        }
       } catch (error) {
-        const settled = await settleAfterTurnStarted(
+        const thrown = await settleHostThrowAfterLivePlacementRefresh({
           admitted,
-          withEngineDetourInvocationScope(
-            { timedOut: false, code: null, stderr: "", thrown: error },
-            request.invocationScopeId
-          ),
+          hostError: error,
+          hostTurnCompleted: deliveryHostTurnCompleted,
+          request,
+          turnRequest,
+          lease,
           adapters,
-          env.principalAuthority,
+          env,
           io,
           persistRunState,
-          courtScope.notePackageFault,
-          courtScope.courtAttemptId
-        );
+          notePackageFault: courtScope.notePackageFault,
+          ...courtScope.courtAttemptId === void 0 ? {} : { courtAttemptId: courtScope.courtAttemptId }
+        });
+        turnRequest = thrown.turnRequest;
         return await finishAfterTurn(
           withProcessCancelSkipAutoResume(
             {
-              ...settled,
+              ...thrown.settled,
               turnDispatched: true,
               ...deferredPersist
             },
@@ -23023,6 +23398,7 @@ var init_post_admission = __esm({
     init_invocation();
     init_submission_ledger();
     init_run_ticket_number();
+    init_activation_ledger_topology();
     init_session_identity();
     init_sitian_facade();
     init_receipt_delivery_policy();
@@ -29586,7 +29962,7 @@ var init_analyst_gate_cycles_read = __esm({
 
 // src/analyst-ledger.ts
 import { readdir as readdir4 } from "node:fs/promises";
-import { basename as basename11, join as join27 } from "node:path";
+import { basename as basename12, join as join27 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
 }
@@ -29938,7 +30314,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;
@@ -32221,7 +32597,7 @@ var init_cli = __esm({
 });
 
 // src/public-cli/main.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { dirname as dirname19, join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -32312,7 +32688,7 @@ function linkPackage(packageRoot2, name, targetDir) {
 var here = dirname19(fileURLToPath2(import.meta.url));
 function resolvePackageRoot(binDir) {
   const canonical = join29(binDir, "..", "..");
-  if (existsSync9(join29(canonical, "package.json"))) {
+  if (existsSync12(join29(canonical, "package.json"))) {
     return canonical;
   }
   return binDir;