@akagilnc/pi-workflow-roles 0.1.5614 → 0.1.5650

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

@@ -168,6 +168,7 @@ __export(activation_ledger_topology_exports, {
   physicallyContainedIn: () => physicallyContainedIn,
   resolveActivationLedgerHome: () => resolveActivationLedgerHome,
   resolveActivationLedgerHomeForPath: () => resolveActivationLedgerHomeForPath,
+  tryBookKeyFromAkRolesPath: () => tryBookKeyFromAkRolesPath,
   tryHomeFromAkRolesPath: () => tryHomeFromAkRolesPath
 });
 import {
@@ -189,6 +190,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, resolve(path));
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(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) {
@@ -1145,8 +1157,7 @@ function roleRunPlacement(ledgerHome, input) {
   return {
     runDirectory,
     sessionDirectory,
-    sessionFile: sessionFileIn(sessionDirectory),
-    attachmentsDirectory: join3(runDirectory, "attachments")
+    sessionFile: sessionFileIn(sessionDirectory)
   };
 }
 function isUnboundRunDirectory(runDirectory) {
@@ -8136,15 +8147,9 @@ async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
   }
   await rename2(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);
@@ -8775,7 +8780,6 @@ async function placeRoleAdmission(options) {
     sessionDirectory,
     sessionFile,
     runDirectory,
-    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
@@ -8796,7 +8800,6 @@ async function placeRoleAdmission(options) {
     sessionDirectory,
     sessionFile,
     attachments,
-    attachmentsDirectory,
     ledgerHome,
     ticketFields
   };
@@ -9426,19 +9429,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);
@@ -10073,8 +10081,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);
@@ -10085,15 +10093,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);
 }
@@ -10445,6 +10461,213 @@ var init_settlement = __esm({
   }
 });
 
+// src/external-host-turn-loop.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { basename as basename9 } from "node:path";
+async function resolveLiveRunDirectoryPath(recordedPath, home) {
+  if (existsSync6(recordedPath)) return recordedPath;
+  const parsed = parseRunLeaf(basename9(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(basename9(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 } : {}
+  });
+}
+async function recordTurnDelivery(runDirectory, delivered, source) {
+  try {
+    reportRunRecord(runDirectory, "turn-delivery", {
+      systemPrompt: delivered.systemPrompt,
+      ...delivered.outputSchema === void 0 ? {} : { outputSchema: delivered.outputSchema }
+    }, source);
+  } catch (error) {
+    await retainPackageFault({
+      runDirectory,
+      diagnostic: `turn delivery record failed beside host start: ${describeErrorIdentity(error)}`,
+      error
+    });
+  }
+}
+function mergeRoleTurnAbortSignals(prepared, request) {
+  if (request === void 0) return prepared;
+  if (prepared === void 0) return request;
+  return AbortSignal.any([prepared, request]);
+}
+function isHostAbortedError(error) {
+  return typeof error === "object" && error !== null && error.code === "host-aborted";
+}
+function hostAbortedError(message = "host aborted") {
+  return Object.assign(new Error(message), { code: "host-aborted" });
+}
+function externalHostFailure(cause, name, code, details, diagnostic) {
+  return asFailure({
+    cause,
+    identity: { name, code },
+    ...diagnostic === void 0 ? {} : { diagnostic },
+    ...details === void 0 ? {} : { details }
+  });
+}
+function asFailure(knownFailure, stderr = "") {
+  return { code: null, stderr, timedOut: false, knownFailure };
+}
+async function settleHostAborted(prepared, sessionId) {
+  const closure = await prepared.closeRound();
+  if ("failure" in closure) return asFailure(closure.failure);
+  return asFailure({
+    cause: "session",
+    identity: { name: "HostAborted", code: "host-aborted" },
+    ...sessionId === void 0 ? {} : { details: { sessionId } }
+  });
+}
+async function driveExternalRoleTurnRounds(prepared, request, driver) {
+  let prompt = prepared.prompt;
+  const abortSignal = mergeRoleTurnAbortSignals(prepared.abortSignal, request.signal);
+  let result = { code: 0, stderr: "", timedOut: false };
+  const countedReaskLimit = deliveryLimitFromConfig(request.deliveryRequestLimit);
+  const exemptReminders = /* @__PURE__ */ new Set();
+  let countedReasks = 0;
+  for (let attempt = 0; ; attempt += 1) {
+    if (abortSignal?.aborted) return settleHostAborted(prepared, driver.currentSessionId());
+    let round;
+    try {
+      round = await driver.runRound({ prompt, abortSignal, attempt });
+    } catch (error) {
+      if (isHostAbortedError(error)) return settleHostAborted(prepared, driver.currentSessionId());
+      throw error;
+    }
+    if (round.status === "terminal") return round.result;
+    result = {
+      code: round.code !== void 0 ? round.code : 0,
+      stderr: round.stderr ?? "",
+      timedOut: round.timedOut === true,
+      ...round.signal === void 0 ? {} : { signal: round.signal }
+    };
+    let closure;
+    try {
+      closure = await prepared.closeRound();
+    } catch (error) {
+      await retainPackageFaultBesideLivePlacement(request, {
+        diagnostic: `round closure failed beside host terminal: ${describeErrorIdentity(error)}`,
+        error
+      });
+      return result.code === 0 && !result.timedOut && result.signal === void 0 ? { ...result, knownFailure: projectThrownFailureLeaf(error) } : result;
+    }
+    if (closure.accepted) {
+      try {
+        await driver.afterAccepted?.();
+      } catch (error) {
+        await retainPackageFaultBesideLivePlacement(request, {
+          diagnostic: `post-acceptance close failed beside host terminal: ${describeErrorIdentity(error)}`,
+          error
+        });
+      }
+      return result;
+    }
+    if ("failure" in closure) {
+      await retainPackageFaultBesideLivePlacement(request, {
+        diagnostic: `round closure failed beside host terminal: ${JSON.stringify(closure.failure)}`
+      });
+      return result.code === 0 && !result.timedOut && result.signal === void 0 ? { ...result, knownFailure: closure.failure } : result;
+    }
+    if (result.code !== 0 || result.signal !== void 0 || result.timedOut) return result;
+    const reminderCode = closure.retry.code;
+    const exempt = isOneShotWorkerReminderCode(reminderCode) && !exemptReminders.has(reminderCode);
+    if (exempt) exemptReminders.add(reminderCode);
+    else {
+      countedReasks += 1;
+      if (countedReasks > countedReaskLimit) {
+        await retainPackageFaultBesideLivePlacement(request, {
+          diagnostic: `${driver.roundLimitName}: round-retry-limit`
+        });
+        return result;
+      }
+    }
+    prompt = closure.retry.message;
+    driver.afterRetry?.();
+  }
+}
+async function disposeExternalRoleTurn(prepared, request, outcome) {
+  try {
+    await prepared.dispose?.();
+  } catch (error) {
+    await retainPackageFaultBesideLivePlacement(request, {
+      diagnostic: `required envelope shutdown failed beside host terminal: ${describeErrorIdentity(error)}`,
+      error
+    });
+    if (outcome.code === 0 && !outcome.timedOut && outcome.signal === void 0 && outcome.knownFailure === void 0) {
+      return { ...outcome, knownFailure: projectThrownFailureLeaf(error) };
+    }
+  }
+  return outcome;
+}
+function createSerializedRoleTurnHost(execute) {
+  let serial = Promise.resolve();
+  return {
+    executeTurn(request) {
+      const execution = serial.then(() => execute(request));
+      serial = execution.then(() => void 0, () => void 0);
+      return execution;
+    }
+  };
+}
+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 dirname12, join as join15 } from "node:path";
 function createSessionIdentityAuthority(authority, hostName) {
@@ -10524,6 +10747,7 @@ __export(role_turn_host_exports, {
 });
 import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { constants } 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 dirname13, isAbsolute as isAbsolute6, join as join16, resolve as resolve12 } from "node:path";
 import { platform } from "node:process";
@@ -10709,7 +10933,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 = existsSync7(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 {
@@ -10791,6 +11040,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) {
@@ -10808,8 +11058,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
         });
@@ -10878,6 +11127,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();
@@ -11056,7 +11307,7 @@ var init_host_providers = __esm({
 });
 
 // src/public-cli/load-production-acp-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 } from "node:url";
 async function loadProductionAcpHostFactory(packageRoot, host) {
@@ -11066,7 +11317,7 @@ async function loadProductionAcpHostFactory(packageRoot, host) {
   }
   const built = join18(packageRoot, "dist/acp-host/production-host.js");
   const source = join18(packageRoot, "src/acp-host/production-host.ts");
-  const target = existsSync6(built) ? built : source;
+  const target = existsSync8(built) ? built : source;
   const href = pathToFileURL(target).href;
   const mod = await import(href);
   const create = mod.createProductionAcpRoleTurnHost;
@@ -11080,7 +11331,7 @@ var init_load_production_acp_host = __esm({
 });
 
 // src/public-cli/load-production-headless-host.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { join as join19 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function loadProductionHeadlessHostFactory(packageRoot, host) {
@@ -11090,7 +11341,7 @@ async function loadProductionHeadlessHostFactory(packageRoot, host) {
   }
   const built = join19(packageRoot, "dist/headless-host/production-host.js");
   const source = join19(packageRoot, "src/headless-host/production-host.ts");
-  const target = existsSync7(built) ? built : source;
+  const target = existsSync9(built) ? built : source;
   const href = pathToFileURL2(target).href;
   const mod = await import(href);
   const create = mod.createProductionHeadlessRoleTurnHost;
@@ -11256,8 +11507,179 @@ var init_role_seat_runtime = __esm({
   }
 });
 
+// src/report-ticket-tool.ts
+import { Type as Type16 } from "typebox";
+import { existsSync as existsSync10 } from "node:fs";
+function pageString(page, key) {
+  const value = page?.[key];
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function admittedForLiveTicketReport(runDirectory, authority) {
+  const admittedPage = readPageSync(runDirectory, "admitted") ?? {};
+  const invocationPage = readPageSync(runDirectory, "invocation") ?? {};
+  const role = pageString(admittedPage, "role") ?? pageString(invocationPage, "role");
+  const runId = pageString(admittedPage, "runId") ?? pageString(invocationPage, "runId");
+  const bookKey = pageString(admittedPage, "bookKey") ?? pageString(invocationPage, "bookKey");
+  const projectRoot = pageString(admittedPage, "projectRoot") ?? pageString(invocationPage, "projectRoot");
+  if (role === void 0 || runId === void 0 || bookKey === void 0 || projectRoot === void 0) {
+    throw new Error("ak_report_ticket requires durable role/runId/bookKey/projectRoot on the run");
+  }
+  const attachments = Array.isArray(admittedPage.attachments) ? admittedPage.attachments : [];
+  const sessionDirectory = sessionDirectoryOf(runDirectory);
+  const sessionFile = sessionFileOf(runDirectory);
+  const principal = authority.seal({ sessionDirectory, sessionFile });
+  const ticketNumber = readDeclaredTicketNumber(admittedPage.ticketNumber) ?? readDeclaredTicketNumber(invocationPage.ticketNumber);
+  return {
+    role,
+    runId,
+    bookKey,
+    projectRoot,
+    instruction: typeof admittedPage.instruction === "string" ? admittedPage.instruction : "",
+    instructionEmpty: admittedPage.instructionEmpty === true || typeof admittedPage.instruction === "string" && admittedPage.instruction.trim() === "",
+    attachments,
+    runDirectory,
+    principal,
+    ...ticketNumber === void 0 ? {} : { ticketNumber }
+  };
+}
+async function reportTicketFromHostContext(context, rawTicketNumber, authority = piDurablePrincipalAuthority) {
+  const ticketNumber = readDeclaredTicketNumber(rawTicketNumber);
+  if (ticketNumber === void 0) {
+    throw new Error("ak_report_ticket requires an identifiable ticketNumber");
+  }
+  const runDirectory = runDirectoryFromHostContext(context);
+  if (runDirectory === void 0) {
+    throw new Error("ak_report_ticket requires a per-turn run directory");
+  }
+  if (!existsSync10(runDirectory)) {
+    throw new Error(`ak_report_ticket run directory missing: ${runDirectory}`);
+  }
+  const admitted = admittedForLiveTicketReport(runDirectory, authority);
+  const alreadyPlaced = !isUnboundRunDirectory(runDirectory);
+  if (!alreadyPlaced) {
+    await bindAdmittedTicketNumber(admitted, ticketNumber);
+  }
+  const applyLiveHandles = (nextDirectory2) => {
+    context.runDirectory = nextDirectory2;
+    if (process.env.AK_ROLE_RUN_DIR === runDirectory) {
+      process.env.AK_ROLE_RUN_DIR = nextDirectory2;
+    }
+    context.sessionManager.setSessionFile?.(sessionFileOf(nextDirectory2));
+  };
+  const relocation = alreadyPlaced ? void 0 : await relocateAdmittedRunToTicket(admitted, authority, { relocate: applyLiveHandles });
+  const nextDirectory = relocation?.newRunDirectory ?? admitted.runDirectory;
+  if (relocation === void 0) applyLiveHandles(nextDirectory);
+  return {
+    ticketNumber: alreadyPlaced ? admitted.ticketNumber ?? ticketNumber : ticketNumber,
+    relocated: relocation !== void 0
+  };
+}
+function registerReportTicketTool(roleHost) {
+  if (roleHost.getAllTools().some((tool) => tool.name === REPORT_TICKET_TOOL_NAME)) return;
+  roleHost.registerTool({
+    name: REPORT_TICKET_TOOL_NAME,
+    label: "\u62A5\u7968\u53F7",
+    description: REPORT_TICKET_TOOL_DESCRIPTION,
+    promptSnippet: "\u5DF2\u77E5\u7968\u53F7\u65F6\u7ACB\u5373\u7533\u62A5\uFF0C\u5305\u5F53\u573A\u5F52\u4F4D",
+    parameters: reportTicketArgsSchema,
+    async execute(_toolCallId, parameters, _signal, _onUpdate, ctx) {
+      const raw = isRecord(parameters) ? parameters.ticketNumber : void 0;
+      const details = await reportTicketFromHostContext(ctx, raw);
+      return {
+        content: [],
+        details
+      };
+    }
+  });
+}
+var REPORT_TICKET_TOOL_NAME, reportTicketArgsSchema, REPORT_TICKET_TOOL_DESCRIPTION, MISSING_TICKET_REASK_MATERIAL;
+var init_report_ticket_tool = __esm({
+  "src/report-ticket-tool.ts"() {
+    "use strict";
+    init_host_contracts();
+    init_durable_principal();
+    init_invocation();
+    init_role_run_placement();
+    init_run_dossier();
+    init_run_ticket_number();
+    init_unknown_value();
+    REPORT_TICKET_TOOL_NAME = "ak_report_ticket";
+    reportTicketArgsSchema = Type16.Object(
+      {
+        ticketNumber: Type16.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 }
+    );
+    REPORT_TICKET_TOOL_DESCRIPTION = "\u5411\u5305\u7533\u62A5\u672C\u7968\u53F7\u3002\u5DF2\u77E5\u7968\u53F7\u65F6\u5F00\u5DE5\u7B2C\u4E00\u4EF6\u4E8B\u8C03\u7528\uFF1B\u5305\u5F53\u573A\u628A\u672C\u817F\u5F52\u5230\u7968\u53F7\u76EE\u5F55\u3002\u5C1A\u65E0\u7968\u53F7\uFF08\u4F8B\u5982\u4E2D\u4E66\u7701\u5EFA\u7968\u524D\uFF09\u4E0D\u8981\u8C03\u7528\uFF0C\u53D6\u5F97\u540E\u518D\u62A5\u3002\u4EA4\u5377\u65F6\u82E5\u4ECD\u672A\u62A5\u8FC7\u4E14\u4EA4\u5377\u4EA6\u672A\u5E26\u7968\u53F7\uFF0C\u5305\u4F1A\u7ECF\u65E2\u6709\u91CD\u4EA4\u901A\u9053\u518D\u95EE\u4E00\u6B21\u3002";
+    MISSING_TICKET_REASK_MATERIAL = "resources/missing-ticket-reask.md";
+  }
+});
+
+// src/session-opening-materials.ts
+import { existsSync as existsSync11 } from "node:fs";
+import { readFile as readFile10 } from "node:fs/promises";
+import { dirname as dirname14, join as join20 } from "node:path";
+import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
+function resolvePackageRootDir(moduleUrl = import.meta.url) {
+  let dir = dirname14(fileURLToPath(moduleUrl));
+  for (let i = 0; i < 8; i += 1) {
+    if (existsSync11(join20(dir, "package.json")) && existsSync11(join20(dir, "souls"))) {
+      return dir;
+    }
+    const parent = dirname14(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return fileURLToPath(new URL("..", moduleUrl));
+}
+async function readPackageMaterial(relativePath) {
+  return readFile10(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");
+}
+function roleSoulPath(role, materials) {
+  const suffix = `/souls/${role}.md`;
+  const path = materials.find((candidate) => `/${candidate}`.endsWith(suffix));
+  if (path === void 0) throw new Error(`session materials omit the ${role} Soul`);
+  return path;
+}
+async function loadSeparatedSessionPart(role, materials, part) {
+  const soul = roleSoulPath(role, materials);
+  return part === "soul" ? readPackageMaterial(soul) : joinPackageMaterials(materials.filter((path) => path !== soul));
+}
+function loadMainRoleSessionMaterials(role) {
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "soul");
+}
+function loadMainRoleReferenceMaterials(role) {
+  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "references");
+}
+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 basename9, join as join20 } from "node:path";
+import { basename as basename10, join as join21 } from "node:path";
 function bookDirectOfficerRunPointer(options) {
   const submissionToolCallId = options.submissionToolCallId?.trim() ?? "";
   const pointer = {
@@ -11283,7 +11705,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(basename9(recordedRunDirectory));
+  const leaf = parseRunLeaf(basename10(recordedRunDirectory));
   const parentIdentity = await readRoleRunIdentity(parentRunDirectory);
   if (leaf !== void 0 && parentIdentity !== void 0) {
     const currentRunDirectory = await findRunDirectoryById(
@@ -11306,7 +11728,7 @@ async function resolveOfficerPointer(raw, parentRunDirectory) {
   };
 }
 async function readBookedOfficerPointers(parentRunDirectory) {
-  const { records, diagnostics } = await readSitianRecords(join20(parentRunDirectory, RUN_HISTORY_FILE));
+  const { records, diagnostics } = await readSitianRecords(join21(parentRunDirectory, RUN_HISTORY_FILE));
   if (diagnostics.length > 0) {
     throw new Error(
       `${RUN_HISTORY_FILE} has ${diagnostics.length} malformed row(s); officer pointers unreadable: ${parentRunDirectory}`
@@ -11642,67 +12064,6 @@ var init_submission_gate = __esm({
   }
 });
 
-// src/session-opening-materials.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
-import { dirname as dirname14, join as join21 } from "node:path";
-import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
-function resolvePackageRootDir(moduleUrl = import.meta.url) {
-  let dir = dirname14(fileURLToPath(moduleUrl));
-  for (let i = 0; i < 8; i += 1) {
-    if (existsSync8(join21(dir, "package.json")) && existsSync8(join21(dir, "souls"))) {
-      return dir;
-    }
-    const parent = dirname14(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return fileURLToPath(new URL("..", moduleUrl));
-}
-async function readPackageMaterial(relativePath) {
-  return readFile10(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");
-}
-function roleSoulPath(role, materials) {
-  const suffix = `/souls/${role}.md`;
-  const path = materials.find((candidate) => `/${candidate}`.endsWith(suffix));
-  if (path === void 0) throw new Error(`session materials omit the ${role} Soul`);
-  return path;
-}
-async function loadSeparatedSessionPart(role, materials, part) {
-  const soul = roleSoulPath(role, materials);
-  return part === "soul" ? readPackageMaterial(soul) : joinPackageMaterials(materials.filter((path) => path !== soul));
-}
-function loadMainRoleSessionMaterials(role) {
-  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "soul");
-}
-function loadMainRoleReferenceMaterials(role) {
-  return loadSeparatedSessionPart(role, MAIN_ROLE_SESSION_MATERIALS[role], "references");
-}
-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, {
@@ -11718,7 +12079,7 @@ __export(auditor_soul_exports, {
   readAuditorResumeBinding: () => readAuditorResumeBinding,
   resolveAuditorSubject: () => resolveAuditorSubject
 });
-import { basename as basename10 } from "node:path";
+import { basename as basename11 } from "node:path";
 function auditorSoulRelativePath(role) {
   return `souls/${role}-auditor.md`;
 }
@@ -11754,7 +12115,7 @@ function loadAuditorReferenceMaterialsFromSubjectInput(raw) {
   return loadAuditorReferenceMaterials(resolveAuditorSubject(raw));
 }
 function subjectFromSourceDirectory(sourceRunDirectory) {
-  const role = parseRunLeaf(basename10(sourceRunDirectory))?.role;
+  const role = parseRunLeaf(basename11(sourceRunDirectory))?.role;
   return isAuditorSoulRole(role) ? role : void 0;
 }
 async function readAuditorResumeBinding(runDirectory) {
@@ -12316,6 +12677,7 @@ var init_auto_resume = __esm({
 
 // src/public-cli/post-admission.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
+import { existsSync as existsSync12 } from "node:fs";
 function describeCaughtError(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -12348,6 +12710,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 && !existsSync12(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;
@@ -12734,6 +13181,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,
@@ -12743,13 +13196,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);
@@ -12859,32 +13315,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
         )
       );
@@ -12910,6 +13372,7 @@ async function dispatchPostAdmissionTurn(input) {
     while (akSeamDeliversReceipt && receiptDelivery.nextAction() === "request-delivery") {
       let deliveryResult;
       let deliveryTurnRequest;
+      let deliveryHostTurnCompleted = false;
       try {
         const deliveryRequest = buildReceiptDeliveryRequest({
           request: turnRequest,
@@ -12923,24 +13386,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
             },
@@ -13456,6 +13935,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();
@@ -13604,10 +14084,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;
@@ -13666,6 +14150,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) {
@@ -13840,23 +14428,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(argv, parsed, env, io) {
   const { summonParallelReviewerLenses: summonParallelReviewerLenses2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
@@ -14042,9 +14621,7 @@ async function runPublicInstructionSeat(argv, 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) {
@@ -14318,23 +14895,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 {
@@ -14367,7 +14938,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,
@@ -14438,7 +15009,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);
@@ -14468,6 +15039,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);
@@ -14501,10 +15073,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 = {
@@ -14570,7 +15142,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) {
@@ -14670,7 +15242,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);
@@ -14699,7 +15271,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();
@@ -15386,7 +15961,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 join25 } from "node:path";
+import { basename as basename12, join as join25 } from "node:path";
 async function readExistingRunLifecycleState(runDirectory) {
   return (await readRoleRunIdentity(runDirectory))?.state;
 }
@@ -15738,7 +16313,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;
@@ -16723,7 +17298,7 @@ var init_analyst_model_groups = __esm({
 
 // src/analyst-entry.ts
 import { readFile as readFile13 } from "node:fs/promises";
-import { Type as Type16 } from "typebox";
+import { Type as Type17 } from "typebox";
 function cachedPageMatchesRequestedScope(page, input) {
   if (page.bookKey !== input.bookKey) return false;
   const requestedTicket = input.ticketNumber ?? input.issueNumber;
@@ -16928,16 +17503,16 @@ var init_analyst_entry = __esm({
         }
       }
     };
-    analystSweepModeInputSchema = Type16.Object(
+    analystSweepModeInputSchema = Type17.Object(
       {
-        mode: Type16.Literal("sweep"),
-        mergedPullRequests: Type16.Array(
-          Type16.Object(
+        mode: Type17.Literal("sweep"),
+        mergedPullRequests: Type17.Array(
+          Type17.Object(
             {
-              projectRoot: Type16.String(),
+              projectRoot: Type17.String(),
               /** 排除后改动行数 — omit or 0 → typed 空缺; finite ≥ 0 only. */
-              changedLines: Type16.Optional(
-                Type16.Number({ minimum: 0, maximum: Number.MAX_VALUE })
+              changedLines: Type17.Optional(
+                Type17.Number({ minimum: 0, maximum: Number.MAX_VALUE })
               )
             }
           )
@@ -18030,7 +18605,7 @@ __export(public_role_summons_exports, {
   summonPublicRole: () => summonPublicRole
 });
 import { execFile as execFile3 } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { realpath as realpath6 } from "node:fs/promises";
 import { join as join27 } from "node:path";
 import { promisify as promisify3 } from "node:util";
@@ -18056,7 +18631,7 @@ function parentDir(path) {
 function walkPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 12; i += 1) {
-    if (existsSync9(join27(dir, "package.json")) && existsSync9(join27(dir, "souls"))) {
+    if (existsSync13(join27(dir, "package.json")) && existsSync13(join27(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -18724,6 +19299,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) {
@@ -18748,12 +19341,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";
@@ -18775,6 +19368,10 @@ var init_role_run_relocation = __esm({
       "mergerInputPath",
       "sourceRunPath"
     ];
+    PRINCIPAL_SESSION_PATH_FIELDS = [
+      "sessionDirectory",
+      "sessionFile"
+    ];
     SOURCE_RUN_LOCATOR_FIELDS = ["runDirectory"];
   }
 });
@@ -18805,7 +19402,7 @@ __export(run_lifecycle_exports, {
   writeRoleRunState: () => writeRoleRunState
 });
 import { chmod, lstat as lstat3, open as open2, readdir as readdir4, readFile as readFile15, unlink as unlink2 } from "node:fs/promises";
-import { basename as basename12, join as join29 } from "node:path";
+import { basename as basename13, join as join29 } from "node:path";
 function buildAutoResumeContinuationPrompt() {
   return RESUME_TRANSPORT_ENVELOPE;
 }
@@ -19252,7 +19849,7 @@ async function findLatestRunIdForSeatTicket(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);
@@ -19447,7 +20044,7 @@ async function loadResumableRunRecord(home, runId, authority) {
       );
     }
   }
-  const sourceRunLeaf = parseRunLeaf(basename12(sourceRunPath ?? ""));
+  const sourceRunLeaf = parseRunLeaf(basename13(sourceRunPath ?? ""));
   const referencedRunId = sourceRun?.runId ?? sourceRunLeaf?.runId;
   const referencedRole = sourceRun?.role ?? sourceRunLeaf?.role;
   if (referencedRunId !== void 0 && referencedRunId !== "") {
@@ -19795,7 +20392,7 @@ var init_archivist_record_topology = __esm({
 });
 
 // src/pi/record-session-host.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 var piRecordSessionHost;
 var init_record_session_host = __esm({
@@ -19817,7 +20414,7 @@ var init_record_session_host = __esm({
         const sessionFile = session.getSessionFile();
         return {
           session,
-          resumed: sessionFile !== void 0 && existsSync10(sessionFile)
+          resumed: sessionFile !== void 0 && existsSync14(sessionFile)
         };
       },
       inMemoryRecordSession(cwd) {
@@ -19840,7 +20437,7 @@ __export(archivist_record_entry_exports, {
 });
 import {
   closeSync,
-  existsSync as existsSync11,
+  existsSync as existsSync15,
   openSync,
   readdirSync as readdirSync3,
   readFileSync as readFileSync4,
@@ -20001,7 +20598,7 @@ function mostRecentNavigatorSessionFile(sessionDir, cwd) {
 }
 function resolveNavigatorNestContinuation(sessionDir, cwd) {
   const ledgerPath = currentSessionLedgerPath(sessionDir);
-  if (existsSync11(ledgerPath)) {
+  if (existsSync15(ledgerPath)) {
     const recentFile = readCurrentSession(sessionDir);
     assertRecentFinalFileUnderSessionDir(sessionDir, recentFile);
     return recentFile;
@@ -20086,7 +20683,7 @@ function createRecordSessionOpen(options, host = piRecordSessionHost) {
     parentSession = parentFile;
     mayResumeSameNest = options.kind === WORKER_SUBMISSION_GATE_KIND;
   }
-  const nestAlreadyExists = existsSync11(sessionDir);
+  const nestAlreadyExists = existsSync15(sessionDir);
   ensureRealDirectoryTree(ledgerHome, sessionDir);
   if (mayResumeSameNest && nestAlreadyExists) {
     if (options.kind === NAVIGATOR_RECORD_KIND) {
@@ -20111,7 +20708,7 @@ function createRecordSessionOpen(options, host = piRecordSessionHost) {
   });
   if (session.isPersisted()) {
     const file = session.getSessionFile();
-    if (file !== void 0 && !existsSync11(file)) {
+    if (file !== void 0 && !existsSync15(file)) {
       const header = session.getHeader();
       if (header !== null && header.type === "session") {
         writeFileSync2(file, `${JSON.stringify(header)}
@@ -20159,12 +20756,12 @@ init_packaged_role_registry();
 init_activation_ledger_topology();
 import { resolve as resolve16 } from "node:path";
 import "@earendil-works/pi-coding-agent";
-import { Type as Type17 } from "typebox";
+import { Type as Type18 } from "typebox";
 
 // src/navigator-public-session.ts
 init_host_session_record();
-import { existsSync as existsSync12 } from "node:fs";
-import { basename as basename13 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { basename as basename14 } from "node:path";
 
 // src/navigator-session-contracts.ts
 init_unknown_value();
@@ -20450,7 +21047,7 @@ async function resolveNavigatorLedgerHome(context) {
 }
 var NAVIGATOR_HOST_RUN_POINTER_ENTRY = "ak-navigator-host-run";
 function runIdFromNavigatorDirectory(runDirectory) {
-  const parsed = parseRunLeaf(basename13(runDirectory));
+  const parsed = parseRunLeaf(basename14(runDirectory));
   if (parsed === void 0 || parsed.role !== "navigator") return void 0;
   return parsed.runId;
 }
@@ -20512,7 +21109,7 @@ function createNativeNavigatorSessionFactory(deps) {
           if (disposed) return;
           const resumeRunId = hostRunId;
           const workContextPath = navigatorWorkContextFile(sessionManager.getSessionDir());
-          const workContextLocator = existsSync12(workContextPath) ? workContextPath : void 0;
+          const workContextLocator = existsSync16(workContextPath) ? workContextPath : void 0;
           const baseSummon = {
             role: "navigator",
             argv: [text],
@@ -20647,8 +21244,8 @@ function resolveNavigatorAuthorityMaterial(roleInput, fileAuthority) {
   return void 0;
 }
 var NAVIGATOR_TARGETS = PACKAGED_ROLE_REGISTRY.map(({ role, phases }) => ({ role, phases }));
-var prepareSchema = Type17.Object({
-  prose: Type17.Optional(Type17.Unknown({
+var prepareSchema = Type18.Object({
+  prose: Type18.Optional(Type18.Unknown({
     description: "\u6E38\u5955\u4F7F\u6563\u6587\u5EFA\u8BAE\uFF0C\u539F\u6837\u5448\u73B0\u3002\u4E0D\u8981\u6C42 candidates/next \u7ED3\u6784\u3002"
   }))
 }, { additionalProperties: true });
@@ -21187,24 +21784,25 @@ init_sitian_facade();
 init_host_session_record();
 init_submission_ledger();
 init_filed_submission();
+init_report_ticket_tool();
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { writeSync as writeSync2 } from "node:fs";
 import { join as join33 } from "node:path";
 import { Value as Value3 } from "typebox/value";
 
 // src/activation-trace.ts
-import { Type as Type18 } from "typebox";
-var causeSchema = Type18.Object({
-  identity: Type18.String({ minLength: 1 }),
-  name: Type18.String({ minLength: 1 }),
-  message: Type18.String(),
-  evidenceId: Type18.Optional(Type18.String({ minLength: 1 }))
+import { Type as Type19 } from "typebox";
+var causeSchema = Type19.Object({
+  identity: Type19.String({ minLength: 1 }),
+  name: Type19.String({ minLength: 1 }),
+  message: Type19.String(),
+  evidenceId: Type19.Optional(Type19.String({ minLength: 1 }))
 }, { additionalProperties: false });
-var activationTraceRecordSchema = Type18.Object({
-  role: Type18.String({ minLength: 1 }),
-  stageId: Type18.String({ pattern: "^[a-z][a-z0-9-]*$" }),
-  status: Type18.Literal("failed"),
-  timestamp: Type18.String({ format: "date-time" }),
+var activationTraceRecordSchema = Type19.Object({
+  role: Type19.String({ minLength: 1 }),
+  stageId: Type19.String({ pattern: "^[a-z][a-z0-9-]*$" }),
+  status: Type19.Literal("failed"),
+  timestamp: Type19.String({ format: "date-time" }),
   cause: causeSchema
 }, { additionalProperties: false });
 var activationCauseEvidence = 0;
@@ -21369,10 +21967,10 @@ init_engine_material();
 init_engine_detour();
 init_engine_detour_usage();
 init_run_terminal_artifacts();
-import { Type as Type19 } from "typebox";
-var engineDetourArgsSchema = Type19.Object(
+import { Type as Type20 } from "typebox";
+var engineDetourArgsSchema = Type20.Object(
   {
-    argv: Type19.Array(Type19.String({ minLength: 1 }), {
+    argv: Type20.Array(Type20.String({ minLength: 1 }), {
       minItems: 1,
       description: "\u9996\u9879\u4E3A PATH \u4E2D\u7684\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u5176\u4F59\u9879\u4E3A\u53C2\u6570\u3002"
     })
@@ -21696,10 +22294,10 @@ init_run_ticket_number();
 
 // src/audited-run-identity.ts
 init_role_run_placement();
-import { basename as basename14 } from "node:path";
+import { basename as basename15 } from "node:path";
 var AUDITED_RUN_IDENTITY_KIND = "audited-run-identity";
 function auditedRunIdentityFromDirectory(runDirectory) {
-  const parsed = parseRunLeaf(basename14(runDirectory));
+  const parsed = parseRunLeaf(basename15(runDirectory));
   if (parsed === void 0) return void 0;
   return formatRunLeaf(parsed.runId, parsed.role);
 }
@@ -21921,7 +22519,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 readdirSync4, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync17, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync5, rmdirSync, rmSync as rmSync3 } from "node:fs";
 import { resolve as resolve19 } from "node:path";
 var WORKER_SUBMISSION_GATE_RECORD_KIND = WORKER_SUBMISSION_GATE_KIND;
 var WORKER_COMMIT_BASELINE_ENTRY_TYPE = "commit-baseline";
@@ -21951,7 +22549,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 (!existsSync17(file)) return [];
   try {
     const out = gitFile(file, ["--get-all", key]);
     return out.length === 0 ? [] : out.split("\n");
@@ -21961,7 +22559,7 @@ function tryGetAll(file, key) {
   }
 }
 function ownedHook(path) {
-  if (!existsSync13(path)) return false;
+  if (!existsSync17(path)) return false;
   return readFileSync5(path, "utf8").includes(HOOK_MARKER);
 }
 function escapeGitConfigValueRegex(value) {
@@ -21988,11 +22586,11 @@ function rmOwnedDir(dir) {
   const hookPath = resolve19(dir, HOOK_FILE);
   if (!ownedHook(hookPath)) return;
   rmSync3(hookPath, { force: true });
-  if (existsSync13(dir) && readdirSync4(dir).length === 0) rmdirSync(dir);
+  if (existsSync17(dir) && readdirSync4(dir).length === 0) rmdirSync(dir);
 }
 function linkedGitDirs(commonDir) {
   const root = resolve19(commonDir, "worktrees");
-  if (!existsSync13(root)) return [];
+  if (!existsSync17(root)) return [];
   return readdirSync4(root).map((name) => resolve19(root, name)).filter((dir) => lstatSync3(dir).isDirectory());
 }
 function uninstallPackageWorkerHooks(cwd) {
@@ -22084,6 +22682,7 @@ function createWorkerSubmissionGate(options = {}) {
   let unfinishedReasonBounces = 0;
   let invocationScopeId;
   let record;
+  let parentRef;
   let sessionParent;
   const explicitHome = typeof options.home === "string" && options.home.length > 0 ? options.home : void 0;
   const unfinishedReasonBounceLimit = deliveryLimitFromConfig(options.unfinishedReasonBounceLimit);
@@ -22095,6 +22694,20 @@ function createWorkerSubmissionGate(options = {}) {
       return null;
     }
   };
+  const liveRecord = () => {
+    if (record === void 0 || root === void 0 || parentRef === void 0) return record;
+    const file = record.getSessionFile();
+    if (file !== void 0 && existsSync17(file)) return record;
+    const parentFile = parentRef.getSessionFile();
+    if (parentFile === void 0 || parentFile.length === 0) return record;
+    sessionParent = parentFile;
+    record = createRecordSession({
+      cwd: root,
+      kind: WORKER_SUBMISSION_GATE_RECORD_KIND,
+      parent: parentRef
+    });
+    return record;
+  };
   const gateSitian = (cwd, payload) => {
     sitianReport({
       level: "event",
@@ -22111,6 +22724,7 @@ function createWorkerSubmissionGate(options = {}) {
       invocationScopeId = scope;
       uninstallPackageWorkerHooks(cwd);
       root = cwd;
+      parentRef = parent;
       sessionParent = parent.getSessionFile();
       record = createRecordSession({
         cwd,
@@ -22139,9 +22753,10 @@ function createWorkerSubmissionGate(options = {}) {
       });
     },
     assertAcceptable(status, details) {
+      const gateRecord = liveRecord();
       if (status === "unfinished" && !unfinishedReasonPresent(details)) {
         if (unfinishedReasonBounces < unfinishedReasonBounceLimit) {
-          record?.appendCustomEntry(WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE, {
+          gateRecord?.appendCustomEntry(WORKER_UNFINISHED_REASON_BOUNCE_ENTRY_TYPE, {
             version: 1,
             invocationScopeId
           });
@@ -22154,7 +22769,7 @@ function createWorkerSubmissionGate(options = {}) {
       const headMoved = now !== null && (baseline === null || now !== baseline);
       if (!headMoved && !reminded) {
         reminded = true;
-        record?.appendCustomEntry(WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
+        gateRecord?.appendCustomEntry(WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
         gateSitian(root, {
           type: WORKER_COMMIT_REMINDER_BOUNCE_ENTRY_TYPE,
           version: 1
@@ -22168,7 +22783,7 @@ function createWorkerSubmissionGate(options = {}) {
         return;
       }
       prefixReminded = true;
-      record?.appendCustomEntry(WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
+      gateRecord?.appendCustomEntry(WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE, { version: 1 });
       gateSitian(root, {
         type: WORKER_PREFIX_REMINDER_BOUNCE_ENTRY_TYPE,
         version: 1
@@ -23634,6 +24249,10 @@ function createRoleRuntimeExtension(dependencies, deliveryRequestLimit) {
           }
         }
         await executeActivationStage(entry.role, activationStage(entry.role, activateByRole), { clock, writeTrace });
+        registerReportTicketTool(roleHost);
+        roleHost.setActiveTools([
+          .../* @__PURE__ */ new Set([...roleHost.getActiveTools(), REPORT_TICKET_TOOL_NAME])
+        ]);
         roleReferenceMaterials = await dependencies.loadRoleReferenceMaterials?.(entry.role) ?? "";
         if (!engineDetourRegistered) {
           engineDetourRegistered = registerEngineDetourTool(roleHost, hostActions);
@@ -23710,6 +24329,7 @@ import { createServer } from "node:net";
 import { dirname as dirname21 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 init_role_activation_flags();
+init_role_run_relocation();
 init_submission_correctable_error();
 init_navigator_invocation_identity();
 init_serialize_thrown_value();
@@ -23795,11 +24415,11 @@ async function prepareRoleEnvelope(options) {
       }
     });
   };
+  const mutableRequest = request;
   const context = {
     cwd: request.cwd,
     mode: "print",
     model: request.model === void 0 ? void 0 : { provider: request.model.provider },
-    runDirectory: request.runDirectory,
     ...request.courtAttemptId === void 0 ? {} : { courtAttemptId: request.courtAttemptId },
     ...request.invocationScopeId === void 0 ? {} : { invocationScopeId: request.invocationScopeId },
     ...request.host === void 0 || request.host.trim() === "" ? {} : { host: request.host.trim() },
@@ -23824,6 +24444,25 @@ async function prepareRoleEnvelope(options) {
     abort() {
     }
   };
+  Object.defineProperty(context, "runDirectory", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return mutableRequest.runDirectory;
+    },
+    set(next) {
+      if (typeof next !== "string" || next.trim() === "") return;
+      if (mutableRequest.runDirectory === next) return;
+      projectTurnRequestLiveRunDirectory(mutableRequest, next);
+      sessionFile = sessionFileOf(next);
+      if (typeof mutableRequest.principal.sessionDirectory !== "string") {
+        mutableRequest.principal.sessionDirectory = sessionDirectoryOf(next);
+      }
+      if (typeof mutableRequest.principal.sessionFile !== "string") {
+        mutableRequest.principal.sessionFile = sessionFile;
+      }
+    }
+  });
   const bookCustomMessage = (customType, message) => {
     const payload = {
       ...message.content === void 0 ? {} : { content: message.content },
@@ -24152,7 +24791,7 @@ async function prepareRoleEnvelope(options) {
       });
     } catch (error) {
       await retainPackageFault({
-        runDirectory: request.runDirectory,
+        runDirectory: mutableRequest.runDirectory,
         diagnostic: `relay close failed beside envelope shutdown: ${describeErrorIdentity(error)}`,
         error
       });
@@ -24285,165 +24924,16 @@ init_session_identity();
 
 // src/headless-host/role-turn-host.ts
 init_role_run_placement();
+init_external_host_turn_loop();
+init_run_lifecycle();
+init_settlement();
 import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { mkdtemp, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname as dirname22, isAbsolute as isAbsolute11, join as join34, resolve as resolve20 } from "node:path";
 
-// src/external-host-turn-loop.ts
-init_settlement();
-init_run_lifecycle();
-init_receipt_delivery_policy();
-init_sitian_facade();
-init_submission_errors();
-async function recordTurnDelivery(runDirectory, delivered, source) {
-  try {
-    reportRunRecord(runDirectory, "turn-delivery", {
-      systemPrompt: delivered.systemPrompt,
-      ...delivered.outputSchema === void 0 ? {} : { outputSchema: delivered.outputSchema }
-    }, source);
-  } catch (error) {
-    await retainPackageFault({
-      runDirectory,
-      diagnostic: `turn delivery record failed beside host start: ${describeErrorIdentity(error)}`,
-      error
-    });
-  }
-}
-function mergeRoleTurnAbortSignals(prepared, request) {
-  if (request === void 0) return prepared;
-  if (prepared === void 0) return request;
-  return AbortSignal.any([prepared, request]);
-}
-function isHostAbortedError(error) {
-  return typeof error === "object" && error !== null && error.code === "host-aborted";
-}
-function hostAbortedError(message = "host aborted") {
-  return Object.assign(new Error(message), { code: "host-aborted" });
-}
-function externalHostFailure(cause, name, code, details, diagnostic) {
-  return asFailure({
-    cause,
-    identity: { name, code },
-    ...diagnostic === void 0 ? {} : { diagnostic },
-    ...details === void 0 ? {} : { details }
-  });
-}
-function asFailure(knownFailure, stderr = "") {
-  return { code: null, stderr, timedOut: false, knownFailure };
-}
-async function settleHostAborted(prepared, sessionId) {
-  const closure = await prepared.closeRound();
-  if ("failure" in closure) return asFailure(closure.failure);
-  return asFailure({
-    cause: "session",
-    identity: { name: "HostAborted", code: "host-aborted" },
-    ...sessionId === void 0 ? {} : { details: { sessionId } }
-  });
-}
-async function driveExternalRoleTurnRounds(prepared, request, driver) {
-  let prompt = prepared.prompt;
-  const abortSignal = mergeRoleTurnAbortSignals(prepared.abortSignal, request.signal);
-  let result = { code: 0, stderr: "", timedOut: false };
-  const countedReaskLimit = deliveryLimitFromConfig(request.deliveryRequestLimit);
-  const exemptReminders = /* @__PURE__ */ new Set();
-  let countedReasks = 0;
-  for (let attempt = 0; ; attempt += 1) {
-    if (abortSignal?.aborted) return settleHostAborted(prepared, driver.currentSessionId());
-    let round;
-    try {
-      round = await driver.runRound({ prompt, abortSignal, attempt });
-    } catch (error) {
-      if (isHostAbortedError(error)) return settleHostAborted(prepared, driver.currentSessionId());
-      throw error;
-    }
-    if (round.status === "terminal") return round.result;
-    result = {
-      code: round.code !== void 0 ? round.code : 0,
-      stderr: round.stderr ?? "",
-      timedOut: round.timedOut === true,
-      ...round.signal === void 0 ? {} : { signal: round.signal }
-    };
-    let closure;
-    try {
-      closure = await prepared.closeRound();
-    } catch (error) {
-      await retainPackageFault({
-        runDirectory: request.runDirectory,
-        diagnostic: `round closure failed beside host terminal: ${describeErrorIdentity(error)}`,
-        error
-      });
-      return result.code === 0 && !result.timedOut && result.signal === void 0 ? { ...result, knownFailure: projectThrownFailureLeaf(error) } : result;
-    }
-    if (closure.accepted) {
-      try {
-        await driver.afterAccepted?.();
-      } catch (error) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
-          diagnostic: `post-acceptance close failed beside host terminal: ${describeErrorIdentity(error)}`,
-          error
-        });
-      }
-      return result;
-    }
-    if ("failure" in closure) {
-      await retainPackageFault({
-        runDirectory: request.runDirectory,
-        diagnostic: `round closure failed beside host terminal: ${JSON.stringify(closure.failure)}`
-      });
-      return result.code === 0 && !result.timedOut && result.signal === void 0 ? { ...result, knownFailure: closure.failure } : result;
-    }
-    if (result.code !== 0 || result.signal !== void 0 || result.timedOut) return result;
-    const reminderCode = closure.retry.code;
-    const exempt = isOneShotWorkerReminderCode(reminderCode) && !exemptReminders.has(reminderCode);
-    if (exempt) exemptReminders.add(reminderCode);
-    else {
-      countedReasks += 1;
-      if (countedReasks > countedReaskLimit) {
-        await retainPackageFault({
-          runDirectory: request.runDirectory,
-          diagnostic: `${driver.roundLimitName}: round-retry-limit`
-        });
-        return result;
-      }
-    }
-    prompt = closure.retry.message;
-    driver.afterRetry?.();
-  }
-}
-async function disposeExternalRoleTurn(prepared, request, outcome) {
-  try {
-    await prepared.dispose?.();
-  } catch (error) {
-    await retainPackageFault({
-      runDirectory: request.runDirectory,
-      diagnostic: `required envelope shutdown failed beside host terminal: ${describeErrorIdentity(error)}`,
-      error
-    });
-    if (outcome.code === 0 && !outcome.timedOut && outcome.signal === void 0 && outcome.knownFailure === void 0) {
-      return { ...outcome, knownFailure: projectThrownFailureLeaf(error) };
-    }
-  }
-  return outcome;
-}
-function createSerializedRoleTurnHost(execute) {
-  let serial = Promise.resolve();
-  return {
-    executeTurn(request) {
-      const execution = serial.then(() => execute(request));
-      serial = execution.then(() => void 0, () => void 0);
-      return execution;
-    }
-  };
-}
-
-// src/headless-host/role-turn-host.ts
-init_run_lifecycle();
-init_settlement();
-
 // src/agent-start-materials.ts
 function renderAgentStartMaterials(body, materials) {
   if (materials.length === 0) return body;
@@ -24829,7 +25319,7 @@ function formatCodexFailurePayload(payload) {
 function cwdIsGitWorkTree(cwd) {
   let dir = cwd;
   for (; ; ) {
-    if (existsSync14(join34(dir, ".git"))) return true;
+    if (existsSync18(join34(dir, ".git"))) return true;
     const parent = dirname22(dir);
     if (parent === dir) return false;
     dir = parent;
@@ -25046,7 +25536,7 @@ function createHeadlessRoleTurnHost(config) {
           await config.sessionIdentity.bind(request.principal, sessionId);
         }
         const env = { ...process.env, ...config.env ?? {} };
-        const sessionParent = config.sessionIdentity.resolveSessionFile(request.principal);
+        const liveSessionParent = () => config.sessionIdentity.resolveSessionFile(request.principal);
         const inputsDirectory = await mkdtemp(join34(tmpdir(), "ak-role-headless-"));
         const systemPromptPath = join34(inputsDirectory, "system-prompt.txt");
         let mcpConfigPath;
@@ -25077,8 +25567,7 @@ function createHeadlessRoleTurnHost(config) {
           try {
             await rm2(inputsDirectory, { recursive: true, force: true });
           } catch (cleanupError) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `headless turn inputs cleanup failed beside setup failure: ${describeErrorIdentity(cleanupError)}`,
               error: cleanupError
             });
@@ -25127,11 +25616,11 @@ function createHeadlessRoleTurnHost(config) {
                   host: config.hostName,
                   sessionId,
                   cwd: request.cwd,
-                  sessionParent,
+                  sessionParent: liveSessionParent(),
                   home: request.home
                 }) !== void 0;
               }
-              await recordTurnDelivery(request.runDirectory, {
+              await recordTurnDelivery(await syncTurnRequestLivePlacement(request), {
                 systemPrompt,
                 ...startedWithSchema === void 0 ? {} : { outputSchema: startedWithSchema }
               }, "headless-host");
@@ -25157,7 +25646,7 @@ function createHeadlessRoleTurnHost(config) {
                     codexObserver?.observe(event);
                     if (!codex && typeof event === "object" && event !== null && "session_id" in event && typeof event.session_id === "string" && event.session_id !== "" && event.session_id !== sessionId) {
                       sessionId = event.session_id;
-                      recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent, home: request.home });
+                      recordNativeSessionPointer({ host: config.hostName, sessionId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home });
                     }
                     if (codex && !codexIdObserved) {
                       const tid = codexObserver?.result().threadId;
@@ -25167,7 +25656,7 @@ function createHeadlessRoleTurnHost(config) {
                           host: config.hostName,
                           sessionId: tid,
                           cwd: request.cwd,
-                          sessionParent,
+                          sessionParent: liveSessionParent(),
                           home: request.home
                         }) !== void 0;
                       }
@@ -25178,7 +25667,7 @@ function createHeadlessRoleTurnHost(config) {
                 exitedSessionId = roundSessionId;
                 if (codex && roundSessionId !== void 0 && roundSessionId !== "" && !pointerRecorded) {
                   try {
-                    recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent, home: request.home });
+                    recordNativeSessionPointer({ host: config.hostName, sessionId: roundSessionId, cwd: request.cwd, sessionParent: liveSessionParent(), home: request.home });
                   } catch (error) {
                     spawned.packageErrors = [...spawned.packageErrors, error];
                   }
@@ -25195,16 +25684,14 @@ function createHeadlessRoleTurnHost(config) {
                 };
               }
               for (const error of spawned.packageErrors) {
-                await retainPackageFault({
-                  runDirectory: request.runDirectory,
+                await retainPackageFaultBesideLivePlacement(request, {
                   diagnostic: `headless transport handling failed beside host terminal: ${describeErrorIdentity(error)}`,
                   error
                 });
               }
               try {
                 const noteBeside = async (error, what) => {
-                  await retainPackageFault({
-                    runDirectory: request.runDirectory,
+                  await retainPackageFaultBesideLivePlacement(request, {
                     diagnostic: `${what}: ${describeErrorIdentity(error)}`,
                     error
                   });
@@ -25272,8 +25759,7 @@ function createHeadlessRoleTurnHost(config) {
                 }
                 return deliveredFromSpawned(spawned);
               } catch (error) {
-                await retainPackageFault({
-                  runDirectory: request.runDirectory,
+                await retainPackageFaultBesideLivePlacement(request, {
                   diagnostic: `required turn handling failed beside host terminal: ${describeErrorIdentity(error)}`,
                   error
                 });
@@ -25285,27 +25771,35 @@ function createHeadlessRoleTurnHost(config) {
             }
           });
         } finally {
+          const live = await trySyncTurnRequestLivePlacement(request);
+          const liveRunDirectory = "runDirectory" in live ? live.runDirectory : void 0;
+          if (liveRunDirectory === void 0 && "resolveError" in live) {
+            await retainPackageFaultBesideLivePlacement(request, {
+              diagnostic: `headless cleanup live path resolve failed beside host terminal: ${describeErrorIdentity(live.resolveError)}`,
+              error: live.resolveError
+            });
+          }
           try {
             await rm2(inputsDirectory, { recursive: true, force: true });
           } catch (error) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `headless turn inputs cleanup failed beside host terminal: ${describeErrorIdentity(error)}`,
               error
             });
           }
           try {
-            if (exitedSessionId !== void 0 && exitedSessionId !== "") copyAndRecordHostDossier({
-              host: config.hostName,
-              sessionId: exitedSessionId,
-              cwd: request.cwd,
-              sessionDirectory: sessionDirectoryOf(request.runDirectory),
-              sessionParent,
-              ...request.home !== void 0 ? { home: request.home } : {}
-            });
+            if (exitedSessionId !== void 0 && exitedSessionId !== "" && liveRunDirectory !== void 0) {
+              copyAndRecordHostDossier({
+                host: config.hostName,
+                sessionId: exitedSessionId,
+                cwd: request.cwd,
+                sessionDirectory: sessionDirectoryOf(liveRunDirectory),
+                sessionParent: sessionFileOf(liveRunDirectory),
+                ...request.home !== void 0 ? { home: request.home } : {}
+              });
+            }
           } catch (error) {
-            await retainPackageFault({
-              runDirectory: request.runDirectory,
+            await retainPackageFaultBesideLivePlacement(request, {
               diagnostic: `host dossier copy failed beside host terminal: ${describeErrorIdentity(error)}`,
               error
             });