@akagilnc/pi-workflow-roles 0.1.4035 → 0.1.4193

package/dist/public-cli/main.js

@@ -377,6 +377,146 @@ var init_activation_ledger_topology = __esm({
   }
 });
 
+// src/run-ticket-number.ts
+import { readFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isSafePositiveTicketNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+}
+function requireSafePositiveTicketNumber(ticketNumber, context = "ticketNumber") {
+  if (!isSafePositiveTicketNumber(ticketNumber)) {
+    throw new Error(
+      `${context} requires a safe positive integer, got ${String(ticketNumber)}`
+    );
+  }
+  return ticketNumber;
+}
+function ticketFromRecord(record4) {
+  return isSafePositiveTicketNumber(record4.ticketNumber) ? record4.ticketNumber : void 0;
+}
+async function readJsonObject(path) {
+  try {
+    const raw = JSON.parse(await readFile(path, "utf8"));
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return void 0;
+    }
+    return raw;
+  } catch (error) {
+    if (isEnoent(error)) return void 0;
+    throw error;
+  }
+}
+async function readBoardPageTicketNumber(runDirectory, page) {
+  const record4 = await readJsonObject(join3(runDirectory, page));
+  if (record4 === void 0) return void 0;
+  return ticketFromRecord(record4);
+}
+async function readBoardTicketNumber(runDirectory) {
+  return await readBoardPageTicketNumber(runDirectory, "admitted-request.json") ?? await readBoardPageTicketNumber(runDirectory, "invocation.json");
+}
+async function readMigrationDerivedTicketNumber(runDirectory) {
+  const record4 = await readJsonObject(
+    join3(runDirectory, MIGRATION_TICKET_DERIVATION_PAGE)
+  );
+  if (record4 === void 0) return void 0;
+  if (record4.derivation !== "worktree-path-basename") return void 0;
+  return ticketFromRecord(record4);
+}
+async function readRunTicketNumber(runDirectory) {
+  return await readBoardTicketNumber(runDirectory) ?? await readMigrationDerivedTicketNumber(runDirectory);
+}
+var MIGRATION_TICKET_DERIVATION_PAGE;
+var init_run_ticket_number = __esm({
+  "src/run-ticket-number.ts"() {
+    "use strict";
+    MIGRATION_TICKET_DERIVATION_PAGE = "migration-ticket-derivation.json";
+  }
+});
+
+// src/role-run-placement.ts
+import { readdir } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function isMissingPathError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function listBookRunDirectories(bookDir) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = async (runsDir) => {
+    let entries;
+    try {
+      entries = await readdir(runsDir, { withFileTypes: true });
+    } catch (error) {
+      if (isMissingPathError(error)) return;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const runDir = join4(runsDir, entry.name);
+      if (seen.has(runDir)) continue;
+      seen.add(runDir);
+      out.push(runDir);
+    }
+  };
+  await collect(join4(bookDir, "runs"));
+  let subjects;
+  try {
+    subjects = await readdir(bookDir, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingPathError(error)) return out.sort();
+    throw error;
+  }
+  for (const subject of subjects) {
+    if (!subject.isDirectory() || subject.name === "runs") continue;
+    await collect(join4(bookDir, subject.name, "runs"));
+  }
+  return out.sort();
+}
+function roleRunPlacement(ledgerHome, input) {
+  const subjectDirectory = "ticketNumber" in input.subject ? String(requireSafePositiveTicketNumber(
+    input.subject.ticketNumber,
+    "roleRunPlacement subject.ticketNumber"
+  )) : "unbound";
+  const runDirectory = join4(
+    activationBookDirectory(ledgerHome, input.bookKey),
+    subjectDirectory,
+    "runs",
+    `${input.runId}@${input.role}`
+  );
+  const sessionDirectory = join4(runDirectory, "session");
+  return {
+    runDirectory,
+    sessionDirectory,
+    sessionFile: join4(sessionDirectory, "session.jsonl"),
+    artifactsDirectory: roleRunArtifactsDirectory(runDirectory),
+    attachmentsDirectory: join4(runDirectory, "attachments")
+  };
+}
+function roleRunArtifactsDirectory(runDirectory) {
+  return join4(runDirectory, "artifacts");
+}
+function ensureRoleRunDirectory(ledgerHome, directory) {
+  return ensureRealDirectoryTree(ledgerHome, directory);
+}
+function ensureRoleRunPlacement(ledgerHome, placement) {
+  for (const directory of [
+    placement.sessionDirectory,
+    placement.attachmentsDirectory
+  ]) {
+    ensureRoleRunDirectory(ledgerHome, directory);
+  }
+}
+var init_role_run_placement = __esm({
+  "src/role-run-placement.ts"() {
+    "use strict";
+    init_activation_ledger_topology();
+    init_run_ticket_number();
+  }
+});
+
 // src/pi/durable-principal.ts
 var durable_principal_exports = {};
 __export(durable_principal_exports, {
@@ -384,25 +524,23 @@ __export(durable_principal_exports, {
   piDurablePrincipalAuthority: () => piDurablePrincipalAuthority
 });
 import { lstat } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 function encode(coordinates) {
   return coordinates;
 }
 function issuePiDurablePrincipalCoordinates(request) {
   const ledgerHome = resolveActivationLedgerHome(request.home);
   const bookKey = resolveBookKeyFromGit(request.cwd);
-  const runDirectory = join3(
-    activationBookDirectory(ledgerHome, bookKey),
-    "runs",
-    `${request.runId}@${request.role}`
-  );
-  const sessionDirectory = join3(runDirectory, "session");
+  const placement = roleRunPlacement(ledgerHome, {
+    bookKey,
+    subject: { unbound: true },
+    runId: request.runId,
+    role: request.role
+  });
   return {
     ledgerHome,
     bookKey,
-    runDirectory,
-    sessionDirectory,
-    sessionFile: join3(sessionDirectory, "session.jsonl")
+    ...placement
   };
 }
 var piDurablePrincipalAuthority;
@@ -411,6 +549,7 @@ var init_durable_principal = __esm({
     "use strict";
     init_activation_ledger_git();
     init_activation_ledger_topology();
+    init_role_run_placement();
     piDurablePrincipalAuthority = {
       issue(request) {
         const coordinates = issuePiDurablePrincipalCoordinates(request);
@@ -435,7 +574,7 @@ var init_durable_principal = __esm({
         }
         return {
           sessionDirectory: record4.sessionDirectory,
-          sessionFile: typeof record4.sessionFile === "string" && record4.sessionFile.trim() !== "" ? record4.sessionFile : join3(record4.sessionDirectory, "session.jsonl")
+          sessionFile: typeof record4.sessionFile === "string" && record4.sessionFile.trim() !== "" ? record4.sessionFile : join5(record4.sessionDirectory, "session.jsonl")
         };
       },
       async isAvailable(principal) {
@@ -453,7 +592,7 @@ var init_durable_principal = __esm({
 
 // src/package-resources/engine-material.ts
 import { existsSync as existsSync2, readdirSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 function pickEngineAxis(source) {
   return {
     ...source.engine === void 0 ? {} : { engine: source.engine },
@@ -474,11 +613,11 @@ function isEngineNameSyntax(name) {
   return true;
 }
 function resolveEngineMaterialDirectory(packageRoot2) {
-  return join4(packageRoot2, ENGINE_MATERIAL_RELATIVE_ROOT);
+  return join6(packageRoot2, ENGINE_MATERIAL_RELATIVE_ROOT);
 }
 function resolveEngineMaterialPath(packageRoot2, name) {
   const legal = assertLegalEngineName(name);
-  return join4(resolveEngineMaterialDirectory(packageRoot2), `${legal}.md`);
+  return join6(resolveEngineMaterialDirectory(packageRoot2), `${legal}.md`);
 }
 function assertLegalEngineName(name) {
   if (!isEngineNameSyntax(name)) {
@@ -14710,10 +14849,84 @@ var init_auditor_output = __esm({
 });
 
 // src/diarist-contracts.ts
+function projectCourtTicketNumbers(raw, options) {
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    if (!isSafePositiveTicketNumber(item)) continue;
+    if (seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  const principal = options?.principalTicket;
+  if (principal === void 0) return out;
+  requireSafePositiveTicketNumber(principal, "projectCourtTicketNumbers principalTicket");
+  if (seen.has(principal)) return out;
+  return [principal, ...out];
+}
+function interpretDurableCourtTicketNumbers(record4, options) {
+  if (!Object.hasOwn(record4, "courtTicketNumbers")) {
+    return { kind: "absent" };
+  }
+  const raw = record4.courtTicketNumbers;
+  if (!Array.isArray(raw)) {
+    return {
+      kind: "damage",
+      reason: "courtTicketNumbers is present but not an array"
+    };
+  }
+  if (raw.length === 0) {
+    return {
+      kind: "damage",
+      reason: "courtTicketNumbers is present but empty"
+    };
+  }
+  for (let i = 0; i < raw.length; i += 1) {
+    const item = raw[i];
+    if (!isSafePositiveTicketNumber(item)) {
+      return {
+        kind: "damage",
+        reason: `courtTicketNumbers[${i}] is not a safe positive integer`
+      };
+    }
+  }
+  const tickets = projectCourtTicketNumbers(raw);
+  if (tickets === null || tickets.length === 0) {
+    return {
+      kind: "damage",
+      reason: "courtTicketNumbers projected empty after lawful members"
+    };
+  }
+  const principal = options?.principalTicket;
+  if (principal !== void 0) {
+    if (!isSafePositiveTicketNumber(principal)) {
+      return {
+        kind: "damage",
+        reason: "courtTicketNumbers principal ticket is not a safe positive integer"
+      };
+    }
+    if (!tickets.includes(principal)) {
+      return {
+        kind: "damage",
+        reason: `courtTicketNumbers is missing principal ticket #${principal}`
+      };
+    }
+  }
+  return { kind: "ok", tickets: Object.freeze([...tickets]) };
+}
+function sameCourtTicketNumbers(left, right) {
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
 var DIARIST_OUTPUT_TOOL_NAME;
 var init_diarist_contracts = __esm({
   "src/diarist-contracts.ts"() {
     "use strict";
+    init_run_ticket_number();
     DIARIST_OUTPUT_TOOL_NAME = "ak_diarist_output";
   }
 });
@@ -14892,7 +15105,7 @@ var init_packaged_role_registry = __esm({
         role: "inspector",
         phases: [null],
         outputTool: INSPECTOR_OUTPUT_TOOL_NAME,
-        inputFlag: void 0,
+        inputFlag: "ak-inspector-source-run",
         phaseFlag: void 0,
         activationStage: "load-and-install",
         sessionMaterials: INSPECTOR_SESSION_MATERIALS
@@ -15229,8 +15442,8 @@ __export(config_exports, {
   setPersistentSeatHost: () => setPersistentSeatHost,
   validatePublicCliConfigAxes: () => validatePublicCliConfigAxes
 });
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { dirname as dirname4, join as join7 } from "node:path";
 function isGateOfficerSeat(value) {
   return GATE_OFFICER_SEATS.includes(value);
 }
@@ -15238,12 +15451,12 @@ function publicCliConfigPath(home) {
   if (typeof home !== "string" || home.trim() === "") {
     throw new Error("home must be explicitly provided");
   }
-  return join5(home, ".ak-roles", "public-cli.json");
+  return join7(home, ".ak-roles", "public-cli.json");
 }
 async function loadPublicCliConfig(home) {
   const path = publicCliConfigPath(home);
   try {
-    const raw = await readFile(path, "utf8");
+    const raw = await readFile2(path, "utf8");
     return parsePublicCliConfig(JSON.parse(raw));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -15706,7 +15919,7 @@ function credentialProvidersFromAuthData(data) {
 }
 async function loadCredentialProviders(agentDir) {
   try {
-    const raw = await readFile(join5(agentDir, "auth.json"), "utf8");
+    const raw = await readFile2(join7(agentDir, "auth.json"), "utf8");
     return credentialProvidersFromAuthData(JSON.parse(raw));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -15745,15 +15958,15 @@ __export(host_providers_exports, {
   renderHostProvidersTable: () => renderHostProvidersTable
 });
 import { readFileSync } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function hostProvidersPath(home) {
   if (typeof home !== "string" || home.trim() === "") {
     throw new Error("home must be explicitly provided");
   }
-  return join6(home, ".ak-roles", "host-providers.json");
+  return join8(home, ".ak-roles", "host-providers.json");
 }
 function hermesProviderModelsCachePath(home) {
-  return join6(home, ".hermes", "provider_models_cache.json");
+  return join8(home, ".hermes", "provider_models_cache.json");
 }
 function parseHostProvidersTable(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
@@ -15926,6 +16139,9 @@ var init_cli_errors = __esm({
 });
 
 // src/host-contracts.ts
+function isOfficerReviewSeat(role) {
+  return role === "notary" || role === "inspector" || role === "auditor";
+}
 var ExplicitInternalActivationError;
 var init_host_contracts = __esm({
   "src/host-contracts.ts"() {
@@ -15963,12 +16179,13 @@ function applyEngineChildEnv(childEnv, engine) {
     childEnv[AK_ROLE_ENGINE_ENV] = void 0;
   }
 }
-var ENGINE_DETOUR_TOOL_NAME, AK_ROLE_ENGINE_ENV;
+var ENGINE_DETOUR_TOOL_NAME, AK_ROLE_ENGINE_ENV, ENGINE_MODEL_FLAG_NAME;
 var init_engine_detour = __esm({
   "src/engine-detour.ts"() {
     "use strict";
     ENGINE_DETOUR_TOOL_NAME = "ak_engine_detour";
     AK_ROLE_ENGINE_ENV = "AK_ROLE_ENGINE";
+    ENGINE_MODEL_FLAG_NAME = "ak-engine-model";
   }
 });
 
@@ -16019,6 +16236,18 @@ var init_role_activation_flags = __esm({
   }
 });
 
+// src/user-dialogue-stdin.ts
+function encodeUserDialogueStdin(body) {
+  return JSON.stringify({ kind: USER_DIALOGUE_STDIN_KIND, body });
+}
+var USER_DIALOGUE_STDIN_KIND;
+var init_user_dialogue_stdin = __esm({
+  "src/user-dialogue-stdin.ts"() {
+    "use strict";
+    USER_DIALOGUE_STDIN_KIND = "ak-user-dialogue";
+  }
+});
+
 // src/sitian-contracts.ts
 function attachDirectErrnoCode(error, cause) {
   if (cause === null || typeof cause !== "object" || !("code" in cause)) return;
@@ -16049,7 +16278,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { basename as basename3, dirname as dirname5, join as join7, resolve as resolve3 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -16176,38 +16405,23 @@ function resolveSitianVolumeCategory(kind) {
   }
   return kind;
 }
-function safeBookKey(cwd) {
-  try {
-    return resolveBookKeyFromGit(cwd);
-  } catch {
-    return basename3(resolve3(cwd)) || "default";
-  }
-}
 function resolveSitianRecordPathInLedger(input, ledgerHome) {
-  const cwd = input.cwd ?? process.cwd();
   const category = resolveSitianVolumeCategory(input.kind);
+  const ticketNumber = category === "ticket-provenance" ? typeof input.subject === "string" && /^[1-9][0-9]*$/.test(input.subject) ? input.subject : typeof input.subject === "object" && typeof input.subject.ticketNumber === "number" && Number.isSafeInteger(input.subject.ticketNumber) && input.subject.ticketNumber > 0 ? String(input.subject.ticketNumber) : void 0 : void 0;
   let sessionDir;
-  if (input.sessionParent !== void 0 && input.sessionParent.length > 0 && physicallyContainedIn(ledgerHome, input.sessionParent)) {
-    sessionDir = join7(dirname5(input.sessionParent), category);
+  if (ticketNumber !== void 0) {
+    const bookDir = activationBookDirectory(
+      ledgerHome,
+      resolveBookKeyFromGit(input.cwd ?? process.cwd())
+    );
+    sessionDir = join9(bookDir, ticketNumber);
   } else {
-    const bookKey = safeBookKey(cwd);
-    const bookDir = activationBookDirectory(ledgerHome, bookKey);
-    if (input.subject !== void 0) {
-      let subjectStr;
-      if (typeof input.subject === "string") {
-        subjectStr = input.subject;
-      } else if (typeof input.subject.runId === "string" && input.subject.runId.length > 0) {
-        subjectStr = input.subject.runId;
-      } else {
-        subjectStr = JSON.stringify(input.subject);
-      }
-      const digest = createHash("sha256").update(subjectStr).digest("hex").slice(0, 32);
-      sessionDir = join7(bookDir, category, digest);
-    } else {
-      sessionDir = join7(bookDir, category);
+    if (input.sessionParent === void 0 || input.sessionParent.length === 0 || !physicallyContainedIn(ledgerHome, input.sessionParent)) {
+      throw new Error("Sitian record ownership requires a parent session inside the ledger home");
     }
+    sessionDir = join9(dirname5(input.sessionParent), category);
   }
-  const recordFile = join7(sessionDir, "records.jsonl");
+  const recordFile = join9(sessionDir, "records.jsonl");
   return { sessionDir, recordFile, ledgerHome };
 }
 function resolveSitianRecordPath(input) {
@@ -16265,7 +16479,7 @@ var init_sitian_appender = __esm({
 
 // src/sitian-reader.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -16273,7 +16487,7 @@ async function readSitianRecords(recordFile) {
   if (!existsSync4(recordFile)) {
     return { records: [], diagnostics: [] };
   }
-  const text = await readFile2(recordFile, "utf8");
+  const text = await readFile3(recordFile, "utf8");
   const lines = text.split("\n");
   const records = [];
   const diagnostics = [];
@@ -16338,13 +16552,13 @@ __export(role_turn_host_exports, {
 });
 import { execFile, spawn } from "node:child_process";
 import { constants } from "node:fs";
-import { access, appendFile, readFile as readFile3, realpath } from "node:fs/promises";
-import { basename as basename4, delimiter as delimiter2, dirname as dirname6, isAbsolute as isAbsolute3, join as join8, resolve as resolve4 } from "node:path";
+import { access, appendFile, readFile as readFile4, realpath } from "node:fs/promises";
+import { basename as basename3, delimiter as delimiter2, dirname as dirname6, isAbsolute as isAbsolute3, join as join10, resolve as resolve3 } from "node:path";
 import { platform } from "node:process";
 import { promisify } from "node:util";
 import { randomUUID as randomUUID2 } from "node:crypto";
 function resolveInternalRoleEntrypoint(packageRoot2) {
-  return join8(packageRoot2, INTERNAL_ROLE_ENTRYPOINT_RELATIVE2);
+  return join10(packageRoot2, INTERNAL_ROLE_ENTRYPOINT_RELATIVE2);
 }
 function buildExplicitInternalActivationArgs(selectedRoleEntry, extraArgs = []) {
   return ["--no-extensions", "-e", selectedRoleEntry, ...extraArgs];
@@ -16380,7 +16594,7 @@ function buildMethodArgs(methods) {
 function applyPiNativeSkillInvocation(methods, prompt) {
   const skills = methods.filter((method) => method.kind === "skill");
   if (skills.length !== 1) return prompt;
-  const name = basename4(dirname6(skills[0].path));
+  const name = basename3(dirname6(skills[0].path));
   if (name.length === 0) return prompt;
   const token = `/skill:${name}`;
   const trimmed = prompt.trimStart();
@@ -16392,11 +16606,6 @@ function applyPiNativeSkillInvocation(methods, prompt) {
 }
 function buildPiTurnExtraArgs(request, authority, extraPiArgs = []) {
   const { sessionFile, sessionDirectory } = authority.decode(request.principal);
-  const rawPrompt = request.continuation.kind === "initial" || request.continuation.kind === "resume" ? request.continuation.prompt : (() => {
-    const _exhaustive = request.continuation;
-    return _exhaustive;
-  })();
-  const prompt = applyPiNativeSkillInvocation(request.methods, rawPrompt);
   return [
     "--no-skills",
     ...buildMethodArgs(request.methods),
@@ -16410,15 +16619,27 @@ function buildPiTurnExtraArgs(request, authority, extraPiArgs = []) {
     ...extraPiArgs,
     // Envelope assembly = projectActivationFlags; pi only renders argv pairs.
     ...activationFlagsToPiArgv(projectActivationFlags(request)),
+    ...piEngineModelArgs(request),
     "--mode",
     "json",
-    ...buildSeatModelCliArgs2(request.model),
-    prompt
+    ...buildSeatModelCliArgs2(request.model)
   ];
 }
+function piEngineModelArgs(request) {
+  const model = normalizeEngineName(request.engineModel);
+  if (model === void 0) return [];
+  return [`--${ENGINE_MODEL_FLAG_NAME}`, model];
+}
+function piUserDialogueBody(request) {
+  const rawPrompt = request.continuation.kind === "initial" || request.continuation.kind === "resume" ? request.continuation.prompt : (() => {
+    const _exhaustive = request.continuation;
+    return _exhaustive;
+  })();
+  return applyPiNativeSkillInvocation(request.methods, rawPrompt);
+}
 async function resolveSelectedPi(command, cwd, env) {
   const searchPath = env.PATH ?? (platform === "win32" ? process.env.PATH ?? "" : "/usr/bin:/bin");
-  const candidates = isAbsolute3(command) || command.includes("/") ? [resolve4(cwd, command)] : searchPath.split(delimiter2).map((dir) => resolve4(cwd, dir, command));
+  const candidates = isAbsolute3(command) || command.includes("/") ? [resolve3(cwd, command)] : searchPath.split(delimiter2).map((dir) => resolve3(cwd, dir, command));
   for (const candidate of candidates) {
     try {
       await access(candidate, constants.X_OK);
@@ -16455,11 +16676,22 @@ function createDefaultPiSpawnRunner(options) {
       const child = spawn(piIdentity.executable, [...args], {
         cwd: spawnOptions.cwd,
         env: spawnOptions.env,
-        stdio: ["ignore", "ignore", "pipe"]
+        stdio: ["pipe", "ignore", "pipe"]
       });
+      if (child.stdin === null) {
+        throw new Error("Pi child stdin pipe was not created");
+      }
       if (child.stderr === null) {
         throw new Error("Pi child stderr pipe was not created");
       }
+      let stdinDeliveryError;
+      child.stdin.on("error", (error) => {
+        stdinDeliveryError ??= error;
+      });
+      if (spawnOptions.stdin !== void 0) {
+        child.stdin.write(spawnOptions.stdin);
+      }
+      child.stdin.end();
       let stderr = "";
       let timedOut = false;
       let timer;
@@ -16512,6 +16744,10 @@ function createDefaultPiSpawnRunner(options) {
               reject(executionError);
               return;
             }
+            if (stdinDeliveryError !== void 0) {
+              reject(stdinDeliveryError);
+              return;
+            }
             resolveResult({
               code,
               stderr,
@@ -16535,7 +16771,8 @@ function createPiRoleTurnHost(config) {
   return {
     async executeTurn(request) {
       let turnRequest = request;
-      const paths = request.hostTransition?.priorNativeKind === "sitian" ? request.hostTransition.priorNativePaths : void 0;
+      const officerStationChild = request.stationChild === true && isOfficerReviewSeat(request.activation.role);
+      const paths = !officerStationChild && request.hostTransition?.priorNativeKind === "sitian" ? request.hostTransition.priorNativePaths : void 0;
       if (request.continuation.kind === "resume" && paths !== void 0 && paths.length > 0) {
         turnRequest = {
           ...request,
@@ -16553,6 +16790,7 @@ ${paths.join("\n")}`
         config.extraPiArgs ?? []
       );
       const args = buildExplicitInternalActivationArgs(roleEntry, extraArgs);
+      const stdin = encodeUserDialogueStdin(piUserDialogueBody(turnRequest));
       const env = {
         ...process.env,
         HOME: request.home,
@@ -16584,6 +16822,7 @@ ${paths.join("\n")}`
       return await spawnRunner(args, {
         cwd: request.cwd,
         env,
+        stdin,
         ...timeoutMs === void 0 ? {} : { timeoutMs },
         ...request.signal === void 0 ? {} : { signal: request.signal }
       });
@@ -16592,7 +16831,7 @@ ${paths.join("\n")}`
 }
 async function appendPiSessionCustomEntry(authority, principal, customType, data) {
   const { sessionFile } = authority.decode(principal);
-  const text = await readFile3(sessionFile, "utf8");
+  const text = await readFile4(sessionFile, "utf8");
   let parentId = null;
   for (const line2 of text.trim().split("\n").filter(Boolean)) {
     const entry = JSON.parse(line2);
@@ -16627,6 +16866,7 @@ var init_role_turn_host = __esm({
     init_host_contracts();
     init_engine_detour();
     init_role_activation_flags();
+    init_user_dialogue_stdin();
     init_sitian_facade();
     INTERNAL_ROLE_ENTRYPOINT_RELATIVE2 = "extensions/role-runtime.ts";
     EXPLICIT_INTERNAL_LOAD_PROBE_ARGS = [
@@ -16641,37 +16881,423 @@ var init_role_turn_host = __esm({
   }
 });
 
-// src/run-ticket-number.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-function isEnoent(error) {
+// src/auditor-dossier-tool.ts
+var init_auditor_dossier_tool = __esm({
+  "src/auditor-dossier-tool.ts"() {
+    "use strict";
+    init_role_run_placement();
+    init_build();
+  }
+});
+
+// src/readable-gate-item.ts
+var readable_gate_item_exports = {};
+__export(readable_gate_item_exports, {
+  joinReadableGateItems: () => joinReadableGateItems,
+  readableGateItem: () => readableGateItem
+});
+function readableGateItem(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function joinReadableGateItems(items, separator = "; ") {
+  return items.map(readableGateItem).join(separator);
+}
+var init_readable_gate_item = __esm({
+  "src/readable-gate-item.ts"() {
+    "use strict";
+  }
+});
+
+// src/submission-errors.ts
+var init_submission_errors = __esm({
+  "src/submission-errors.ts"() {
+    "use strict";
+    init_readable_gate_item();
+  }
+});
+
+// src/gatekeeper-role.ts
+var init_gatekeeper_role = __esm({
+  "src/gatekeeper-role.ts"() {
+    "use strict";
+    init_auditor_dossier_tool();
+    init_submission_errors();
+    init_inspector_contracts();
+    init_gatekeeper_output();
+    init_submission_errors();
+  }
+});
+
+// src/compliance-transport.ts
+var AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE;
+var init_compliance_transport = __esm({
+  "src/compliance-transport.ts"() {
+    "use strict";
+    init_auditor_dossier_tool();
+    init_gatekeeper_role();
+    AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
+    AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE = "ak_auditor_compliance_failure";
+  }
+});
+
+// src/role-run-relocation.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { readdir as readdir2, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join11, sep as sep2 } from "node:path";
+function isEnoent2(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-function ticketFromRecord(record4) {
-  const ticketNumber = record4.ticketNumber;
-  if (typeof ticketNumber === "number" && Number.isSafeInteger(ticketNumber) && ticketNumber >= 1) {
-    return ticketNumber;
+function rewriteRunDirectoryPathValue(value, oldRunDirectory, newRunDirectory) {
+  if (typeof value !== "string") return value;
+  if (value === oldRunDirectory) return newRunDirectory;
+  const prefix = `${oldRunDirectory}${sep2}`;
+  if (value.startsWith(prefix)) {
+    return `${newRunDirectory}${value.slice(oldRunDirectory.length)}`;
   }
-  return void 0;
+  return value;
 }
-async function readPageTicketNumber(runDirectory, page) {
-  try {
-    const raw = JSON.parse(await readFile4(join9(runDirectory, page), "utf8"));
-    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-      return void 0;
+function rewriteRunDirectoryPathValueAgainstRewrites(value, rewrites) {
+  if (typeof value !== "string" || rewrites.length === 0) return value;
+  let best;
+  for (const rewrite of rewrites) {
+    if (value === rewrite.oldRunDirectory || value.startsWith(`${rewrite.oldRunDirectory}${sep2}`)) {
+      if (best === void 0 || rewrite.oldRunDirectory.length > best.oldRunDirectory.length) {
+        best = rewrite;
+      }
     }
-    return ticketFromRecord(raw);
-  } catch (error) {
-    if (isEnoent(error)) return void 0;
-    throw error;
   }
+  if (best === void 0) return value;
+  return rewriteRunDirectoryPathValue(
+    value,
+    best.oldRunDirectory,
+    best.newRunDirectory
+  );
 }
-async function readRunTicketNumber(runDirectory) {
-  return await readPageTicketNumber(runDirectory, "admitted-request.json") ?? await readPageTicketNumber(runDirectory, "invocation.json");
+function rewriteRunDirectoryPathFields(record4, fields, oldRunDirectory, newRunDirectory) {
+  rewriteRunDirectoryPathFieldsAgainstRewrites(record4, fields, [
+    { oldRunDirectory, newRunDirectory }
+  ]);
 }
-var init_run_ticket_number = __esm({
-  "src/run-ticket-number.ts"() {
+function rewriteRunDirectoryPathFieldsAgainstRewrites(record4, fields, rewrites) {
+  for (const field of fields) {
+    if (field in record4) {
+      record4[field] = rewriteRunDirectoryPathValueAgainstRewrites(
+        record4[field],
+        rewrites
+      );
+    }
+  }
+}
+function collectRewrites(input) {
+  const own = {
+    oldRunDirectory: input.oldRunDirectory,
+    newRunDirectory: input.newRunDirectory
+  };
+  if (input.crossRunRewrites === void 0 || input.crossRunRewrites.length === 0) {
+    return [own];
+  }
+  const seen = /* @__PURE__ */ new Set([own.oldRunDirectory]);
+  const out = [own];
+  for (const rewrite of input.crossRunRewrites) {
+    if (seen.has(rewrite.oldRunDirectory)) continue;
+    seen.add(rewrite.oldRunDirectory);
+    out.push(rewrite);
+  }
+  return out;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function rewriteSourceRunLocator(value, rewrites) {
+  if (!isPlainObject(value)) return;
+  rewriteRunDirectoryPathFieldsAgainstRewrites(
+    value,
+    SOURCE_RUN_LOCATOR_FIELDS,
+    rewrites
+  );
+}
+function rewriteSummonsMaterials(value, rewrites) {
+  if (!isPlainObject(value)) return;
+  rewriteRunDirectoryPathFieldsAgainstRewrites(
+    value,
+    SUMMONS_PATH_FIELDS,
+    rewrites
+  );
+  rewriteSourceRunLocator(value.sourceRun, rewrites);
+  if (Array.isArray(value.attachmentPaths)) {
+    value.attachmentPaths = value.attachmentPaths.map(
+      (path) => rewriteRunDirectoryPathValueAgainstRewrites(path, rewrites)
+    );
+  }
+}
+async function rewriteJsonObjectFile(path, fields, rewrites) {
+  if (!existsSync5(path)) return;
+  const page = JSON.parse(await readFile5(path, "utf8"));
+  if (!isPlainObject(page)) return;
+  rewriteRunDirectoryPathFieldsAgainstRewrites(page, fields, rewrites);
+  await writeFile2(path, `${JSON.stringify(page, null, 2)}
+`, "utf8");
+}
+async function rewriteOfficerPointerFile(path, rewrites) {
+  if (!existsSync5(path)) return;
+  const page = JSON.parse(await readFile5(path, "utf8"));
+  if (!isPlainObject(page)) return;
+  if (page.kind !== "direct-officer-run-pointer") return;
+  rewriteRunDirectoryPathFieldsAgainstRewrites(
+    page,
+    OFFICER_POINTER_FIELDS,
+    rewrites
+  );
+  await writeFile2(path, `${JSON.stringify(page)}
+`, "utf8");
+}
+async function rewriteSitianRecordsJsonl(path, rewrites) {
+  if (!existsSync5(path)) return;
+  const raw = await readFile5(path, "utf8");
+  if (raw.length === 0) return;
+  const endsWithNewline = raw.endsWith("\n");
+  const lines = raw.split("\n");
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line2 = lines[i];
+    if (line2 === "" && i === lines.length - 1 && endsWithNewline) {
+      out.push("");
+      continue;
+    }
+    if (line2.trim() === "") {
+      out.push(line2);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line2);
+    } catch {
+      out.push(line2);
+      continue;
+    }
+    if (!isPlainObject(parsed)) {
+      out.push(line2);
+      continue;
+    }
+    if (!("sessionParent" in parsed)) {
+      out.push(line2);
+      continue;
+    }
+    const before = parsed.sessionParent;
+    rewriteRunDirectoryPathFieldsAgainstRewrites(
+      parsed,
+      SITIAN_RECORD_FIELDS,
+      rewrites
+    );
+    if (parsed.sessionParent !== before) changed = true;
+    out.push(JSON.stringify(parsed));
+  }
+  if (!changed) return;
+  const body = out.join("\n");
+  await writeFile2(
+    path,
+    endsWithNewline && !body.endsWith("\n") ? `${body}
+` : body,
+    "utf8"
+  );
+}
+async function rewriteSessionTranscriptBindings(path, rewrites) {
+  if (!existsSync5(path)) return;
+  const raw = await readFile5(path, "utf8");
+  if (raw.length === 0) return;
+  const endsWithNewline = raw.endsWith("\n");
+  const lines = raw.split("\n");
+  let changed = false;
+  const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line2 = lines[i];
+    if (line2 === "" && i === lines.length - 1 && endsWithNewline) {
+      out.push("");
+      continue;
+    }
+    if (line2.trim() === "") {
+      out.push(line2);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line2);
+    } catch {
+      out.push(line2);
+      continue;
+    }
+    if (!isPlainObject(parsed)) {
+      out.push(line2);
+      continue;
+    }
+    let lineChanged = false;
+    if (parsed.type === "session" && "parentSession" in parsed) {
+      const before = parsed.parentSession;
+      rewriteRunDirectoryPathFieldsAgainstRewrites(
+        parsed,
+        SESSION_HEADER_FIELDS,
+        rewrites
+      );
+      if (parsed.parentSession !== before) lineChanged = true;
+    } else if (parsed.type === "custom" && parsed.customType === AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE && isPlainObject(parsed.data) && isPlainObject(parsed.data.parent)) {
+      const parent = parsed.data.parent;
+      const before = parent.sessionFile;
+      rewriteRunDirectoryPathFieldsAgainstRewrites(
+        parent,
+        BINDING_PARENT_FIELDS,
+        rewrites
+      );
+      if (parent.sessionFile !== before) lineChanged = true;
+    }
+    if (lineChanged) changed = true;
+    out.push(lineChanged ? JSON.stringify(parsed) : line2);
+  }
+  if (!changed) return;
+  const body = out.join("\n");
+  await writeFile2(
+    path,
+    endsWithNewline && !body.endsWith("\n") ? `${body}
+` : body,
+    "utf8"
+  );
+}
+async function rewriteNestedMachinePathPages(pagesDirectory, rewrites) {
+  const sessionRoot = join11(pagesDirectory, "session");
+  async function walk(directory) {
+    let entries;
+    try {
+      entries = await readdir2(directory, { withFileTypes: true });
+    } catch (error) {
+      if (isEnoent2(error)) return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const path = join11(directory, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (entry.name === "current-session.json") {
+        await rewriteJsonObjectFile(path, CURRENT_SESSION_FIELDS, rewrites);
+      } else if (entry.name.endsWith(".pointer.json")) {
+        await rewriteOfficerPointerFile(path, rewrites);
+      } else if (entry.name === "records.jsonl") {
+        await rewriteSitianRecordsJsonl(path, rewrites);
+      } else if (entry.name.endsWith(".jsonl")) {
+        await rewriteSessionTranscriptBindings(path, rewrites);
+      }
+    }
+  }
+  await walk(sessionRoot);
+}
+async function rewriteRoleRunDurablePages(input) {
+  const { pagesDirectory } = input;
+  const rewrites = collectRewrites(input);
+  const admittedPath = join11(pagesDirectory, "admitted-request.json");
+  if (existsSync5(admittedPath)) {
+    const page = JSON.parse(await readFile5(admittedPath, "utf8"));
+    rewriteRunDirectoryPathFieldsAgainstRewrites(
+      page,
+      ADMITTED_PAGE_FIELDS,
+      rewrites
+    );
+    rewriteSourceRunLocator(page.sourceRun, rewrites);
+    if (Array.isArray(page.attachments)) {
+      for (const attachment of page.attachments) {
+        if (isPlainObject(attachment)) {
+          rewriteRunDirectoryPathFieldsAgainstRewrites(
+            attachment,
+            ["frozenPath"],
+            rewrites
+          );
+        }
+      }
+    }
+    if (isPlainObject(page.principal)) {
+      rewriteRunDirectoryPathFieldsAgainstRewrites(
+        page.principal,
+        ["sessionDirectory", "sessionFile"],
+        rewrites
+      );
+    }
+    await writeFile2(admittedPath, `${JSON.stringify(page, null, 2)}
+`, "utf8");
+  }
+  const invocationPath = join11(pagesDirectory, "invocation.json");
+  if (existsSync5(invocationPath)) {
+    const page = JSON.parse(await readFile5(invocationPath, "utf8"));
+    rewriteRunDirectoryPathFieldsAgainstRewrites(
+      page,
+      INVOCATION_PAGE_FIELDS,
+      rewrites
+    );
+    await writeFile2(
+      invocationPath,
+      `${JSON.stringify(page, null, 2)}
+`,
+      "utf8"
+    );
+  }
+  const statePath = join11(pagesDirectory, "run-state.json");
+  if (existsSync5(statePath)) {
+    const page = JSON.parse(await readFile5(statePath, "utf8"));
+    rewriteRunDirectoryPathFieldsAgainstRewrites(
+      page,
+      RUN_STATE_PAGE_FIELDS,
+      rewrites
+    );
+    if (isPlainObject(page.principal)) {
+      rewriteRunDirectoryPathFieldsAgainstRewrites(
+        page.principal,
+        ["sessionDirectory", "sessionFile"],
+        rewrites
+      );
+    }
+    if (isPlainObject(page.currentCourt)) {
+      rewriteSummonsMaterials(page.currentCourt.summons, rewrites);
+    }
+    await writeFile2(statePath, `${JSON.stringify(page, null, 2)}
+`, "utf8");
+  }
+  await rewriteNestedMachinePathPages(pagesDirectory, rewrites);
+}
+var ADMITTED_PAGE_FIELDS, INVOCATION_PAGE_FIELDS, RUN_STATE_PAGE_FIELDS, SOURCE_RUN_LOCATOR_FIELDS, SUMMONS_PATH_FIELDS, CURRENT_SESSION_FIELDS, OFFICER_POINTER_FIELDS, SITIAN_RECORD_FIELDS, SESSION_HEADER_FIELDS, BINDING_PARENT_FIELDS;
+var init_role_run_relocation = __esm({
+  "src/role-run-relocation.ts"() {
     "use strict";
+    init_compliance_transport();
+    ADMITTED_PAGE_FIELDS = [
+      "runDirectory",
+      "admittedRequestPath",
+      "sessionDirectory",
+      "sessionFile",
+      "taskPath",
+      "packetPath",
+      "prerequisitesPath",
+      "requestManifestPath",
+      "mergerInputPath",
+      "sourceRunPath"
+    ];
+    INVOCATION_PAGE_FIELDS = [
+      "runDirectory",
+      "sessionDirectory",
+      "sessionFile"
+    ];
+    RUN_STATE_PAGE_FIELDS = [
+      "runDirectory",
+      "admittedRequestPath",
+      "sessionDirectory",
+      "sessionFile"
+    ];
+    SOURCE_RUN_LOCATOR_FIELDS = ["runDirectory"];
+    SUMMONS_PATH_FIELDS = ["sourceRunPath"];
+    CURRENT_SESSION_FIELDS = ["sessionFile"];
+    OFFICER_POINTER_FIELDS = ["sessionFile", "runDirectory"];
+    SITIAN_RECORD_FIELDS = ["sessionParent"];
+    SESSION_HEADER_FIELDS = ["parentSession"];
+    BINDING_PARENT_FIELDS = ["sessionFile"];
   }
 });
 
@@ -16686,21 +17312,6 @@ var init_sha256 = __esm({
   }
 });
 
-// src/readable-gate-item.ts
-var init_readable_gate_item = __esm({
-  "src/readable-gate-item.ts"() {
-    "use strict";
-  }
-});
-
-// src/submission-errors.ts
-var init_submission_errors = __esm({
-  "src/submission-errors.ts"() {
-    "use strict";
-    init_readable_gate_item();
-  }
-});
-
 // src/submission-correctable-error.ts
 var correctableSubmissionErrorBrand, CorrectableSubmissionError;
 var init_submission_correctable_error = __esm({
@@ -16791,16 +17402,16 @@ var init_terminating_tools = __esm({
 });
 
 // src/doctor-evidence.ts
-import { readdir, readFile as readFile5, realpath as realpath2, stat } from "node:fs/promises";
-import { dirname as dirname7, relative as relative2, resolve as resolve5, sep as sep2 } from "node:path";
+import { readdir as readdir3, readFile as readFile6, realpath as realpath2, stat } from "node:fs/promises";
+import { dirname as dirname7, relative as relative2, resolve as resolve4, sep as sep3 } from "node:path";
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function discoverCaseFiles(root) {
   const found = [];
   async function walk(dir, depth) {
-    for (const item of await readdir(dir, { withFileTypes: true })) {
-      const path = resolve5(dir, item.name);
+    for (const item of await readdir3(dir, { withFileTypes: true })) {
+      const path = resolve4(dir, item.name);
       if (item.isDirectory()) {
         await walk(path, depth + 1);
       } else if (item.isFile() && (item.name.endsWith(".jsonl") || item.name === "stderr.log" && depth === 1)) found.push(path);
@@ -16819,17 +17430,17 @@ function accumulate(metric, value, source) {
 function timestamp(row) {
   return typeof row.timestamp === "string" && Number.isFinite(Date.parse(row.timestamp)) ? row.timestamp : void 0;
 }
-function isMissingPathError(error) {
+function isMissingPathError2(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 async function stableRunsIdentity(root) {
   let cursor = root;
   while (true) {
     try {
-      const git2 = await stat(resolve5(cursor, ".git"));
-      if (git2.isDirectory() || git2.isFile()) return relative2(cursor, root).split(sep2).join("/");
+      const git2 = await stat(resolve4(cursor, ".git"));
+      if (git2.isDirectory() || git2.isFile()) return relative2(cursor, root).split(sep3).join("/");
     } catch (error) {
-      if (!isMissingPathError(error)) throw error;
+      if (!isMissingPathError2(error)) throw error;
     }
     const parent = dirname7(cursor);
     if (parent === cursor) return root;
@@ -16901,13 +17512,13 @@ function deriveSession(content, id) {
 }
 async function loadDoctorCase(runsPath) {
   const root = await realpath2(runsPath);
-  const match = root.split(sep2).join("/").match(/\/\.ak-roles\/books\/[^/]+\/issues\/([1-9]\d*)\/runs$/);
-  if (!match) throw new Error("Doctor case must be an .ak-roles/books/<book>/issues/<n>/runs directory");
+  const match = root.split(sep3).join("/").match(/\/\.ak-roles\/books\/[^/]+\/(?:issues\/)?([1-9]\d*)\/runs$/);
+  if (!match) throw new Error("Doctor case must be an .ak-roles/books/<book>/<n>/runs directory");
   const evidence = [], sessions = [], statuses = [], commits = [];
   const turns = { count: 0, sources: [] }, calls = { count: 0, sources: [] }, tokens = { count: 0, sources: [] };
   for (const path of await discoverCaseFiles(root)) {
-    const id = relative2(root, path).split(sep2).join("/");
-    const bytes = await readFile5(path);
+    const id = relative2(root, path).split(sep3).join("/");
+    const bytes = await readFile6(path);
     const content = bytes.toString("utf8");
     const kind = id.endsWith(".jsonl") ? "session" : "stderr";
     evidence.push({ id, kind, byteLength: bytes.byteLength, contentLength: content.length, sha256: sha256Hex(bytes), content });
@@ -16920,7 +17531,7 @@ async function loadDoctorCase(runsPath) {
     accumulate(calls, result2.calls, id);
     accumulate(tokens, result2.tokens, id);
   }
-  const runDirs = (await readdir(root, { withFileTypes: true })).filter((item) => item.isDirectory()).map((item) => item.name).sort();
+  const runDirs = (await readdir3(root, { withFileTypes: true })).filter((item) => item.isDirectory()).map((item) => item.name).sort();
   const legs = evidence.filter((entry) => entry.kind === "session").map((entry) => entry.id);
   const retryDirs = runDirs.filter((name) => /(?:^|[-_])retry(?:[-_]|$)/i.test(name));
   const rawBytes = evidence.filter((entry) => entry.kind === "session").reduce((sum, entry) => sum + entry.byteLength, 0);
@@ -16937,7 +17548,7 @@ var init_doctor_evidence = __esm({
 
 // src/collector-config.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 function fail3(message, cause) {
   throw new Error(message, cause === void 0 ? void 0 : { cause });
 }
@@ -16980,7 +17591,7 @@ function emptyCollectorManifest() {
 async function loadCollectorManifest(path) {
   let bytes;
   try {
-    bytes = await readFile6(path);
+    bytes = await readFile7(path);
   } catch (error) {
     fail3(`Collector request manifest is unreadable at ${path}`, error);
   }
@@ -17084,7 +17695,7 @@ async function listPullRequestNumbersByCommit(runner, input) {
 function createGhApiRunner(options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn2;
   return async (args, runOptions = {}) => {
-    return await new Promise((resolve11, reject) => {
+    return await new Promise((resolve10, reject) => {
       const signal = runOptions.signal;
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
@@ -17157,11 +17768,11 @@ function createGhApiRunner(options = {}) {
               const value = line2.slice(idx + 1).trim();
               headers[name] = value;
             }
-            resolve11({ status, headers, bodyText });
+            resolve10({ status, headers, bodyText });
             return;
           }
           if (code === 0) {
-            resolve11({ status: 200, headers: {}, bodyText: stdout });
+            resolve10({ status: 200, headers: {}, bodyText: stdout });
             return;
           }
           const failure = new Error(
@@ -17371,9 +17982,9 @@ var init_git_object_id = __esm({
 
 // src/merger-git-state.ts
 import { execFile as execFile2 } from "node:child_process";
-import { access as access2, readFile as readFile7 } from "node:fs/promises";
+import { access as access2, readFile as readFile8 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
-import { isAbsolute as isAbsolute4, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute4, resolve as resolve5 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 async function git(cwd, args) {
   const { stdout } = await execFileAsync2("git", args, { cwd, encoding: "buffer", maxBuffer: 16 * 1024 * 1024 });
@@ -17438,10 +18049,10 @@ function createProductionMergerGitState(repositoryRoot = process.cwd()) {
       await requireInsideWorkTree(repositoryRoot);
       const targetObjectId = await resolveHeadMaterial(repositoryRoot);
       const mergeHeadReported = line(await git(repositoryRoot, ["rev-parse", "--git-path", "MERGE_HEAD"]), "Git MERGE_HEAD path");
-      const mergeHeadPath = isAbsolute4(mergeHeadReported) ? mergeHeadReported : resolve6(repositoryRoot, mergeHeadReported);
+      const mergeHeadPath = isAbsolute4(mergeHeadReported) ? mergeHeadReported : resolve5(repositoryRoot, mergeHeadReported);
       let sourceObjectId = "";
       if (await pathExists(mergeHeadPath)) {
-        const raw = exactUtf8(await readFile7(mergeHeadPath), "Git MERGE_HEAD");
+        const raw = exactUtf8(await readFile8(mergeHeadPath), "Git MERGE_HEAD");
         const mergeHeads = raw.trim().split(/\r?\n/).map((row) => row.trim()).filter(Boolean);
         if (mergeHeads.length === 0) throw new Error("Git MERGE_HEAD is empty");
         if (mergeHeads.length !== 1) throw new Error("Assigned repository does not have one ordinary in-progress merge");
@@ -17493,10 +18104,10 @@ var init_uuidv7 = __esm({
 });
 
 // src/typed-provider-http.ts
-import { readFile as readFile8, unlink, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { readFile as readFile9, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 function typedProviderHttpPath(runDirectory) {
-  return join10(runDirectory, TYPED_HTTP_FILE);
+  return join12(runDirectory, TYPED_HTTP_FILE);
 }
 async function clearTypedProviderHttpObservation(runDirectory) {
   try {
@@ -17511,7 +18122,7 @@ async function clearTypedProviderHttpObservation(runDirectory) {
 async function readLatestTypedProviderHttpObservation(runDirectory) {
   let text;
   try {
-    text = await readFile8(typedProviderHttpPath(runDirectory), "utf8");
+    text = await readFile9(typedProviderHttpPath(runDirectory), "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return void 0;
@@ -17540,8 +18151,8 @@ var init_typed_provider_http = __esm({
 });
 
 // src/public-cli/run-lifecycle.ts
-import { chmod, open, readdir as readdir2, readFile as readFile9, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { chmod, lstat as lstat2, open, readdir as readdir4, readFile as readFile10, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename4, join as join13 } from "node:path";
 function selectResumeContinuationPrompt(message, engineMaterial) {
   const lines = message !== void 0 ? [message] : [];
   return appendEngineSessionMaterial(lines, engineMaterial).join("\n");
@@ -17570,8 +18181,8 @@ function renderResumeCommand(runId) {
 }
 async function writeRoleRunState(runDirectory, record4) {
   const payload = { ...record4, runDirectory };
-  await writeFile3(
-    join11(runDirectory, RUN_STATE_FILE),
+  await writeFile4(
+    join13(runDirectory, RUN_STATE_FILE),
     `${JSON.stringify(payload, null, 2)}
 `,
     "utf8"
@@ -17621,7 +18232,7 @@ function parseCurrentCourtState(raw) {
 async function readRoleRunStateDisk(runDirectory) {
   let raw;
   try {
-    raw = JSON.parse(await readFile9(join11(runDirectory, RUN_STATE_FILE), "utf8"));
+    raw = JSON.parse(await readFile10(join13(runDirectory, RUN_STATE_FILE), "utf8"));
   } catch (error) {
     if (errorCodeOf2(error) === "ENOENT") return void 0;
     throw error;
@@ -17688,8 +18299,8 @@ async function writeRoleRunStateDisk(runDirectory, disk) {
     ...disk.resumable === void 0 ? {} : { resumable: disk.resumable },
     ...disk.currentCourt === void 0 ? {} : { currentCourt: disk.currentCourt }
   };
-  await writeFile3(
-    join11(runDirectory, RUN_STATE_FILE),
+  await writeFile4(
+    join13(runDirectory, RUN_STATE_FILE),
     `${JSON.stringify(payload, null, 2)}
 `,
     "utf8"
@@ -17856,15 +18467,19 @@ function isProcessAlive(pid) {
 async function autopsyWriterLock(lockPath) {
   let content;
   try {
-    content = await readFile9(lockPath, "utf8");
+    content = await readFile10(lockPath, "utf8");
   } catch (error) {
     if (errorCodeOf2(error) === "ENOENT") return { verdict: "absent" };
-    return { verdict: "absent", readFailure: error };
+    return { verdict: "unknown", reason: "unreadable", readFailure: error };
   }
   const normalized = content.trim();
-  if (!/^[1-9]\d*$/.test(normalized)) return { verdict: "absent" };
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    return { verdict: "unknown", reason: "unparseable", content };
+  }
   const pid = Number.parseInt(normalized, 10);
-  if (!Number.isSafeInteger(pid) || pid <= 0) return { verdict: "absent" };
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return { verdict: "unknown", reason: "unparseable", content };
+  }
   return isProcessAlive(pid) ? { verdict: "alive", pid } : { verdict: "dead", pid };
 }
 function describeAutopsy(autopsy) {
@@ -17874,7 +18489,9 @@ function describeAutopsy(autopsy) {
     case "dead":
       return `dead pid ${autopsy.pid}`;
     case "absent":
-      return autopsy.readFailure !== void 0 ? "unreadable lock" : "absent or unparseable holder";
+      return "absent holder";
+    case "unknown":
+      return autopsy.reason === "unreadable" ? "unreadable lock" : "unparseable holder";
   }
 }
 async function reclaimStaleWriterLock(lockPath, runDirectory) {
@@ -17901,24 +18518,32 @@ async function createWriterLease(lockPath, runDirectory, reportCleanupFailure) {
     throw error;
   }
   let released = false;
+  let currentRunDirectory = runDirectory;
+  let currentLockPath = lockPath;
   return {
-    lockPath,
+    get lockPath() {
+      return currentLockPath;
+    },
+    relocate(nextRunDirectory) {
+      currentRunDirectory = nextRunDirectory;
+      currentLockPath = join13(nextRunDirectory, WRITER_LOCK_FILE);
+    },
     async release() {
       if (released) return;
       released = true;
       await handle.close().catch(() => void 0);
       try {
-        await unlink2(lockPath);
+        await unlink2(currentLockPath);
       } catch (error) {
         if (errorCodeOf2(error) === "EACCES") {
           try {
-            await chmod(runDirectory, 493);
-            await unlink2(lockPath);
+            await chmod(currentRunDirectory, 493);
+            await unlink2(currentLockPath);
           } catch (retryError) {
-            reportCleanupFailure(retryError);
+            reportCleanupFailure(retryError, currentLockPath);
           }
         } else {
-          reportCleanupFailure(error);
+          reportCleanupFailure(error, currentLockPath);
         }
       }
     }
@@ -17933,17 +18558,17 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
     } catch {
     }
   };
-  const reportCleanupFailure = (error) => {
+  const reportCleanupFailure = (error, lockPath2) => {
     reportDiagnostic(
-      `writer lease lock cleanup failed (release is best-effort; residual lock left in place) at ${join11(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
+      `writer lease lock cleanup failed (release is best-effort; residual lock left in place) at ${lockPath2}: ${describeErrorIdentity(error)}`
     );
   };
   const reportReadFailure = (error) => {
     reportDiagnostic(
-      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join11(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
+      `writer lease lock read failed (holder liveness unverifiable; lock left in place) at ${join13(runDirectory, WRITER_LOCK_FILE)}: ${describeErrorIdentity(error)}`
     );
   };
-  const lockPath = join11(runDirectory, WRITER_LOCK_FILE);
+  const lockPath = join13(runDirectory, WRITER_LOCK_FILE);
   let lastAutopsy = { verdict: "absent" };
   let lastReclaimFailure;
   for (let reclaimsLeft = WRITER_LEASE_RECLAIM_ROUNDS; ; reclaimsLeft -= 1) {
@@ -17953,7 +18578,7 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
       if (errorCodeOf2(error) !== "EEXIST") throw error;
     }
     lastAutopsy = await autopsyWriterLock(lockPath);
-    if (lastAutopsy.verdict === "absent" && lastAutopsy.readFailure !== void 0) {
+    if (lastAutopsy.verdict === "unknown" && lastAutopsy.reason === "unreadable") {
       reportReadFailure(lastAutopsy.readFailure);
     }
     if (lastAutopsy.verdict === "alive") {
@@ -17961,9 +18586,14 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
         `role run writer lease is already held by live pid ${lastAutopsy.pid} at ${lockPath}`
       );
     }
+    if (lastAutopsy.verdict === "unknown") {
+      throw new RunWriterLeaseHeldError(
+        lastAutopsy.reason === "unreadable" ? `role run writer lease lock is unreadable at ${lockPath}: ${describeErrorIdentity(lastAutopsy.readFailure)}; holder liveness unverifiable, lock left in place` : `role run writer lease lock at ${lockPath} has no verifiable holder pid (empty or unparseable); holder liveness unverifiable, lock left in place`
+      );
+    }
     if (lastAutopsy.verdict === "absent") {
       throw new RunWriterLeaseHeldError(
-        lastAutopsy.readFailure !== void 0 ? `role run writer lease lock is unreadable at ${lockPath}: ${describeErrorIdentity(lastAutopsy.readFailure)}; holder liveness unverifiable, lock left in place` : `role run writer lease lock at ${lockPath} has no verifiable holder pid (empty or unparseable); holder liveness unverifiable, lock left in place`
+        `role run writer lease disappeared before holder autopsy at ${lockPath}`
       );
     }
     if (reclaimsLeft <= 0) break;
@@ -17990,31 +18620,40 @@ async function acquireRunWriterLease(runDirectory, onCleanupFailure) {
     lastReclaimFailure !== void 0 ? `role run writer lease stayed contested at ${lockPath} after ${WRITER_LEASE_RECLAIM_ROUNDS} reclaims (last autopsy: ${describeAutopsy(lastAutopsy)}; last reclaim failure: ${describeErrorIdentity(lastReclaimFailure)})` : `role run writer lease stayed contested at ${lockPath} after ${WRITER_LEASE_RECLAIM_ROUNDS} reclaims (last autopsy: ${describeAutopsy(lastAutopsy)})`
   );
 }
-async function findRunDirectoryById(home, runId) {
+async function findRunDirectoryById(home, runId, onlyBookKey, onlyRole) {
   if (runId.trim() === "") return void 0;
   const ledgerHome = resolveActivationLedgerHome(home);
-  const booksRoot = join11(ledgerHome, "books");
+  const booksRoot = join13(ledgerHome, "books");
   let bookKeys;
   try {
-    bookKeys = await readdir2(booksRoot);
-  } catch {
-    return void 0;
+    bookKeys = await readdir4(booksRoot);
+  } catch (error) {
+    if (errorCodeOf2(error) === "ENOENT") return void 0;
+    throw error;
   }
+  const matches = [];
   for (const bookKey of bookKeys) {
-    const runsDir = join11(activationBookDirectory(ledgerHome, bookKey), "runs");
-    let entries;
+    if (onlyBookKey !== void 0 && bookKey !== onlyBookKey) continue;
+    const bookDir = activationBookDirectory(ledgerHome, bookKey);
+    let runDirectories;
     try {
-      entries = await readdir2(runsDir);
-    } catch {
-      continue;
+      runDirectories = await listBookRunDirectories(bookDir);
+    } catch (error) {
+      if (errorCodeOf2(error) === "ENOENT") continue;
+      throw error;
     }
-    for (const entry of entries) {
-      if (entry === `${runId}@judge` || entry.startsWith(`${runId}@`)) {
-        return join11(runsDir, entry);
+    for (const runDirectory of runDirectories) {
+      const entry = basename4(runDirectory);
+      if (onlyRole === void 0 && (entry === `${runId}@judge` || entry.startsWith(`${runId}@`)) || entry === `${runId}@${onlyRole}`) {
+        matches.push(runDirectory);
       }
     }
   }
-  return void 0;
+  if (matches.length === 0) return void 0;
+  if (matches.length === 1) return matches[0];
+  throw new Error(
+    `ambiguous role run id ${runId}: ${matches.join(", ")}`
+  );
 }
 function parentRunPathFromGatePointerInstruction(instruction) {
   if (!instruction.startsWith(GATE_DOSSIER_POINTER_PREFIX)) return void 0;
@@ -18025,7 +18664,7 @@ async function readRunParentPath(runDirectory) {
   let raw;
   try {
     raw = JSON.parse(
-      await readFile9(join11(runDirectory, "admitted-request.json"), "utf8")
+      await readFile10(join13(runDirectory, "admitted-request.json"), "utf8")
     );
   } catch (error) {
     if (errorCodeOf2(error) === "ENOENT") return void 0;
@@ -18043,51 +18682,104 @@ async function readRunParentPath(runDirectory) {
   }
   return void 0;
 }
+async function runHasFormedSessionPrincipal(runDirectory) {
+  const disk = await readRoleRunStateDisk(runDirectory);
+  if (disk === void 0) return false;
+  const sessionFile = typeof disk.principalWire.sessionFile === "string" && disk.principalWire.sessionFile.trim() !== "" ? disk.principalWire.sessionFile : join13(disk.principalWire.sessionDirectory, "session.jsonl");
+  try {
+    const stat2 = await lstat2(sessionFile);
+    return stat2.isFile() && !stat2.isSymbolicLink();
+  } catch (error) {
+    if (errorCodeOf2(error) === "ENOENT") return false;
+    throw error;
+  }
+}
 async function findLatestRunIdForSeatTicket(input) {
+  if (input.ticketNumber === void 0 && input.parentRunPath === void 0) {
+    return void 0;
+  }
   const ledgerHome = resolveActivationLedgerHome(input.home);
-  const runsDir = join11(
-    activationBookDirectory(ledgerHome, input.bookKey),
-    "runs"
-  );
-  let entries;
+  const bookDir = activationBookDirectory(ledgerHome, input.bookKey);
+  let runDirectories;
   try {
-    entries = await readdir2(runsDir);
+    runDirectories = await listBookRunDirectories(bookDir);
   } catch (error) {
     if (errorCodeOf2(error) === "ENOENT") return void 0;
     throw error;
   }
   const suffix = `@${input.role}`;
   let best;
-  for (const entry of entries) {
+  for (const runDirectory of runDirectories) {
+    const entry = basename4(runDirectory);
     if (!entry.endsWith(suffix)) continue;
     const runId = entry.slice(0, entry.length - suffix.length);
     if (runId.length === 0) continue;
-    const runDirectory = join11(runsDir, entry);
     if (input.parentRunPath !== void 0) {
       const parentPath = await readRunParentPath(runDirectory);
       if (parentPath !== input.parentRunPath) continue;
     } else if (input.ticketNumber !== void 0) {
-      const ticketNumber = await readRunTicketNumber(runDirectory);
+      const ticketNumber = await readBoardTicketNumber(runDirectory);
       if (ticketNumber !== input.ticketNumber) continue;
-    } else {
-      continue;
     }
+    if (!await runHasFormedSessionPrincipal(runDirectory)) continue;
     if (best === void 0 || runId > best) best = runId;
   }
   return best;
 }
 function parsePersistedTicketIdentity(record4) {
   const correlationId = typeof record4.correlationId === "string" && record4.correlationId.trim() !== "" ? record4.correlationId : void 0;
-  const ticketNumber = typeof record4.ticketNumber === "number" && Number.isSafeInteger(record4.ticketNumber) && record4.ticketNumber >= 1 ? record4.ticketNumber : void 0;
+  const ticketNumber = isSafePositiveTicketNumber(record4.ticketNumber) ? record4.ticketNumber : void 0;
   return {
     ...correlationId === void 0 ? {} : { correlationId },
     ...ticketNumber === void 0 ? {} : { ticketNumber }
   };
 }
+function readDurableCourtTicketNumbersPage(record4, principalTicket, pageLabel) {
+  const interpreted = interpretDurableCourtTicketNumbers(record4, {
+    ...principalTicket === void 0 ? {} : { principalTicket }
+  });
+  if (interpreted.kind === "damage") {
+    return {
+      kind: "damage",
+      reason: `role run ${pageLabel} courtTicketNumbers is damaged: ${interpreted.reason}`
+    };
+  }
+  if (interpreted.kind === "ok") {
+    return { kind: "ok", tickets: interpreted.tickets };
+  }
+  return { kind: "absent" };
+}
+function mergeDurableCourtTicketNumbers(input) {
+  const fromAdmitted = input.admittedRecord === void 0 ? { kind: "absent" } : readDurableCourtTicketNumbersPage(
+    input.admittedRecord,
+    input.principalTicket,
+    "admitted-request"
+  );
+  const fromInvocation = input.invocationRecord === void 0 ? { kind: "absent" } : readDurableCourtTicketNumbersPage(
+    input.invocationRecord,
+    input.principalTicket,
+    "invocation"
+  );
+  if (fromAdmitted.kind === "damage") return fromAdmitted;
+  if (fromInvocation.kind === "damage") return fromInvocation;
+  if (fromAdmitted.kind === "ok" && fromInvocation.kind === "ok") {
+    if (!sameCourtTicketNumbers(fromAdmitted.tickets, fromInvocation.tickets)) {
+      return {
+        kind: "damage",
+        reason: "role run courtTicketNumbers differs between admitted-request and invocation"
+      };
+    }
+    return { kind: "ok", tickets: fromAdmitted.tickets };
+  }
+  if (fromAdmitted.kind === "ok") return { kind: "ok", tickets: fromAdmitted.tickets };
+  if (fromInvocation.kind === "ok") return { kind: "ok", tickets: fromInvocation.tickets };
+  return { kind: "ok" };
+}
 function restoredTicketFields(fields) {
   return {
     ...fields.correlationId === void 0 ? {} : { correlationId: fields.correlationId },
-    ...fields.ticketNumber === void 0 ? {} : { ticketNumber: fields.ticketNumber }
+    ...fields.ticketNumber === void 0 ? {} : { ticketNumber: fields.ticketNumber },
+    ...fields.courtTicketNumbers === void 0 ? {} : { courtTicketNumbers: fields.courtTicketNumbers }
   };
 }
 async function loadResumableRunRecord(home, runId, authority) {
@@ -18123,6 +18815,10 @@ async function loadResumableRunRecord(home, runId, authority) {
   let derived;
   let correlationId;
   let ticketNumber;
+  let courtTicketNumbers;
+  let courtTicketNumbersDamage;
+  let admittedIdentityRecord;
+  let invocationIdentityRecord;
   let prNumber;
   let repository;
   let repositoryDisplay;
@@ -18136,7 +18832,7 @@ async function loadResumableRunRecord(home, runId, authority) {
   let sourceRun;
   try {
     const raw = JSON.parse(
-      await readFile9(run.admittedRequestPath, "utf8")
+      await readFile10(run.admittedRequestPath, "utf8")
     );
     if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
       const record4 = raw;
@@ -18236,6 +18932,7 @@ async function loadResumableRunRecord(home, runId, authority) {
           };
         }
       }
+      admittedIdentityRecord = record4;
       const fromAdmitted = parsePersistedTicketIdentity(record4);
       correlationId = fromAdmitted.correlationId;
       ticketNumber = fromAdmitted.ticketNumber;
@@ -18250,10 +18947,11 @@ async function loadResumableRunRecord(home, runId, authority) {
   let model;
   try {
     const invocationRaw = JSON.parse(
-      await readFile9(join11(run.runDirectory, "invocation.json"), "utf8")
+      await readFile10(join13(run.runDirectory, "invocation.json"), "utf8")
     );
     if (invocationRaw !== null && typeof invocationRaw === "object" && !Array.isArray(invocationRaw)) {
       const rec = invocationRaw;
+      invocationIdentityRecord = rec;
       if (typeof rec.provider === "string" && typeof rec.model === "string") {
         model = {
           provider: rec.provider,
@@ -18268,6 +18966,9 @@ async function loadResumableRunRecord(home, runId, authority) {
       }
     }
   } catch (error) {
+    if (error instanceof CliUsageError) {
+      throw error;
+    }
     if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
       throw new CliUsageError(
         `role run invocation identity is unreadable: ${runId}`,
@@ -18275,6 +18976,16 @@ async function loadResumableRunRecord(home, runId, authority) {
       );
     }
   }
+  const mergedSet = mergeDurableCourtTicketNumbers({
+    admittedRecord: admittedIdentityRecord,
+    invocationRecord: invocationIdentityRecord,
+    principalTicket: ticketNumber
+  });
+  if (mergedSet.kind === "damage") {
+    courtTicketNumbersDamage = mergedSet.reason;
+  } else if (mergedSet.tickets !== void 0) {
+    courtTicketNumbers = mergedSet.tickets;
+  }
   return {
     run,
     principal,
@@ -18294,6 +19005,8 @@ async function loadResumableRunRecord(home, runId, authority) {
       ...derived === void 0 ? {} : { derived },
       ...correlationId === void 0 ? {} : { correlationId },
       ...ticketNumber === void 0 ? {} : { ticketNumber },
+      ...courtTicketNumbers === void 0 ? {} : { courtTicketNumbers },
+      ...courtTicketNumbersDamage === void 0 ? {} : { courtTicketNumbersDamage },
       ...prNumber === void 0 ? {} : { prNumber },
       ...repository === void 0 ? {} : { repository },
       ...repositoryDisplay === void 0 ? {} : { repositoryDisplay },
@@ -18441,9 +19154,14 @@ async function loadResumableCountersignRun(home, runId, authority) {
       `role run ${runId} belongs to ${loaded.run.role}, not countersign`
     );
   }
+  const base = resumedBaseAdmitted(loaded);
   const admitted = {
     role: "countersign",
-    ...resumedBaseAdmitted(loaded)
+    ...base,
+    ...base.courtTicketNumbers === void 0 ? {} : { courtTicketNumbers: base.courtTicketNumbers },
+    ...loaded.admittedFields.courtTicketNumbersDamage === void 0 ? {} : {
+      courtTicketNumbersDamage: loaded.admittedFields.courtTicketNumbersDamage
+    }
   };
   return seatLoadedResult(loaded, admitted);
 }
@@ -18614,7 +19332,8 @@ async function loadResumableInspectorRun(home, runId, authority) {
   }
   const admitted = {
     role: "inspector",
-    ...resumedBaseAdmitted(loaded)
+    ...resumedBaseAdmitted(loaded),
+    ...loaded.admittedFields.sourceRunPath === void 0 ? {} : { sourceRunPath: loaded.admittedFields.sourceRunPath }
   };
   return seatLoadedResult(loaded, admitted);
 }
@@ -18629,11 +19348,13 @@ var init_run_lifecycle = __esm({
   "src/public-cli/run-lifecycle.ts"() {
     "use strict";
     init_activation_ledger_topology();
+    init_role_run_placement();
     init_run_ticket_number();
     init_cli_errors();
     init_typed_provider_http();
     init_typed_provider_http();
     init_collector_config();
+    init_diarist_contracts();
     init_engine_material();
     init_invocation();
     V1_RESUMABLE_PROVIDERS = ["openai-codex", "xai"];
@@ -18660,8 +19381,8 @@ __export(notary_source_run_exports, {
   loadNotarySourceRunLocator: () => loadNotarySourceRunLocator,
   resolveNotarySourceRunLocator: () => resolveNotarySourceRunLocator
 });
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join12, resolve as resolve7, basename as basename5 } from "node:path";
-import { lstat as lstat2, realpath as realpath3 } from "node:fs/promises";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join14, resolve as resolve6, basename as basename5 } from "node:path";
+import { lstat as lstat3, realpath as realpath3 } from "node:fs/promises";
 function parseRunDirectoryName(name) {
   const match = RUN_DIR_NAME.exec(name);
   if (match === null) return void 0;
@@ -18679,7 +19400,7 @@ async function requireRunDirectory(candidate, display) {
   }
   let stat2;
   try {
-    stat2 = await lstat2(real);
+    stat2 = await lstat3(real);
   } catch (error) {
     throw new NotarySourceRunError(
       `notary --source-run is not a readable run directory: ${display}`,
@@ -18706,19 +19427,20 @@ async function resolveNotarySourceRunLocator(options) {
   }
   const ledgerHome = resolveActivationLedgerHome(options.home);
   const bookKey = resolveBookKeyFromGit(options.projectRoot);
-  const bookRunsRoot = join12(activationBookDirectory(ledgerHome, bookKey), "runs");
+  const bookRunsRoot = join14(activationBookDirectory(ledgerHome, bookKey), "runs");
   let candidate;
   const bare = parseRunDirectoryName(raw);
   if (bare !== void 0 && !raw.includes("/") && !raw.includes("\\")) {
-    candidate = join12(bookRunsRoot, `${bare.runId}@${bare.role}`);
+    candidate = await findRunDirectoryById(options.home, bare.runId, bookKey, bare.role) ?? join14(bookRunsRoot, `${bare.runId}@${bare.role}`);
   } else {
-    candidate = isAbsolute6(raw) ? raw : resolve7(options.projectRoot, raw);
+    candidate = isAbsolute6(raw) ? raw : resolve6(options.projectRoot, raw);
   }
   const real = await requireRunDirectory(candidate, raw);
   const identity = parseRunDirectoryName(basename5(real));
-  const runsRootIdentity = physicalPathIdentity(bookRunsRoot);
+  const bookIdentity = physicalPathIdentity(activationBookDirectory(ledgerHome, bookKey));
   const parentIdentity = physicalPathIdentity(dirname8(real));
-  if (parentIdentity !== runsRootIdentity) {
+  const subjectBookIdentity = physicalPathIdentity(dirname8(dirname8(dirname8(real))));
+  if (parentIdentity !== physicalPathIdentity(bookRunsRoot) && !(basename5(dirname8(real)) === "runs" && subjectBookIdentity === bookIdentity)) {
     throw new NotarySourceRunError(
       "notary --source-run must resolve to a retained run under the project machine-ledger book"
     );
@@ -19429,8 +20151,8 @@ var init_option_definitions = __esm({
         repeatable: false,
         form: "option",
         description: {
-          en: "Optional project-relative .ak-roles/books/<book>/issues/<n>/runs override matching --issue.",
-          zh: "\u53EF\u9009\u9879\u76EE\u76F8\u5BF9 .ak-roles/books/<book>/issues/<n>/runs \u8986\u76D6\uFF0C\u4E14\u987B\u5339\u914D --issue\u3002"
+          en: "Optional project-relative .ak-roles/books/<book>/<n>/runs override matching --issue.",
+          zh: "\u53EF\u9009\u9879\u76EE\u76F8\u5BF9 .ak-roles/books/<book>/<n>/runs \u8986\u76D6\uFF0C\u4E14\u987B\u5339\u914D --issue\u3002"
         }
       }
     ];
@@ -19865,6 +20587,7 @@ __export(invocation_exports, {
   admitNotaryInvocation: () => admitNotaryInvocation,
   admitReviewerInvocation: () => admitReviewerInvocation,
   bindAdmittedTicketNumber: () => bindAdmittedTicketNumber,
+  bindCourtTicketNumbersOnAdmitted: () => bindCourtTicketNumbersOnAdmitted,
   bindTicketNumberOnRunDirectory: () => bindTicketNumberOnRunDirectory,
   buildCoderTransportPrompt: () => buildCoderTransportPrompt,
   buildCollectorTransportPrompt: () => buildCollectorTransportPrompt,
@@ -19909,31 +20632,34 @@ __export(invocation_exports, {
   recordEffectiveInvocationModel: () => recordEffectiveInvocationModel,
   recordLaunchedPiIdentity: () => recordLaunchedPiIdentity,
   recordLaunchedRolePackageIdentity: () => recordLaunchedRolePackageIdentity,
+  relocateAdmittedRunToTicket: () => relocateAdmittedRunToTicket,
   requireAuthorityRef: () => requireAuthorityRef,
   resolveDoctorCaseRunsPath: () => resolveDoctorCaseRunsPath,
   resolveGitHubRemoteRepository: () => resolveGitHubRemoteRepository
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import {
-  lstat as lstat3,
-  mkdir as mkdir2,
-  readFile as readFile10,
+  lstat as lstat4,
+  readFile as readFile11,
   realpath as realpath4,
-  writeFile as writeFile4
+  rename,
+  writeFile as writeFile5
 } from "node:fs/promises";
-import { basename as basename6, isAbsolute as isAbsolute7, join as join13, resolve as resolve8, sep as sep3 } from "node:path";
+import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute7, join as join15, resolve as resolve7, sep as sep4 } from "node:path";
 function issueAdmissionPlacement(authority, request) {
-  const principal = authority.issue(request);
-  const { sessionDirectory, sessionFile } = authority.decode(principal);
-  const runDirectory = join13(sessionDirectory, "..");
   const ledgerHome = resolveActivationLedgerHome(request.home);
   const bookKey = resolveBookKeyFromGit(request.cwd);
+  const placement = roleRunPlacement(ledgerHome, {
+    bookKey,
+    subject: request.subject,
+    runId: request.runId,
+    role: request.role
+  });
+  ensureRoleRunPlacement(ledgerHome, placement);
   return {
-    principal,
-    sessionDirectory,
-    sessionFile,
-    runDirectory,
+    principal: authority.seal(placement),
+    ...placement,
     ledgerHome,
     bookKey
   };
@@ -19945,7 +20671,7 @@ async function writeAdmittedRequestPersistence(admittedRequestPath, body, coordi
     sessionDirectory: coordinates.sessionDirectory,
     sessionFile: coordinates.sessionFile
   };
-  await writeFile4(
+  await writeFile5(
     admittedRequestPath,
     `${JSON.stringify(projection, null, 2)}
 `,
@@ -19973,16 +20699,16 @@ async function writeRoleInvocationLedger(source, role, effectiveModel) {
     ...source.ticketNumber === void 0 ? {} : { ticketNumber: source.ticketNumber },
     ...effectiveModelLedgerFields(effectiveModel)
   };
-  await writeFile4(
-    join13(source.runDirectory, "invocation.json"),
+  await writeFile5(
+    join15(source.runDirectory, "invocation.json"),
     `${JSON.stringify(identity, null, 2)}
 `,
     "utf8"
   );
 }
 async function recordEffectiveInvocationModel(runDirectory, model, engine, host, engineModel) {
-  const ledgerPath = join13(runDirectory, "invocation.json");
-  const current = JSON.parse(await readFile10(ledgerPath, "utf8"));
+  const ledgerPath = join15(runDirectory, "invocation.json");
+  const current = JSON.parse(await readFile11(ledgerPath, "utf8"));
   const next = { ...current };
   if (model !== void 0) {
     next.provider = model.provider;
@@ -20006,7 +20732,7 @@ async function recordEffectiveInvocationModel(runDirectory, model, engine, host,
   if (host !== void 0) {
     next.host = host;
   }
-  await writeFile4(
+  await writeFile5(
     ledgerPath,
     `${JSON.stringify(next, null, 2)}
 `,
@@ -20014,9 +20740,9 @@ async function recordEffectiveInvocationModel(runDirectory, model, engine, host,
   );
 }
 async function mergeInvocationIdentityPage(runDirectory, fields) {
-  const ledgerPath = join13(runDirectory, "invocation.json");
-  const current = JSON.parse(await readFile10(ledgerPath, "utf8"));
-  await writeFile4(
+  const ledgerPath = join15(runDirectory, "invocation.json");
+  const current = JSON.parse(await readFile11(ledgerPath, "utf8"));
+  await writeFile5(
     ledgerPath,
     `${JSON.stringify({
       ...current,
@@ -20031,14 +20757,14 @@ async function persistAdmittedSourceRunPath(admitted, sourceRunPath) {
     throw new Error("persistAdmittedSourceRunPath requires a non-empty sourceRunPath");
   }
   const admittedPath = admitted.admittedRequestPath;
-  const current = JSON.parse(await readFile10(admittedPath, "utf8"));
+  const current = JSON.parse(await readFile11(admittedPath, "utf8"));
   if (typeof current.sourceRunPath === "string") {
     if (current.sourceRunPath === sourceRunPath) return;
     throw new Error(
       `persistAdmittedSourceRunPath refuses to replace ${current.sourceRunPath} with ${sourceRunPath}`
     );
   }
-  await writeFile4(
+  await writeFile5(
     admittedPath,
     `${JSON.stringify({ ...current, sourceRunPath }, null, 2)}
 `,
@@ -20046,35 +20772,103 @@ async function persistAdmittedSourceRunPath(admitted, sourceRunPath) {
   );
 }
 async function bindAdmittedTicketNumber(admitted, ticketNumber) {
-  if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
-    throw new Error(`bindAdmittedTicketNumber requires a safe positive integer, got ${String(ticketNumber)}`);
-  }
   if (admitted.ticketNumber !== void 0) {
     if (admitted.ticketNumber === ticketNumber) return;
     throw new Error(
       `bindAdmittedTicketNumber refuses to replace existing ticket #${admitted.ticketNumber} with #${ticketNumber}`
     );
   }
+  await bindTicketNumberOnRunDirectory(admitted.runDirectory, ticketNumber);
   admitted.ticketNumber = ticketNumber;
-  await mergeInvocationIdentityPage(admitted.runDirectory, { ticketNumber });
+}
+async function bindCourtTicketNumbersOnAdmitted(admitted, courtTicketNumbers) {
+  if (admitted.ticketNumber === void 0) {
+    throw new Error(
+      "bindCourtTicketNumbersOnAdmitted requires a bound principal ticketNumber"
+    );
+  }
+  const principal = requireSafePositiveTicketNumber(
+    admitted.ticketNumber,
+    "bindCourtTicketNumbersOnAdmitted principal ticketNumber"
+  );
+  for (const item of courtTicketNumbers) {
+    if (!isSafePositiveTicketNumber(item)) {
+      throw new Error(
+        `bindCourtTicketNumbersOnAdmitted requires safe positive integers, got ${String(item)}`
+      );
+    }
+  }
+  const projected = projectCourtTicketNumbers(courtTicketNumbers, {
+    principalTicket: principal
+  });
+  if (projected === null || projected.length === 0) {
+    throw new Error("bindCourtTicketNumbersOnAdmitted requires a non-empty ticket set");
+  }
+  const frozen = Object.freeze([...projected]);
   const admittedPath = admitted.admittedRequestPath;
-  const current = JSON.parse(await readFile10(admittedPath, "utf8"));
-  await writeFile4(
+  const current = JSON.parse(await readFile11(admittedPath, "utf8"));
+  await writeFile5(
     admittedPath,
-    `${JSON.stringify({ ...current, ticketNumber }, null, 2)}
+    `${JSON.stringify({ ...current, courtTicketNumbers: frozen }, null, 2)}
 `,
     "utf8"
   );
+  await mergeInvocationIdentityPage(admitted.runDirectory, {
+    courtTicketNumbers: frozen
+  });
+  admitted.courtTicketNumbers = frozen;
 }
-async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
-  if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
-    throw new Error(
-      `bindTicketNumberOnRunDirectory requires a safe positive integer, got ${String(ticketNumber)}`
+async function relocateAdmittedRunToTicket(admitted, authority, heldLease) {
+  if (admitted.ticketNumber === void 0 || !admitted.runDirectory.includes(`${sep4}unbound${sep4}runs${sep4}`)) return;
+  const oldRunDirectory = admitted.runDirectory;
+  const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(oldRunDirectory));
+  const target = roleRunPlacement(ledgerHome, {
+    bookKey: admitted.bookKey,
+    subject: { ticketNumber: admitted.ticketNumber },
+    runId: admitted.runId,
+    role: admitted.role
+  });
+  ensureRoleRunDirectory(ledgerHome, dirname9(target.runDirectory));
+  await rename(oldRunDirectory, target.runDirectory);
+  heldLease?.relocate(target.runDirectory);
+  const admittedRecord = admitted;
+  rewriteRunDirectoryPathFields(
+    admittedRecord,
+    [
+      "runDirectory",
+      "admittedRequestPath",
+      "taskPath",
+      "packetPath",
+      "prerequisitesPath",
+      "requestManifestPath",
+      "mergerInputPath"
+    ],
+    oldRunDirectory,
+    target.runDirectory
+  );
+  for (const attachment of admitted.attachments) {
+    attachment.frozenPath = rewriteRunDirectoryPathValue(
+      attachment.frozenPath,
+      oldRunDirectory,
+      target.runDirectory
     );
   }
-  const admittedPath = join13(runDirectory, "admitted-request.json");
-  const invocationPath = join13(runDirectory, "invocation.json");
-  const admitted = JSON.parse(await readFile10(admittedPath, "utf8"));
+  const principal = authority.seal(target);
+  admitted.principal = principal;
+  await rewriteRoleRunDurablePages({
+    pagesDirectory: target.runDirectory,
+    oldRunDirectory,
+    newRunDirectory: target.runDirectory
+  });
+}
+async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
+  requireSafePositiveTicketNumber(
+    ticketNumber,
+    "bindTicketNumberOnRunDirectory"
+  );
+  const admittedPath = join15(runDirectory, "admitted-request.json");
+  const invocationPath = join15(runDirectory, "invocation.json");
+  const admitted = JSON.parse(await readFile11(admittedPath, "utf8"));
   const existing = admitted.ticketNumber;
   if (typeof existing === "number") {
     if (existing === ticketNumber) return;
@@ -20082,9 +20876,9 @@ async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
       `bindTicketNumberOnRunDirectory refuses to replace existing ticket #${existing} with #${ticketNumber}`
     );
   }
-  if (existsSync5(invocationPath)) {
+  if (existsSync6(invocationPath)) {
     const invocation = JSON.parse(
-      await readFile10(invocationPath, "utf8")
+      await readFile11(invocationPath, "utf8")
     );
     if (typeof invocation.ticketNumber === "number" && invocation.ticketNumber !== ticketNumber) {
       throw new Error(
@@ -20092,7 +20886,7 @@ async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
       );
     }
   }
-  await writeFile4(
+  await writeFile5(
     admittedPath,
     `${JSON.stringify({ ...admitted, ticketNumber }, null, 2)}
 `,
@@ -20109,7 +20903,7 @@ async function recordLaunchedPiIdentity(runDirectory, identity) {
 async function observeLaunchedRolePackageIdentity(packageRoot2, selectedRoleEntry) {
   const rolePackageRoot = packageRoot2;
   const raw = JSON.parse(
-    await readFile10(join13(rolePackageRoot, "package.json"), "utf8")
+    await readFile11(join15(rolePackageRoot, "package.json"), "utf8")
   );
   if (typeof raw.version !== "string" || raw.version.trim() === "") {
     throw new Error(
@@ -20350,10 +21144,10 @@ function parseFixerArgv(args) {
   };
 }
 async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
-  const absolute = isAbsolute7(sourcePath) ? sourcePath : resolve8(sourcePath);
+  const absolute = isAbsolute7(sourcePath) ? sourcePath : resolve7(sourcePath);
   let st;
   try {
-    st = await lstat3(absolute);
+    st = await lstat4(absolute);
   } catch (error) {
     throw new CliUsageError(
       `attachment is not a readable regular file: ${sourcePath}`,
@@ -20365,10 +21159,10 @@ async function freezeRegularFileAttachment(sourcePath, destinationDir, index) {
       `attachment must be a regular file (not a directory or symlink): ${sourcePath}`
     );
   }
-  const bytes = await readFile10(absolute);
+  const bytes = await readFile11(absolute);
   const name = `${String(index).padStart(2, "0")}-${basename6(absolute)}`;
-  const frozenPath = join13(destinationDir, name);
-  await writeFile4(frozenPath, bytes);
+  const frozenPath = join15(destinationDir, name);
+  await writeFile5(frozenPath, bytes);
   return {
     attachment: {
       provenancePath: absolute,
@@ -20395,35 +21189,41 @@ async function freezeAttachments(attachmentPaths, attachmentsDirectory) {
 async function freezeAttachmentsIntoRun(attachmentPaths, runDirectory, summonsKey = `s-${Date.now().toString(36)}`) {
   if (attachmentPaths.length === 0) return [];
   const ledgerHome = resolveActivationLedgerHome(homeFromRunDirectory(runDirectory));
-  const attachmentsDirectory = join13(runDirectory, "attachments", summonsKey);
+  const attachmentsDirectory = join15(runDirectory, "attachments", summonsKey);
   ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   return freezeAttachments(attachmentPaths, attachmentsDirectory);
 }
 function ticketAdmissionFields(ticketNumber) {
-  return ticketNumber === void 0 ? {} : { ticketNumber };
+  if (ticketNumber === void 0) return {};
+  return {
+    ticketNumber: requireSafePositiveTicketNumber(
+      ticketNumber,
+      "assertedTicketNumber"
+    )
+  };
 }
 async function admitStandardMaterialInvocation(role, options) {
   if (options.project !== void 0) {
     requireOptionPath("--project", options.project);
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
+  const ticketFields = ticketAdmissionFields(options.assertedTicketNumber);
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role,
+    subject: ticketFields.ticketNumber === void 0 ? { unbound: true } : { ticketNumber: ticketFields.ticketNumber },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   const correlationFields = options.correlationId === void 0 ? {} : { correlationId: options.correlationId };
   const instruction = options.instruction;
@@ -20444,9 +21244,10 @@ async function admitStandardMaterialInvocation(role, options) {
       byteLength: a.byteLength,
       sha256: a.sha256,
       mediaKind: a.mediaKind
-    }))
+    })),
+    ...ticketFields
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -20467,7 +21268,8 @@ async function admitStandardMaterialInvocation(role, options) {
     runDirectory,
     principal,
     admittedRequestPath,
-    ...correlationFields
+    ...correlationFields,
+    ...ticketFields
   };
 }
 async function admitJudgeInvocation(options) {
@@ -20509,24 +21311,23 @@ async function admitCountersignInvocation(options) {
   if (options.project !== void 0) {
     requireOptionPath("--project", options.project);
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "countersign",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   const instruction = options.instruction;
   const instructionEmpty = instruction.trim() === "";
@@ -20548,7 +21349,7 @@ async function admitCountersignInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -20574,7 +21375,7 @@ function buildCountersignTransportPrompt(admitted, engineMaterial) {
 async function loadAdmittedJudgeRequest(runDirectory) {
   try {
     const raw = JSON.parse(
-      await readFile10(join13(runDirectory, "admitted-request.json"), "utf8")
+      await readFile11(join15(runDirectory, "admitted-request.json"), "utf8")
     );
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
     const record4 = raw;
@@ -20592,9 +21393,11 @@ async function loadAdmittedJudgeRequest(runDirectory) {
   }
 }
 async function ensureRunArtifactsDir(runDirectory) {
-  const dir = join13(runDirectory, "artifacts");
-  await mkdir2(dir, { recursive: true });
-  return dir;
+  const directory = roleRunArtifactsDirectory(runDirectory);
+  return ensureRoleRunDirectory(
+    resolveActivationLedgerHome(homeFromRunDirectory(runDirectory)),
+    directory
+  );
 }
 async function admitCoderInvocation(options) {
   if (options.project !== void 0) {
@@ -20609,27 +21412,26 @@ async function admitCoderInvocation(options) {
   if (options.phase !== "plan" && options.phase !== "apply") {
     throw new CliUsageError("coder phase must be plan or apply");
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "coder",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
-  const taskPath = join13(runDirectory, "task.md");
-  await writeFile4(taskPath, instruction, "utf8");
+  const taskPath = join15(runDirectory, "task.md");
+  await writeFile5(taskPath, instruction, "utf8");
   const admitted = {
     role: "coder",
     phase: options.phase,
@@ -20649,7 +21451,7 @@ async function admitCoderInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -20697,9 +21499,9 @@ async function admitFixerInvocation(options) {
   let prerequisites = Object.freeze([]);
   let prerequisitesSource;
   if (options.prerequisitesPath !== void 0) {
-    const absolutePrereq = isAbsolute7(options.prerequisitesPath) ? options.prerequisitesPath : resolve8(options.prerequisitesPath);
+    const absolutePrereq = isAbsolute7(options.prerequisitesPath) ? options.prerequisitesPath : resolve7(options.prerequisitesPath);
     try {
-      prerequisitesSource = await readFile10(absolutePrereq, "utf8");
+      prerequisitesSource = await readFile11(absolutePrereq, "utf8");
     } catch (error) {
       throw new CliUsageError(
         `fixer prerequisites path is unreadable: ${options.prerequisitesPath}`,
@@ -20715,37 +21517,36 @@ async function admitFixerInvocation(options) {
       throw error;
     }
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "fixer",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   let prerequisitesPath;
   if (prerequisitesSource !== void 0) {
-    prerequisitesPath = join13(runDirectory, "prerequisites.json");
-    await writeFile4(
+    prerequisitesPath = join15(runDirectory, "prerequisites.json");
+    await writeFile5(
       prerequisitesPath,
       `${JSON.stringify(prerequisites, null, 2)}
 `,
       "utf8"
     );
   }
-  const packetPath = join13(runDirectory, "fix-packet.md");
-  await writeFile4(packetPath, instruction, "utf8");
+  const packetPath = join15(runDirectory, "fix-packet.md");
+  await writeFile5(packetPath, instruction, "utf8");
   const admitted = {
     role: "fixer",
     phase: options.phase,
@@ -20770,7 +21571,7 @@ async function admitFixerInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -20940,7 +21741,7 @@ async function admitCollectorInvocation(options) {
       throw new CliUsageError(detail, { cause: error });
     }
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   let repository;
   if (options.repo !== void 0) {
     try {
@@ -20969,17 +21770,16 @@ async function admitCollectorInvocation(options) {
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "collector",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths ?? [], attachmentsDirectory);
   const instruction = options.instruction ?? "";
   const instructionEmpty = instruction.trim() === "";
@@ -20991,8 +21791,8 @@ async function admitCollectorInvocation(options) {
   const prNumber = target.kind === "bound" ? target.prNumber : void 0;
   let requestManifestPath;
   if (manifestCanonicalJson !== void 0) {
-    requestManifestPath = join13(runDirectory, "request-manifest.json");
-    await writeFile4(requestManifestPath, manifestCanonicalJson, "utf8");
+    requestManifestPath = join15(runDirectory, "request-manifest.json");
+    await writeFile5(requestManifestPath, manifestCanonicalJson, "utf8");
   }
   const admitted = {
     role: "collector",
@@ -21017,7 +21817,7 @@ async function admitCollectorInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21115,9 +21915,8 @@ function parseDoctorArgv(args) {
 }
 async function resolveDoctorCaseRunsPath(options) {
   const ledgerHome = resolveActivationLedgerHome(options.home);
-  const defaultRuns = join13(
+  const defaultRuns = join15(
     activationBookDirectory(ledgerHome, options.bookKey),
-    "issues",
     String(options.issueNumber),
     "runs"
   );
@@ -21133,7 +21932,7 @@ async function resolveDoctorCaseRunsPath(options) {
       "doctor --runs must be a project-relative path"
     );
   }
-  const resolved = resolve8(options.projectRoot, raw);
+  const resolved = resolve7(options.projectRoot, raw);
   if (resolved !== options.projectRoot && !pathContainedIn(options.projectRoot, resolved)) {
     throw new CliUsageError(
       "doctor --runs escapes the project root"
@@ -21149,11 +21948,11 @@ async function resolveDoctorCaseRunsPath(options) {
       { cause: error }
     );
   }
-  const normalized = real.split(sep3).join("/");
+  const normalized = real.split(sep4).join("/");
   const match = normalized.match(DOCTOR_CASE_RUNS_PATH_PATTERN);
   if (!match) {
     throw new CliUsageError(
-      "doctor --runs must be an .ak-roles/books/<book>/issues/<n>/runs directory"
+      "doctor --runs must be an .ak-roles/books/<book>/<n>/runs directory"
     );
   }
   if (Number(match[1]) !== options.issueNumber) {
@@ -21172,19 +21971,21 @@ async function admitDoctorInvocation(options) {
       `doctor --issue must be a positive integer, got ${options.issueNumber}`
     );
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "doctor",
+    subject: { unbound: true },
     home: options.home
   });
   let caseRunsPath;
@@ -21222,9 +22023,6 @@ async function admitDoctorInvocation(options) {
       { cause: error }
     );
   }
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths ?? [], attachmentsDirectory);
   const instruction = options.instruction ?? "";
   const instructionEmpty = instruction.trim() === "";
@@ -21248,7 +22046,7 @@ async function admitDoctorInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21333,7 +22131,7 @@ async function admitNotaryInvocation(options) {
   if (options.project !== void 0) {
     requireOptionPath("--project", options.project);
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   let sourceRun;
   try {
     sourceRun = await resolveNotarySourceRunLocator({
@@ -21347,24 +22145,24 @@ async function admitNotaryInvocation(options) {
     }
     throw error;
   }
+  const inheritedTicketNumber = await readBoardTicketNumber(sourceRun.runDirectory);
   const runId = options.createRunId?.() ?? uuidv7();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "notary",
+    subject: inheritedTicketNumber === void 0 ? { unbound: true } : { ticketNumber: inheritedTicketNumber },
     home: options.home
   });
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  const ticketFields = ticketAdmissionFields(
-    await readRunTicketNumber(sourceRun.runDirectory)
-  );
+  const ticketFields = ticketAdmissionFields(inheritedTicketNumber);
   const admitted = {
     role: "notary",
     runId,
@@ -21380,7 +22178,7 @@ async function admitNotaryInvocation(options) {
     ...ticketFields,
     ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId }
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21451,22 +22249,23 @@ async function admitGleanerLeftInvocation(options) {
   if (options.baseRevision.trim() === "") {
     throw new CliUsageError("--base requires a nonempty revision");
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "gleaner-left",
+    subject: { unbound: true },
     home: options.home
   });
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
   const instruction = options.instruction;
   const instructionEmpty = instruction.trim() === "";
   const admitted = {
@@ -21482,7 +22281,7 @@ async function admitGleanerLeftInvocation(options) {
     attachments: [],
     ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId }
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21572,24 +22371,23 @@ async function admitReviewerInvocation(options) {
   const authorityRefs = Object.freeze(
     (options.authorityRefs ?? []).map((ref) => requireAuthorityRef(ref))
   );
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const runId = (options.createRunId ?? uuidv7)();
   const {
     principal,
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "reviewer",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   const instruction = options.instruction;
   const instructionEmpty = instruction.trim() === "";
@@ -21612,7 +22410,7 @@ async function admitReviewerInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21711,7 +22509,7 @@ async function admitMergerInvocation(options) {
   if (instruction.trim() === "") {
     throw new CliUsageError("merger requires a nonblank task instruction");
   }
-  const projectRoot = resolve8(options.project ?? options.cwd);
+  const projectRoot = resolve7(options.project ?? options.cwd);
   const derived = await deriveMergerEnvelopeFromActiveMerge(
     projectRoot,
     options.gitState ?? createProductionMergerGitState(projectRoot)
@@ -21722,17 +22520,16 @@ async function admitMergerInvocation(options) {
     sessionDirectory,
     sessionFile,
     runDirectory,
+    attachmentsDirectory,
     ledgerHome,
     bookKey
   } = issueAdmissionPlacement(options.principalAuthority, {
     cwd: projectRoot,
     runId,
     role: "merger",
+    subject: { unbound: true },
     home: options.home
   });
-  const attachmentsDirectory = join13(runDirectory, "attachments");
-  ensureRealDirectoryTree(ledgerHome, sessionDirectory);
-  ensureRealDirectoryTree(ledgerHome, attachmentsDirectory);
   const attachments = await freezeAttachments(options.attachmentPaths, attachmentsDirectory);
   const targetLabel = derived.targetObjectId === "" ? "(none observed)" : derived.targetObjectId;
   const sourceLabel = derived.sourceObjectId === "" ? "(none observed)" : derived.sourceObjectId;
@@ -21758,8 +22555,8 @@ async function admitMergerInvocation(options) {
     resolutionScope: [...derived.resolutionScope],
     authorizedChecks: []
   });
-  const mergerInputPath = join13(runDirectory, "merger-input.json");
-  await writeFile4(
+  const mergerInputPath = join15(runDirectory, "merger-input.json");
+  await writeFile5(
     mergerInputPath,
     `${JSON.stringify(mergerInput, null, 2)}
 `,
@@ -21789,7 +22586,7 @@ async function admitMergerInvocation(options) {
       mediaKind: a.mediaKind
     }))
   };
-  const admittedRequestPath = join13(runDirectory, "admitted-request.json");
+  const admittedRequestPath = join15(runDirectory, "admitted-request.json");
   await writeAdmittedRequestPersistence(admittedRequestPath, admitted, {
     sessionDirectory,
     sessionFile
@@ -21843,11 +22640,11 @@ function parseAnalystCohortIssueToken(raw, flag) {
       `${flag} requires a comma-separated list of N or book:N`
     );
   }
-  const sep4 = trimmed.lastIndexOf(":");
-  if (sep4 > 0) {
-    const rhs = trimmed.slice(sep4 + 1);
+  const sep5 = trimmed.lastIndexOf(":");
+  if (sep5 > 0) {
+    const rhs = trimmed.slice(sep5 + 1);
     if (ANALYST_TICKET_NUMBER_PATTERN.test(rhs)) {
-      const bookKey = trimmed.slice(0, sep4);
+      const bookKey = trimmed.slice(0, sep5);
       if (bookKey.trim() === "") {
         throw new CliUsageError(
           `${flag} book:N requires a non-empty book key, got ${raw}`
@@ -22047,8 +22844,11 @@ var init_invocation = __esm({
     "use strict";
     init_activation_ledger_topology();
     init_activation_ledger_git();
+    init_role_run_placement();
     init_run_ticket_number();
+    init_role_run_relocation();
     init_doctor_evidence();
+    init_diarist_contracts();
     init_collector_config();
     init_collector_target();
     init_github_remote();
@@ -22063,23 +22863,23 @@ var init_invocation = __esm({
     init_cli_errors();
     init_option_definitions();
     DOCTOR_ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/;
-    DOCTOR_CASE_RUNS_PATH_PATTERN = /\/\.ak-roles\/books\/[^/]+\/issues\/([1-9]\d*)\/runs$/;
+    DOCTOR_CASE_RUNS_PATH_PATTERN = /\/\.ak-roles\/books\/[^/]+\/(?:issues\/)?([1-9]\d*)\/runs$/;
     ANALYST_TICKET_NUMBER_PATTERN = /^[1-9]\d*$/;
   }
 });
 
 // src/public-cli/load-production-acp-host.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join16 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function loadProductionAcpHostFactory(packageRoot2, host) {
   const description = lookupHostDescription(host);
   if (description === void 0) {
     throw new Error(`unregistered host: ${host}`);
   }
-  const built = join14(packageRoot2, "dist/acp-host/production-host.js");
-  const source = join14(packageRoot2, "src/acp-host/production-host.ts");
-  const target = existsSync6(built) ? built : source;
+  const built = join16(packageRoot2, "dist/acp-host/production-host.js");
+  const source = join16(packageRoot2, "src/acp-host/production-host.ts");
+  const target = existsSync7(built) ? built : source;
   const href = pathToFileURL(target).href;
   const mod = await import(href);
   const create = mod.createProductionAcpRoleTurnHost;
@@ -22093,17 +22893,17 @@ var init_load_production_acp_host = __esm({
 });
 
 // src/public-cli/load-production-headless-host.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join17 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function loadProductionHeadlessHostFactory(packageRoot2, host) {
   const description = lookupHeadlessHostDescription(host);
   if (description === void 0) {
     throw new Error(`unregistered headless host: ${host}`);
   }
-  const built = join15(packageRoot2, "dist/headless-host/production-host.js");
-  const source = join15(packageRoot2, "src/headless-host/production-host.ts");
-  const target = existsSync7(built) ? built : source;
+  const built = join17(packageRoot2, "dist/headless-host/production-host.js");
+  const source = join17(packageRoot2, "src/headless-host/production-host.ts");
+  const target = existsSync8(built) ? built : source;
   const href = pathToFileURL2(target).href;
   const mod = await import(href);
   const create = mod.createProductionHeadlessRoleTurnHost;
@@ -22229,8 +23029,8 @@ var init_role_turn_host_resolution = __esm({
 
 // src/package-resources/method-skill.ts
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile11, realpath as realpath5 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { readFile as readFile12, realpath as realpath5 } from "node:fs/promises";
+import { join as join18 } from "node:path";
 function gitBlobOid(bytes) {
   const body = typeof bytes === "string" ? Buffer.from(bytes, "utf8") : Buffer.from(bytes);
   const header = Buffer.from(`blob ${body.byteLength}\0`, "utf8");
@@ -22247,10 +23047,10 @@ function packagedMethodSkillRelativeDirectory(name) {
   return `${METHOD_SKILL_RELATIVE_ROOT}/${name}`;
 }
 function resolvePackagedMethodSkillRoot(packageRoot2, name) {
-  return join16(packageRoot2, packagedMethodSkillRelativeDirectory(name));
+  return join18(packageRoot2, packagedMethodSkillRelativeDirectory(name));
 }
 function resolvePackagedMethodSkillPath(packageRoot2, name) {
-  return join16(resolvePackagedMethodSkillRoot(packageRoot2, name), "SKILL.md");
+  return join18(resolvePackagedMethodSkillRoot(packageRoot2, name), "SKILL.md");
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -22344,11 +23144,11 @@ function parseProvenance(raw, expectedName) {
 }
 async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
   const rootDirectory = resolvePackagedMethodSkillRoot(packageRoot2, name);
-  const skillPathConfigured = join16(rootDirectory, "SKILL.md");
-  const provenancePath = join16(rootDirectory, "provenance.json");
+  const skillPathConfigured = join18(rootDirectory, "SKILL.md");
+  const provenancePath = join18(rootDirectory, "provenance.json");
   let provenanceRaw;
   try {
-    provenanceRaw = await readFile11(provenancePath, "utf8");
+    provenanceRaw = await readFile12(provenancePath, "utf8");
   } catch (error) {
     throw new PackagedMethodSkillUnavailableError(name, provenancePath, error);
   }
@@ -22362,10 +23162,10 @@ async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
   }
   const provenance = parseProvenance(provenanceJson, name);
   for (const [rel, expected] of Object.entries(provenance.files)) {
-    const absolute = join16(rootDirectory, rel);
+    const absolute = join18(rootDirectory, rel);
     let bytes;
     try {
-      bytes = await readFile11(absolute);
+      bytes = await readFile12(absolute);
     } catch (error) {
       throw new PackagedMethodSkillUnavailableError(name, absolute, error);
     }
@@ -22381,7 +23181,7 @@ async function loadPackagedMethodSkillMaterial(packageRoot2, name) {
   let raw;
   try {
     skillPath = await realpath5(skillPathConfigured);
-    raw = await readFile11(skillPath, "utf8");
+    raw = await readFile12(skillPath, "utf8");
   } catch (error) {
     throw new PackagedMethodSkillUnavailableError(name, skillPathConfigured, error);
   }
@@ -22459,45 +23259,13 @@ var init_method_skill = __esm({
   }
 });
 
-// src/auditor-dossier-tool.ts
-var init_auditor_dossier_tool = __esm({
-  "src/auditor-dossier-tool.ts"() {
-    "use strict";
-    init_build();
-  }
-});
-
-// src/gatekeeper-role.ts
-var init_gatekeeper_role = __esm({
-  "src/gatekeeper-role.ts"() {
-    "use strict";
-    init_auditor_dossier_tool();
-    init_submission_errors();
-    init_inspector_contracts();
-    init_gatekeeper_output();
-    init_submission_errors();
-  }
-});
-
-// src/compliance-transport.ts
-var AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE;
-var init_compliance_transport = __esm({
-  "src/compliance-transport.ts"() {
-    "use strict";
-    init_auditor_dossier_tool();
-    init_gatekeeper_role();
-    AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE = "ak_auditor_parent_attempt_binding";
-    AUDITOR_COMPLIANCE_FAILURE_ENTRY_TYPE = "ak_auditor_compliance_failure";
-  }
-});
-
 // src/ledger-session-read.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readLedgerSessionJsonl(path) {
-  const text = await readFile12(path, "utf8");
+  const text = await readFile13(path, "utf8");
   const lines = text.split("\n");
   const rows = [];
   for (let index = 0; index < lines.length; index += 1) {
@@ -22671,8 +23439,8 @@ var init_ledger_session_read = __esm({
 });
 
 // src/analyst-gate-cycles-read.ts
-import { readdir as readdir3 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { readdir as readdir5 } from "node:fs/promises";
+import { join as join19 } from "node:path";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -22887,10 +23655,10 @@ function pairGateRounds(volumes) {
   return rounds.sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt)).map((round, index) => ({ ...round, roundIndex: index + 1 }));
 }
 async function resolveOfficerSessionFromPointerFile(pointerPath) {
-  const { readFile: readFile23 } = await import("node:fs/promises");
+  const { readFile: readFile25 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile23(pointerPath, "utf8"));
+    raw = JSON.parse(await readFile25(pointerPath, "utf8"));
   } catch (error) {
     throw new Error(
       `direct officer run pointer unreadable in ${pointerPath}: ${error instanceof Error ? error.message : String(error)}`,
@@ -22913,7 +23681,7 @@ async function readAnalystGateCyclesFromAuditorRoles(auditorRolesDirectory, opti
   for (const directory of directories) {
     let names;
     try {
-      const entries = await readdir3(directory, { withFileTypes: true });
+      const entries = await readdir5(directory, { withFileTypes: true });
       names = entries.filter(
         (e) => e.isFile() && (e.name.endsWith(".jsonl") || e.name.endsWith(".pointer.json"))
       ).map((e) => e.name).sort();
@@ -22922,7 +23690,7 @@ async function readAnalystGateCyclesFromAuditorRoles(auditorRolesDirectory, opti
       throw error;
     }
     for (const name of names) {
-      const path = join17(directory, name);
+      const path = join19(directory, name);
       const fromPointer = name.endsWith(".pointer.json");
       const sessionPath = fromPointer ? await resolveOfficerSessionFromPointerFile(path) : path;
       if (sessionPath === void 0) continue;
@@ -22973,9 +23741,9 @@ var init_audit_escalation = __esm({
 });
 
 // src/run-terminal-artifacts.ts
-import { readdir as readdir4, readFile as readFile13 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname9, join as join18 } from "node:path";
-function isMissingPathError2(error) {
+import { readdir as readdir6, readFile as readFile14 } from "node:fs/promises";
+import { basename as basename7, dirname as dirname10, join as join20 } from "node:path";
+function isMissingPathError3(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 function errorText2(error) {
@@ -23005,9 +23773,9 @@ function readUsableTerminalArtifactBody(body) {
 async function readTerminalArtifactAtPath(path, file) {
   let raw;
   try {
-    raw = await readFile13(path, "utf8");
+    raw = await readFile14(path, "utf8");
   } catch (error) {
-    if (isMissingPathError2(error)) return void 0;
+    if (isMissingPathError3(error)) return void 0;
     return {
       status: "unreadable",
       file,
@@ -23042,14 +23810,14 @@ async function listUniqueErrorFallbackPaths(directories) {
   for (const dir of directories) {
     let names;
     try {
-      names = await readdir4(dir);
+      names = await readdir6(dir);
     } catch (error) {
-      if (isMissingPathError2(error)) continue;
+      if (isMissingPathError3(error)) continue;
       throw error;
     }
     for (const name of names.sort((a, b) => a.localeCompare(b))) {
       if (!UNIQUE_ERROR_FALLBACK_NAME.test(name)) continue;
-      found.push(join18(dir, name));
+      found.push(join20(dir, name));
     }
   }
   return found;
@@ -23065,14 +23833,14 @@ function presentUniqueFallbackBoundToRun(body, expectedRunId) {
   return typeof body.runId === "string" && body.runId === expectedRunId;
 }
 async function readRunTerminalArtifact(runDirectory) {
-  const artifactsDir = join18(runDirectory, "artifacts");
+  const artifactsDir = roleRunArtifactsDirectory(runDirectory);
   for (const file of RUN_TERMINAL_ARTIFACT_FILES) {
-    const path = join18(artifactsDir, file);
+    const path = join20(artifactsDir, file);
     const read = await readTerminalArtifactAtPath(path, file);
     if (read !== void 0) return read;
   }
   for (const relative3 of RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS) {
-    const path = join18(runDirectory, relative3);
+    const path = join20(runDirectory, relative3);
     const read = await readTerminalArtifactAtPath(path, "error.json");
     if (read !== void 0) return read;
   }
@@ -23081,7 +23849,7 @@ async function readRunTerminalArtifact(runDirectory) {
     if (read !== void 0) return read;
   }
   const expectedRunId = runIdFromRunDirectory(runDirectory);
-  for (const path of await listUniqueErrorFallbackPaths([dirname9(runDirectory)])) {
+  for (const path of await listUniqueErrorFallbackPaths([dirname10(runDirectory)])) {
     const read = await readTerminalArtifactAtPath(path, "error.json");
     if (read === void 0) continue;
     if (read.status === "present") {
@@ -23095,6 +23863,7 @@ var RUN_TERMINAL_ARTIFACT_FILES, RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS, UNI
 var init_run_terminal_artifacts = __esm({
   "src/run-terminal-artifacts.ts"() {
     "use strict";
+    init_role_run_placement();
     RUN_TERMINAL_ARTIFACT_FILES = [
       "report.json",
       "error.json",
@@ -23109,21 +23878,34 @@ var init_run_terminal_artifacts = __esm({
 });
 
 // src/submission-ledger.ts
-function submissionRecordFile(cwd, runId, home) {
-  const ledgerHome = resolveActivationLedgerHome(home);
+import { join as join21 } from "node:path";
+async function submissionRecordFile(cwd, runId, scope) {
+  const ledgerHome = resolveActivationLedgerHome(scope.home);
+  let sessionParent = scope.sessionParent;
+  if (sessionParent === void 0) {
+    const discoveredRun = await findRunDirectoryById(scope.home, runId);
+    if (discoveredRun === void 0) return void 0;
+    sessionParent = join21(discoveredRun, "session", "session.jsonl");
+  }
   return resolveSitianRecordPathInLedger({
     level: "event",
     kind: "candidate",
     subject: { runId },
-    cwd
+    cwd,
+    sessionParent
   }, ledgerHome).recordFile;
 }
-async function readOwnedSubmissionRecords(cwd, runId, home) {
-  const file = submissionRecordFile(cwd, runId, home);
+async function readOwnedSubmissionRecords(cwd, runId, scope = {}) {
+  const file = await submissionRecordFile(cwd, runId, scope);
+  if (file === void 0) {
+    return { file: void 0, owned: [] };
+  }
   const { records } = await readSitianRecords(file);
   return {
     file,
-    owned: records.filter((record4) => typeof record4.subject === "object" && record4.subject !== null && record4.subject.runId === runId)
+    owned: records.filter(
+      (record4) => typeof record4.subject === "object" && record4.subject !== null && record4.subject.runId === runId
+    )
   };
 }
 function resolveReadScope(homeOrScope) {
@@ -23146,8 +23928,8 @@ function recordAttemptId(record4) {
   }
   return void 0;
 }
-async function hasFreshAttemptSubmission(cwd, runId, attemptId, home) {
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, home);
+async function hasFreshAttemptSubmission(cwd, runId, attemptId, homeOrScope) {
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, resolveReadScope(homeOrScope));
   return owned.some((record4) => {
     if (recordAttemptId(record4) !== attemptId) return false;
     if (record4.kind === "sealed") return true;
@@ -23191,10 +23973,8 @@ function rowFromPayload(kind, payload, accepted, roleFallback) {
     ...typeof payload.toolCallId === "string" && payload.toolCallId.length > 0 ? { toolCallId: payload.toolCallId } : {}
   };
 }
-async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
-  const scope = resolveReadScope(homeOrScope);
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
-  const scoped = recordsForAttempt(owned, scope.attemptId);
+function mapOwnedToSubmissionRows(owned) {
+  const scoped = owned;
   const out = [];
   const indexByCall = /* @__PURE__ */ new Map();
   const roleByCall = /* @__PURE__ */ new Map();
@@ -23258,6 +24038,21 @@ async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
   }
   return out;
 }
+async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
+  const scope = resolveReadScope(homeOrScope);
+  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope);
+  const scoped = recordsForAttempt(owned, scope.attemptId);
+  return mapOwnedToSubmissionRows(scoped);
+}
+async function readAttemptScopedSubmissionRows(cwd, runId, attemptId, home) {
+  if (attemptId.length === 0) return [];
+  const { owned } = await readOwnedSubmissionRecords(
+    cwd,
+    runId,
+    home === void 0 ? {} : { home }
+  );
+  return mapOwnedToSubmissionRows(owned.filter((record4) => recordAttemptId(record4) === attemptId));
+}
 async function readRecordedSubmissions(cwd, runId, homeOrScope) {
   return (await readRecordedSubmissionRows(cwd, runId, homeOrScope)).map((row) => row.accepted);
 }
@@ -23265,33 +24060,35 @@ var init_submission_ledger = __esm({
   "src/submission-ledger.ts"() {
     "use strict";
     init_activation_ledger_topology();
+    init_host_contracts();
     init_audit_escalation();
     init_run_terminal_artifacts();
     init_sitian_facade();
+    init_run_lifecycle();
     init_submission_correctable_error();
     init_terminating_infrastructure();
   }
 });
 
 // src/session-opening-materials.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { readFile as readFile14 } from "node:fs/promises";
-import { dirname as dirname10, join as join19 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile15 } from "node:fs/promises";
+import { dirname as dirname11, join as join22 } from "node:path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolvePackageRootDir(moduleUrl = import.meta.url) {
-  let dir = dirname10(fileURLToPath(moduleUrl));
+  let dir = dirname11(fileURLToPath(moduleUrl));
   for (let i = 0; i < 8; i += 1) {
-    if (existsSync8(join19(dir, "package.json")) && existsSync8(join19(dir, "souls"))) {
+    if (existsSync9(join22(dir, "package.json")) && existsSync9(join22(dir, "souls"))) {
       return dir;
     }
-    const parent = dirname10(dir);
+    const parent = dirname11(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return fileURLToPath(new URL("..", moduleUrl));
 }
 async function readPackageMaterial(relativePath) {
-  return readFile14(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
+  return readFile15(fileURLToPath(new URL(relativePath, packageRootUrl)), "utf8");
 }
 async function joinPackageMaterials(relativePaths) {
   const chunks = [];
@@ -23387,6 +24184,7 @@ var DOCTOR_CANDIDATE_ENTRY_TYPE;
 var init_dossier_resolution = __esm({
   "src/dossier-resolution.ts"() {
     "use strict";
+    init_host_contracts();
     DOCTOR_CANDIDATE_ENTRY_TYPE = "ak_doctor_audit_candidate";
   }
 });
@@ -23532,13 +24330,13 @@ var init_reviewer_dispatch = __esm({
 });
 
 // src/public-cli/reviewer-dispatch-rejection.ts
-import { readFile as readFile15, unlink as unlink3 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { readFile as readFile16, unlink as unlink3 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 function isReviewerPreflightViolation(value) {
   return typeof value === "string" && REVIEWER_PREFLIGHT_VIOLATIONS.includes(value);
 }
 function reviewerDispatchRejectionPath(runDirectory) {
-  return join20(runDirectory, REVIEWER_DISPATCH_REJECTION_FILE);
+  return join23(runDirectory, REVIEWER_DISPATCH_REJECTION_FILE);
 }
 async function clearReviewerDispatchRejection(runDirectory) {
   try {
@@ -23553,7 +24351,7 @@ async function clearReviewerDispatchRejection(runDirectory) {
 async function readReviewerDispatchRejection(runDirectory) {
   let raw;
   try {
-    raw = await readFile15(reviewerDispatchRejectionPath(runDirectory), "utf8");
+    raw = await readFile16(reviewerDispatchRejectionPath(runDirectory), "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return void 0;
@@ -23910,14 +24708,15 @@ var init_terminal = __esm({
 
 // src/public-cli/settlement.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { appendFile as appendFile2, readFile as readFile16, readdir as readdir5, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname11, join as join21 } from "node:path";
+import { appendFile as appendFile2, readFile as readFile17, readdir as readdir7, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname12, join as join24 } from "node:path";
 function sealedLedgerHome(admitted) {
   return homeFromRunDirectory(admitted.runDirectory);
 }
 function ledgerReadScope(admitted, scope) {
   return {
     home: sealedLedgerHome(admitted),
+    sessionParent: join24(admitted.runDirectory, "session", "session.jsonl"),
     ...scope?.courtAttemptId === void 0 || scope.courtAttemptId.length === 0 ? {} : { attemptId: scope.courtAttemptId }
   };
 }
@@ -23934,6 +24733,16 @@ function roleOutcomeFromRows(role, rows) {
   return { kind: "accepted", role, payloads };
 }
 async function sealedLedgerOutcome(admitted, role, scope) {
+  const home = sealedLedgerHome(admitted);
+  if (scope?.courtAttemptId !== void 0 && scope.courtAttemptId.length > 0) {
+    const thisCourt = await readAttemptScopedSubmissionRows(
+      admitted.projectRoot,
+      admitted.runId,
+      scope.courtAttemptId,
+      home
+    );
+    return roleOutcomeFromRows(role, thisCourt);
+  }
   const rows = await readRecordedSubmissionRows(
     admitted.projectRoot,
     admitted.runId,
@@ -23947,7 +24756,7 @@ async function attemptProducedFreshSubmission(admitted, scope) {
     admitted.projectRoot,
     admitted.runId,
     scope.courtAttemptId,
-    sealedLedgerHome(admitted)
+    ledgerReadScope(admitted, scope)
   );
 }
 async function recordedSubmissionPayloads(admitted, scope) {
@@ -23960,11 +24769,15 @@ async function recordedSubmissionPayloads(admitted, scope) {
 function withSubmissions(terminal, submissions) {
   if (submissions.length === 0) return terminal;
   const roleOutcome = terminal.roleOutcome;
-  const withPayloads = roleOutcome.kind === "accepted" || roleOutcome.kind === "audit_escalation" || roleOutcome.kind === "failure" ? { ...roleOutcome, payloads: submissions } : roleOutcome;
+  const withPayloads = roleOutcome.kind === "accepted" || roleOutcome.kind === "audit_escalation" ? { ...roleOutcome, payloads: (roleOutcome.payloads ?? []).length > 0 ? roleOutcome.payloads : submissions } : roleOutcome.kind === "failure" ? { ...roleOutcome, payloads: roleOutcome.payloads ?? submissions } : roleOutcome;
   return { ...terminal, roleOutcome: withPayloads, submissions };
 }
 async function attachRecordedSubmissions(admitted, terminal, scope) {
-  return withSubmissions(terminal, await recordedSubmissionPayloads(admitted, scope));
+  void scope;
+  return withSubmissions(
+    terminal,
+    await recordedSubmissionPayloads(admitted, void 0)
+  );
 }
 async function settleHostEndedNoReceipt(admitted, authority) {
   const facts = noReceiptLifecycleFacts({
@@ -24038,10 +24851,10 @@ function presentControlledFailure(failure, io) {
 }
 async function inspectJudgeSession(sessionFile) {
   try {
-    await readFile16(sessionFile, "utf8");
+    await readFile17(sessionFile, "utf8");
     return { state: "present" };
   } catch (error) {
-    if (isMissingPathError3(error)) return { state: "missing" };
+    if (isMissingPathError4(error)) return { state: "missing" };
     return {
       state: "unreadable",
       diagnostic: error instanceof Error ? error.message || error.name : String(error)
@@ -24241,7 +25054,7 @@ function explicitInternalKnownFailureClassificationInput(failure) {
     ...failure.details === void 0 ? {} : { knownDetails: failure.details }
   };
 }
-function isMissingPathError3(error) {
+function isMissingPathError4(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function sessionReadFailure(error, fallbackMessage) {
@@ -24270,7 +25083,7 @@ function sessionReadFailure(error, fallbackMessage) {
   return failed;
 }
 async function readBoundSessionEntries(sessionFile) {
-  const text = await readFile16(sessionFile, "utf8");
+  const text = await readFile17(sessionFile, "utf8");
   const entries = [];
   for (const line2 of text.trim().split("\n").filter(Boolean)) {
     try {
@@ -24331,7 +25144,7 @@ async function readSitianRetainedAuditorProviderStop(sessionFile) {
       kind: "auditor",
       sessionParent: sessionFile,
       // Path is driven by sessionParent when under ledger home; cwd is a fallback only.
-      cwd: dirname11(sessionFile)
+      cwd: dirname12(sessionFile)
     });
     const { records } = await readSitianRecords(recordFile);
     for (let i = records.length - 1; i >= 0; i -= 1) {
@@ -24357,18 +25170,18 @@ async function readSessionProviderStop(sessionFile) {
   }
 }
 async function readBoundEvidenceChildKnownFailure(sessionFile) {
-  const childDirectory = join21(dirname11(sessionFile), "evidence-children");
+  const childDirectory = join24(dirname12(sessionFile), "evidence-children");
   let names;
   try {
-    names = await readdir5(childDirectory);
+    names = await readdir7(childDirectory);
   } catch (error) {
-    if (isMissingPathError3(error)) return void 0;
+    if (isMissingPathError4(error)) return void 0;
     throw sessionReadFailure(error, "failed to read bound evidence-child session directory");
   }
   for (const file of names.filter((name) => name.endsWith(".jsonl")).sort().reverse()) {
     let entries;
     try {
-      entries = await readBoundSessionEntries(join21(childDirectory, file));
+      entries = await readBoundSessionEntries(join24(childDirectory, file));
     } catch (error) {
       throw sessionReadFailure(error, "failed to read discovered evidence-child session");
     }
@@ -24392,7 +25205,7 @@ async function loadBoundAuditorVolumes(sessionFile) {
   try {
     parentEntries = await readBoundSessionEntries(sessionFile);
   } catch (error) {
-    if (isMissingPathError3(error)) return void 0;
+    if (isMissingPathError4(error)) return void 0;
     throw sessionReadFailure(error, "failed to read parent session for auditor binding");
   }
   const parentId = parentEntries.find((entry) => entry.type === "session")?.id;
@@ -24423,22 +25236,22 @@ async function loadBoundAuditorVolumes(sessionFile) {
     latestParentUserIndex = i;
     break;
   }
-  const childDirectories = [join21(dirname11(sessionFile), "auditor-roles")];
+  const childDirectories = [join24(dirname12(sessionFile), "auditor-roles")];
   const valid = [];
   let sawAnyDirectory = false;
   for (const childDirectory of childDirectories) {
     let names;
     try {
-      names = await readdir5(childDirectory);
+      names = await readdir7(childDirectory);
       sawAnyDirectory = true;
     } catch (error) {
-      if (isMissingPathError3(error)) continue;
+      if (isMissingPathError4(error)) continue;
       throw sessionReadFailure(error, "failed to read bound auditor session directory");
     }
     for (const file of names.filter((name) => name.endsWith(".jsonl")).sort().reverse()) {
       let entries;
       try {
-        entries = await readBoundSessionEntries(join21(childDirectory, file));
+        entries = await readBoundSessionEntries(join24(childDirectory, file));
       } catch (error) {
         throw sessionReadFailure(error, "failed to read discovered auditor session");
       }
@@ -24596,7 +25409,7 @@ async function resolveAuditedRunnerFailureResolution(input) {
     );
     if (terminatingFailure !== void 0) return resolutionOf(terminatingFailure);
   } catch (error) {
-    if (!isMissingPathError3(error)) {
+    if (!isMissingPathError4(error)) {
       const failure = sessionReadFailure(error, "failed to recover typed terminating-tool failure");
       return resolutionOf({
         cause: "session",
@@ -24943,8 +25756,8 @@ function projectTerminalGateFact(rounds) {
   };
 }
 async function extractGateFactFromSessionDirectory(sessionDirectory, options = {}) {
-  const directories = [join21(sessionDirectory, "auditor-roles")];
-  const parentSessionFile = options.parentSessionFile ?? join21(sessionDirectory, "session.jsonl");
+  const directories = [join24(sessionDirectory, "auditor-roles")];
+  const parentSessionFile = options.parentSessionFile ?? join24(sessionDirectory, "session.jsonl");
   const rounds = await readAnalystGateCyclesFromAuditorRoles(directories, {
     parentSessionFile
   });
@@ -25025,7 +25838,7 @@ async function extractNavigatorFactFromAdmittedSession(sessionFile) {
     const entries = await readBoundSessionEntries(sessionFile);
     return extractNavigatorFact(entries);
   } catch (error) {
-    if (isMissingPathError3(error)) {
+    if (isMissingPathError4(error)) {
       return {
         disposition: "unavailable",
         source: "unknown",
@@ -25042,9 +25855,9 @@ async function extractNavigatorFactFromAdmittedSession(sessionFile) {
 async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25058,7 +25871,7 @@ async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25087,9 +25900,9 @@ async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
 async function publishCoderArtifacts(admitted, roleOutcome, coordinates, options = {}) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25104,7 +25917,7 @@ async function publishCoderArtifacts(admitted, roleOutcome, coordinates, options
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25138,7 +25951,7 @@ async function readLawfulSettlementEntries(sessionFile) {
   try {
     return await readBoundSessionEntries(sessionFile);
   } catch (error) {
-    if (isMissingPathError3(error)) return void 0;
+    if (isMissingPathError4(error)) return void 0;
     throw error instanceof Error && error.knownCause === "session" ? error : sessionReadFailure(error, "session unreadable");
   }
 }
@@ -25225,9 +26038,9 @@ function extractFixerMethodInvocations(entries, options) {
 async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25242,7 +26055,7 @@ async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25313,9 +26126,9 @@ async function settleLawfulFixerTerminalResult(admitted, authority, options, sco
 async function publishCollectorArtifacts(admitted, roleOutcome, coordinates) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25329,7 +26142,7 @@ async function publishCollectorArtifacts(admitted, roleOutcome, coordinates) {
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25431,9 +26244,9 @@ function extractDoctorCandidateAuditNoReceiptFact(entries) {
 async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25449,7 +26262,7 @@ async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, option
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25687,9 +26500,9 @@ function extractReviewerMethodInvocations(entries, options) {
 async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, options) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25703,7 +26516,7 @@ async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, opti
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25792,9 +26605,9 @@ function extractMergerMethodInvocations(entries, options) {
 async function publishMergerArtifacts(admitted, roleOutcome, coordinates, options) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
   const artifactsDir = await ensureRunArtifactsDir(admitted.runDirectory);
-  const reportPath = join21(artifactsDir, "report.json");
-  const evidencePath = join21(artifactsDir, "evidence.json");
-  await writeFile5(
+  const reportPath = join24(artifactsDir, "report.json");
+  const evidencePath = join24(artifactsDir, "evidence.json");
+  await writeFile6(
     reportPath,
     `${JSON.stringify(
       {
@@ -25808,7 +26621,7 @@ async function publishMergerArtifacts(admitted, roleOutcome, coordinates, option
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25912,13 +26725,13 @@ function publicationAttemptFromError(path, error) {
 }
 function uniqueFailureFallbackDirs(runDirectory, baseDir) {
   const dirs = [];
-  for (const dir of [baseDir, runDirectory, dirname11(runDirectory)]) {
+  for (const dir of [baseDir, runDirectory, dirname12(runDirectory)]) {
     if (!dirs.includes(dir)) dirs.push(dir);
   }
   return dirs;
 }
 async function resolveFailureArtifactsBase(runDirectory) {
-  const artifactsDir = join21(runDirectory, "artifacts");
+  const artifactsDir = roleRunArtifactsDirectory(runDirectory);
   try {
     await ensureRunArtifactsDir(runDirectory);
     return { baseDir: artifactsDir };
@@ -25934,13 +26747,13 @@ async function writeFailureJsonRetainingCause(preferredCandidates, uniqueFallbac
   const candidates = [
     ...preferredCandidates,
     // One unique name per fallback dir — collisions on fixed names cannot exhaust this.
-    ...uniqueFallbackDirs.map((dir) => join21(dir, `${stem}.${randomUUID3()}.json`))
+    ...uniqueFallbackDirs.map((dir) => join24(dir, `${stem}.${randomUUID3()}.json`))
   ];
   for (let i = 0; i < candidates.length; i += 1) {
     const path = candidates[i];
     const payload = issues.length === 0 ? basePayload : { ...basePayload, publicationIssues: issues };
     try {
-      await writeFile5(
+      await writeFile6(
         path,
         `${JSON.stringify(payload, null, 2)}
 `,
@@ -25979,26 +26792,26 @@ async function publishFailureArtifacts(admitted, failure, authority) {
   } catch (error) {
     priorIssues.push(publicationAttemptFromError(sessionFile, error));
   }
-  const underArtifacts = baseDir === join21(admitted.runDirectory, "artifacts");
+  const underArtifacts = baseDir === roleRunArtifactsDirectory(admitted.runDirectory);
   const uniqueFallbackDirs = uniqueFailureFallbackDirs(
     admitted.runDirectory,
     baseDir
   );
   const errorCandidates = underArtifacts ? [
-    join21(baseDir, "error.json"),
-    join21(baseDir, "error.settlement.json"),
-    join21(admitted.runDirectory, "error.settlement.json")
+    join24(baseDir, "error.json"),
+    join24(baseDir, "error.settlement.json"),
+    join24(admitted.runDirectory, "error.settlement.json")
   ] : [
-    join21(baseDir, "error.settlement.json"),
-    join21(baseDir, "error.json")
+    join24(baseDir, "error.settlement.json"),
+    join24(baseDir, "error.json")
   ];
   const evidenceCandidates = underArtifacts ? [
-    join21(baseDir, "evidence.json"),
-    join21(baseDir, "evidence.settlement.json"),
-    join21(admitted.runDirectory, "evidence.settlement.json")
+    join24(baseDir, "evidence.json"),
+    join24(baseDir, "evidence.settlement.json"),
+    join24(admitted.runDirectory, "evidence.settlement.json")
   ] : [
-    join21(baseDir, "evidence.settlement.json"),
-    join21(baseDir, "evidence.json")
+    join24(baseDir, "evidence.settlement.json"),
+    join24(baseDir, "evidence.json")
   ];
   const errorPayloadBase = {
     kind: "error",
@@ -26193,6 +27006,7 @@ var init_settlement = __esm({
     init_method_skill();
     init_navigator_invocation_identity();
     init_receipt_delivery_policy();
+    init_role_run_placement();
     init_invocation();
     init_terminal();
     COLLECTOR_INFRASTRUCTURE_TOOLS = /* @__PURE__ */ new Set([
@@ -26248,17 +27062,17 @@ var init_turn_request = __esm({
 });
 
 // src/session-identity.ts
-import { mkdir as mkdir4, readFile as readFile17, rename, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname12, join as join22 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile18, rename as rename2, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname13, join as join25 } from "node:path";
 function createSessionIdentityAuthority(authority, sessionBindingFile) {
-  const bindingPath = (principal) => join22(authority.decode(principal).sessionDirectory, sessionBindingFile);
+  const bindingPath = (principal) => join25(authority.decode(principal).sessionDirectory, sessionBindingFile);
   return {
     resolveSessionFile(principal) {
       return authority.decode(principal).sessionFile;
     },
     async load(principal) {
       try {
-        const value = JSON.parse(await readFile17(bindingPath(principal), "utf8"));
+        const value = JSON.parse(await readFile18(bindingPath(principal), "utf8"));
         if (typeof value !== "object" || value === null || typeof value.sessionId !== "string") {
           throw new Error("durable session binding is invalid");
         }
@@ -26270,11 +27084,11 @@ function createSessionIdentityAuthority(authority, sessionBindingFile) {
     },
     async bind(principal, sessionId) {
       const target = bindingPath(principal);
-      await mkdir4(dirname12(target), { recursive: true });
+      await mkdir3(dirname13(target), { recursive: true });
       const temporary = `${target}.${process.pid}.tmp`;
-      await writeFile6(temporary, `${JSON.stringify({ sessionId })}
+      await writeFile7(temporary, `${JSON.stringify({ sessionId })}
 `, { encoding: "utf8", mode: 384 });
-      await rename(temporary, target);
+      await rename2(temporary, target);
     }
   };
 }
@@ -26307,9 +27121,9 @@ var init_ticket_provenance_contracts = __esm({
 });
 
 // src/ticket-provenance.ts
-import { join as join23 } from "node:path";
+import { join as join26 } from "node:path";
 function ticketProvenanceSubject(ticketNumber) {
-  if (!Number.isSafeInteger(ticketNumber) || ticketNumber < 1) {
+  if (!isSafePositiveTicketNumber(ticketNumber)) {
     throw new Error(`ticket-provenance subject requires a positive ticket number, got ${String(ticketNumber)}`);
   }
   return String(ticketNumber);
@@ -26325,18 +27139,22 @@ function resolveTicketProvenanceVolume(ticketNumber, cwd, home) {
   return {
     recordFile: path.recordFile,
     volumeDir: path.sessionDir,
-    humanViewFile: join23(path.sessionDir, TICKET_PROVENANCE_HUMAN_VIEW)
+    humanViewFile: join26(path.sessionDir, TICKET_PROVENANCE_HUMAN_VIEW)
   };
 }
 var init_ticket_provenance = __esm({
   "src/ticket-provenance.ts"() {
     "use strict";
     init_sitian_facade();
+    init_run_ticket_number();
     init_ticket_provenance_contracts();
   }
 });
 
 // src/public-cli/case-dossier-delivery.ts
+import { mkdtemp, readFile as readFile19, rm, writeFile as writeFile8 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join27 } from "node:path";
 function describeDossierFile(path) {
   return path;
 }
@@ -26355,19 +27173,43 @@ async function projectCaseDossierPointerSection(input) {
     `\u8BB0\u5F55\u5377\u5B97\uFF1A${describeDossierFile(volume.recordFile)}`
   ].join("\n");
 }
-var CASE_DOSSIER_SECTION_HEADING;
+async function deliverCaseDossierAsAttachment(input) {
+  const section = await projectCaseDossierPointerSection({
+    ticketNumber: input.ticketNumber,
+    projectRoot: input.projectRoot,
+    home: input.home
+  });
+  if (section === void 0) return void 0;
+  const stagingDir = await mkdtemp(join27(tmpdir(), "ak-case-dossier-"));
+  try {
+    const stagingPath = join27(stagingDir, CASE_DOSSIER_ATTACH_FILE);
+    await writeFile8(stagingPath, `${section}
+`, "utf8");
+    return await freezeAttachmentsIntoRun(
+      [stagingPath],
+      input.runDirectory,
+      CASE_DOSSIER_ATTACH_KEY
+    );
+  } finally {
+    await rm(stagingDir, { recursive: true, force: true });
+  }
+}
+var CASE_DOSSIER_SECTION_HEADING, CASE_DOSSIER_ATTACH_KEY, CASE_DOSSIER_ATTACH_FILE;
 var init_case_dossier_delivery = __esm({
   "src/public-cli/case-dossier-delivery.ts"() {
     "use strict";
     init_ticket_provenance();
+    init_invocation();
     CASE_DOSSIER_SECTION_HEADING = "## \u672C\u7968\u8D77\u5C45\u5F55\uFF08\u7CFB\u7EDF\u968F\u6848\u63D0\u4F9B\uFF09";
+    CASE_DOSSIER_ATTACH_KEY = "case-dossier";
+    CASE_DOSSIER_ATTACH_FILE = "case-dossier-pointer.md";
   }
 });
 
 // src/host-transition-prior-native.ts
-import { access as access3, readdir as readdir6 } from "node:fs/promises";
-import { dirname as dirname13, join as join24 } from "node:path";
-function isEnoent2(error) {
+import { access as access3, readdir as readdir8 } from "node:fs/promises";
+import { dirname as dirname14, join as join28 } from "node:path";
+function isEnoent3(error) {
   return typeof error === "object" && error !== null && error.code === "ENOENT";
 }
 async function listPiNativeRecordPaths(sessionFile) {
@@ -26375,28 +27217,28 @@ async function listPiNativeRecordPaths(sessionFile) {
     await access3(sessionFile);
     return [sessionFile];
   } catch (error) {
-    if (isEnoent2(error)) return [];
+    if (isEnoent3(error)) return [];
     throw error;
   }
 }
 async function listSitianRecordPaths(sessionParent) {
-  const sessionRoot = dirname13(sessionParent);
+  const sessionRoot = dirname14(sessionParent);
   let entries;
   try {
-    entries = await readdir6(sessionRoot, { withFileTypes: true });
+    entries = await readdir8(sessionRoot, { withFileTypes: true });
   } catch (error) {
-    if (isEnoent2(error)) return [];
+    if (isEnoent3(error)) return [];
     throw error;
   }
   const recordPaths = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const recordFile = join24(sessionRoot, entry.name, "records.jsonl");
+    const recordFile = join28(sessionRoot, entry.name, "records.jsonl");
     try {
       await access3(recordFile);
       recordPaths.push(recordFile);
     } catch (error) {
-      if (!isEnoent2(error)) throw error;
+      if (!isEnoent3(error)) throw error;
     }
   }
   recordPaths.sort();
@@ -26460,8 +27302,8 @@ var init_public_run_credentials = __esm({
 // src/public-cli/auto-resume.ts
 import { constants as fsConstants2 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { lstat as lstat5, mkdir as mkdir5, open as open2 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { lstat as lstat6, mkdir as mkdir4, open as open2 } from "node:fs/promises";
+import { join as join29 } from "node:path";
 async function persistReturnedRunState(admitted, authority, options) {
   if (options?.lawful === true) {
     await markRunTerminal(admitted.runDirectory);
@@ -26496,24 +27338,21 @@ async function finalizeExceptionRunBestEffort(runDirectory, io) {
     );
   }
 }
-function runArtifactsDirectory(runDirectory) {
-  return join25(runDirectory, "artifacts");
-}
 async function ensureRealArtifactsDirectory(runDirectory) {
-  const runStat = await lstat5(runDirectory);
+  const runStat = await lstat6(runDirectory);
   if (runStat.isSymbolicLink() || !runStat.isDirectory()) {
     throw new Error("run artifact retention: run directory is not a real directory");
   }
-  const artifactsDir = runArtifactsDirectory(runDirectory);
+  const artifactsDir = roleRunArtifactsDirectory(runDirectory);
   try {
-    const existing = await lstat5(artifactsDir);
+    const existing = await lstat6(artifactsDir);
     if (existing.isSymbolicLink() || !existing.isDirectory()) {
       throw new Error("run artifact retention: artifacts path is not a real directory");
     }
   } catch (error) {
-    if (!isMissingPathError4(error)) throw error;
-    await mkdir5(artifactsDir, { recursive: true });
-    const created = await lstat5(artifactsDir);
+    if (!isMissingPathError5(error)) throw error;
+    await mkdir4(artifactsDir, { recursive: true });
+    const created = await lstat6(artifactsDir);
     if (created.isSymbolicLink() || !created.isDirectory()) {
       throw new Error("run artifact retention: artifacts directory is not a real directory");
     }
@@ -26543,7 +27382,7 @@ function serializeThrownValue(value, depth = 0, seen = /* @__PURE__ */ new WeakS
   }
   return value;
 }
-function isMissingPathError4(error) {
+function isMissingPathError5(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function transferNestedValue(value, depth, seen) {
@@ -26579,7 +27418,7 @@ function jsonSafeReplacer() {
   };
 }
 async function writeHardenedArtifactFile(artifactsDir, namePrefix, payload) {
-  const filePath = join25(artifactsDir, `${namePrefix}-${randomUUID4()}.json`);
+  const filePath = join29(artifactsDir, `${namePrefix}-${randomUUID4()}.json`);
   const body = `${JSON.stringify(payload, jsonSafeReplacer(), 2)}
 `;
   const noFollowFlag = typeof fsConstants2.O_NOFOLLOW === "number" ? fsConstants2.O_NOFOLLOW : 0;
@@ -26828,6 +27667,7 @@ var dummyIo, TurnDispatchedFailure, DISPATCH_ERROR_RETENTION_ENTRY_TYPE;
 var init_auto_resume = __esm({
   "src/public-cli/auto-resume.ts"() {
     "use strict";
+    init_role_run_placement();
     init_run_lifecycle();
     init_config2();
     init_terminal();
@@ -26850,8 +27690,8 @@ var init_auto_resume = __esm({
 
 // src/public-cli/post-admission.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readFile as readFile18, writeFile as writeFile7 } from "node:fs/promises";
-import { isAbsolute as isAbsolute8, join as join26, resolve as resolve9 } from "node:path";
+import { readFile as readFile20, writeFile as writeFile9 } from "node:fs/promises";
+import { isAbsolute as isAbsolute8, join as join30, resolve as resolve8 } from "node:path";
 function describeCaughtError(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -26865,15 +27705,18 @@ function appendContinuationSection(continuation, section) {
 ${section}`;
   return continuation.kind === "initial" ? { kind: "initial", prompt } : { kind: "resume", prompt };
 }
+function isStationChildOfficerDialogue(role, env) {
+  return env.stationChild === true && isOfficerReviewSeat(role);
+}
 function withOnceSuccessfulBeforeDispatch(adapters) {
   const hook = adapters.beforeDispatch;
   if (hook === void 0) return adapters;
   let succeeded = false;
   return {
     ...adapters,
-    beforeDispatch: async (admitted) => {
+    beforeDispatch: async (admitted, lease) => {
       if (succeeded) return;
-      await hook(admitted);
+      await hook(admitted, lease);
       succeeded = true;
     }
   };
@@ -26892,8 +27735,8 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
   } catch (appendError) {
     try {
       const artifactsDir = await ensureRealArtifactsDirectory(admitted.runDirectory);
-      await writeFile7(
-        join26(artifactsDir, `post-admission-diagnostic-${randomUUID5()}.json`),
+      await writeFile9(
+        join30(artifactsDir, `post-admission-diagnostic-${randomUUID5()}.json`),
         `${JSON.stringify({ version: 1, ...payload }, null, 2)}
 `,
         { encoding: "utf8", flag: "wx" }
@@ -26909,7 +27752,7 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
 }
 async function readInvocationHost(runDirectory) {
   try {
-    const raw = JSON.parse(await readFile18(join26(runDirectory, "invocation.json"), "utf8"));
+    const raw = JSON.parse(await readFile20(join30(runDirectory, "invocation.json"), "utf8"));
     return typeof raw.host === "string" && raw.host.trim() !== "" ? raw.host : void 0;
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
@@ -27027,6 +27870,44 @@ async function dispatchPostAdmissionTurn(input) {
   const persistRunState = input.persistRunState !== false;
   const deferredPersist = persistRunState ? {} : { needsPersist: true };
   const shouldPresent = adapters.shouldPresentSettled ?? ((terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome));
+  let afterDispatchApplied = false;
+  const finishAfterTurn = async (result2) => {
+    if (adapters.afterDispatch === void 0 || afterDispatchApplied) return result2;
+    afterDispatchApplied = true;
+    try {
+      await adapters.afterDispatch(admitted, lease);
+      return result2;
+    } catch (error) {
+      const primaryFailure = result2.terminal !== void 0 && !isLawfulTypedTerminalOutcome(result2.terminal.roleOutcome);
+      if (primaryFailure) {
+        await recordBestEffortPostDispatchDiagnostic(
+          admitted,
+          env,
+          `afterDispatch failed beside primary terminal (best-effort continue): ${describeErrorIdentity(error)}`,
+          io
+        );
+        return result2;
+      }
+      return {
+        ...await presentControlledFailure2(
+          admitted,
+          {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: error
+          },
+          adapters,
+          env.principalAuthority,
+          io,
+          persistRunState
+        ),
+        ...result2.turnDispatched === true ? { turnDispatched: true } : {},
+        ...result2.skipAutoResume === true ? { skipAutoResume: true } : {},
+        ...deferredPersist
+      };
+    }
+  };
   try {
     const missingCredential = missingCredentialPreDispatchFailure(
       env.model,
@@ -27078,7 +27959,7 @@ async function dispatchPostAdmissionTurn(input) {
     await clearReviewerDispatchRejection(admitted.runDirectory);
     if (adapters.beforeDispatch !== void 0) {
       try {
-        await adapters.beforeDispatch(admitted);
+        await adapters.beforeDispatch(admitted, lease);
       } catch (error) {
         const settled2 = await presentControlledFailure2(
           admitted,
@@ -27106,19 +27987,28 @@ async function dispatchPostAdmissionTurn(input) {
     if (hostTransition !== void 0) {
       turnRequest = { ...turnRequest, hostTransition };
     }
-    const dossierSection = await projectCaseDossierPointerSection({
-      ticketNumber: admitted.ticketNumber,
-      projectRoot: admitted.projectRoot,
-      home: env.home
-    });
-    if (dossierSection !== void 0) {
-      turnRequest = {
-        ...turnRequest,
-        continuation: appendContinuationSection(
-          turnRequest.continuation,
-          dossierSection
-        )
-      };
+    if (isStationChildOfficerDialogue(admitted.role, env)) {
+      await deliverCaseDossierAsAttachment({
+        ticketNumber: admitted.ticketNumber,
+        projectRoot: admitted.projectRoot,
+        home: env.home,
+        runDirectory: admitted.runDirectory
+      });
+    } else {
+      const dossierSection = await projectCaseDossierPointerSection({
+        ticketNumber: admitted.ticketNumber,
+        projectRoot: admitted.projectRoot,
+        home: env.home
+      });
+      if (dossierSection !== void 0) {
+        turnRequest = {
+          ...turnRequest,
+          continuation: appendContinuationSection(
+            turnRequest.continuation,
+            dossierSection
+          )
+        };
+      }
     }
     await markRunRunning(
       admitted.runDirectory,
@@ -27144,12 +28034,12 @@ async function dispatchPostAdmissionTurn(input) {
         io,
         persistRunState
       );
-      return { ...settled2, turnDispatched: true, ...deferredPersist };
+      return await finishAfterTurn({ ...settled2, turnDispatched: true, ...deferredPersist });
     }
     let stderrLogWriteFailure;
     try {
-      await writeFile7(
-        join26(admitted.runDirectory, "stderr.log"),
+      await writeFile9(
+        join30(admitted.runDirectory, "stderr.log"),
         result2.stderr,
         "utf8"
       );
@@ -27223,7 +28113,7 @@ async function dispatchPostAdmissionTurn(input) {
         io,
         persistRunState
       );
-      return { ...settledFailure, turnDispatched: true, ...deferredPersist };
+      return await finishAfterTurn({ ...settledFailure, turnDispatched: true, ...deferredPersist });
     }
     if (settledOutcome !== void 0) {
       if (persistRunState) {
@@ -27244,10 +28134,10 @@ async function dispatchPostAdmissionTurn(input) {
             io,
             persistRunState
           );
-          return { ...failed, turnDispatched: true, ...deferredPersist };
+          return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
         }
       }
-      return { ...settledOutcome, ...deferredPersist };
+      return await finishAfterTurn({ ...settledOutcome, ...deferredPersist });
     }
     if (hostSignalFailed) {
       const resolutionInput = controlledFailureInputFromResolution(resolution);
@@ -27274,7 +28164,7 @@ async function dispatchPostAdmissionTurn(input) {
         io,
         persistRunState
       );
-      return { ...failed, turnDispatched: true, ...deferredPersist };
+      return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
     }
     if (stderrLogWriteFailure !== void 0) {
       const failed = await settleAfterTurnStarted(
@@ -27290,7 +28180,7 @@ async function dispatchPostAdmissionTurn(input) {
         io,
         persistRunState
       );
-      return { ...failed, turnDispatched: true, ...deferredPersist };
+      return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
     }
     const noReceipt = await attachRecordedSubmissions(
       admitted,
@@ -27315,16 +28205,16 @@ async function dispatchPostAdmissionTurn(input) {
           io,
           persistRunState
         );
-        return { ...failed, turnDispatched: true, ...deferredPersist };
+        return await finishAfterTurn({ ...failed, turnDispatched: true, ...deferredPersist });
       }
     }
-    return {
+    return await finishAfterTurn({
       exitCode: exitCodeForTerminalOutcome(noReceipt.roleOutcome),
       admitted,
       terminal: noReceipt,
       turnDispatched: true,
       ...deferredPersist
-    };
+    });
   } finally {
     try {
       await lease.release();
@@ -27338,25 +28228,17 @@ async function dispatchPostAdmissionTurn(input) {
   }
 }
 function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepared) {
-  const officerSourcePath = request.summons?.sourceRunPath;
-  const withReread = (body) => {
-    if (officerSourcePath === void 0 || admitted.role !== "notary" && admitted.role !== "inspector" && admitted.role !== "auditor") {
-      return body;
-    }
-    if (body.startsWith("\u8BF7\u91CD\u8BFB")) return body;
-    return `\u8BF7\u91CD\u8BFB
-${body}`;
-  };
+  const officerDialogue = isStationChildOfficerDialogue(admitted.role, env);
   let prompt;
   if (request.message !== void 0) {
     if (summonsPrepared !== void 0) {
-      prompt = withReread(buildInstructionTransportPrompt({
+      prompt = officerDialogue ? request.message : buildInstructionTransportPrompt({
         instruction: request.message,
         instructionEmpty: false,
         attachments: summonsPrepared.attachments
-      }));
+      });
     } else if (request.summons !== void 0) {
-      prompt = withReread(request.message);
+      prompt = request.message;
     } else {
       prompt = buildResumeContinuationPrompt({
         packageRoot: env.packageRoot,
@@ -27365,17 +28247,9 @@ ${body}`;
       });
     }
   } else if (summonsPrepared !== void 0) {
-    prompt = withReread(buildInstructionTransportPrompt(summonsPrepared));
+    prompt = officerDialogue ? summonsPrepared.instructionEmpty ? "" : summonsPrepared.instruction : buildInstructionTransportPrompt(summonsPrepared);
   } else if (request.summons !== void 0) {
-    const path = request.summons.sourceRunPath;
-    if (path !== void 0 && (admitted.role === "notary" || admitted.role === "inspector" || admitted.role === "auditor")) {
-      prompt = `\u8BF7\u91CD\u8BFB
-${GATE_DOSSIER_POINTER_PREFIX}${path}`;
-    } else if (admitted.role === "notary" || admitted.role === "inspector" || admitted.role === "auditor") {
-      prompt = "\u8BF7\u91CD\u8BFB";
-    } else {
-      prompt = "";
-    }
+    prompt = "";
   } else {
     prompt = buildResumeContinuationPrompt({
       packageRoot: env.packageRoot,
@@ -27411,8 +28285,8 @@ async function dispatchAfterWriterLease(input) {
   }
 }
 function isAlreadyFrozenSummonsAttachment(runDirectory, attachmentPath) {
-  const absolute = isAbsolute8(attachmentPath) ? attachmentPath : resolve9(attachmentPath);
-  return pathContainedIn(join26(runDirectory, "attachments"), absolute);
+  const absolute = isAbsolute8(attachmentPath) ? attachmentPath : resolve8(attachmentPath);
+  return pathContainedIn(join30(runDirectory, "attachments"), absolute);
 }
 async function prepareSummonsResumeMaterials(runDirectory, summons) {
   if (summons === void 0) return void 0;
@@ -27708,6 +28582,7 @@ var init_post_admission = __esm({
     init_activation_ledger_topology();
     init_engine_material();
     init_session_identity();
+    init_host_contracts();
     init_case_dossier_delivery();
     init_host_transition_prior_native();
     init_public_run_credentials();
@@ -28060,7 +28935,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
         home: env.home
       });
       auditorSourceRun = resolved.runDirectory;
-      auditorSourceTicket = await readRunTicketNumber(resolved.runDirectory);
+      auditorSourceTicket = await readBoardTicketNumber(resolved.runDirectory);
     } catch (error) {
       presentStructuralRejection(
         new CliUsageError(error instanceof Error ? error.message : String(error)),
@@ -28069,7 +28944,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
       return { exitCode: 2 };
     }
   }
-  const resumeInstruction = env.reviewReask;
+  const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
   const summons = {
     ...resumeInstruction === void 0 ? {
       instruction: parsed.instruction,
@@ -28108,7 +28983,8 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
       ...parsed.project === void 0 ? {} : { project: parsed.project },
       ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
       ...env.model === void 0 ? {} : { model: env.model },
-      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId }
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      ...auditorSourceTicket === void 0 ? {} : { assertedTicketNumber: auditorSourceTicket }
     });
   } catch (error) {
     if (error instanceof CliUsageError) {
@@ -28135,7 +29011,8 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
         ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
         continuation: {
           kind: "initial",
-          prompt: buildInstructionTransportPrompt(
+          // #879: gate first mint uses parent payload as content when present.
+          prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInstructionTransportPrompt(
             admitted,
             engineSessionMaterialFromOptions({
               ...pickEngineAxis(env),
@@ -28149,13 +29026,7 @@ async function runPublicInstructionSeat(argv, env, io, role, parseArgv2) {
         env,
         io,
         request: turnRequest,
-        adapters: instructionSeatAdapters({
-          beforeDispatch: async (admittedSeat) => {
-            if (auditorSourceTicket !== void 0) {
-              await bindAdmittedTicketNumber(admittedSeat, auditorSourceTicket);
-            }
-          }
-        }),
+        adapters: instructionSeatAdapters(),
         ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
       });
     }
@@ -28340,7 +29211,7 @@ async function runPublicNotary(argv, env, io, parseNotaryArgv2) {
     throw error;
   }
   {
-    const resumeInstruction = env.reviewReask;
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
     const summons = {
       sourceRunPath: source.runDirectory,
       sourceRun: source,
@@ -28395,7 +29266,9 @@ async function runPublicNotary(argv, env, io, parseNotaryArgv2) {
     ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
     continuation: {
       kind: "initial",
-      prompt: buildNotaryTransportPrompt(admitted, engineMaterial)
+      // #879: gate path first mint carries parent payload as dialogue content;
+      // external zero-prompt kickoff unchanged when no body/reask.
+      prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildNotaryTransportPrompt(admitted, engineMaterial)
     }
   });
   return await runPostAdmissionOneShot({
@@ -28483,12 +29356,20 @@ __export(inspector_run_exports, {
   runPublicInspector: () => runPublicInspector,
   runPublicInspectorResume: () => runPublicInspectorResume
 });
+function inspectorParentRunPath(admitted) {
+  if (typeof admitted.sourceRunPath === "string" && admitted.sourceRunPath.trim() !== "") {
+    return admitted.sourceRunPath;
+  }
+  return parentRunPathFromGatePointerInstruction(admitted.instruction);
+}
 function buildInspectorTurnRequest(admitted, options) {
+  const sourceRun = inspectorParentRunPath(admitted);
   return projectRoleTurnRequest(
     admitted,
     {
       activation: {
-        role: "inspector"
+        role: "inspector",
+        ...sourceRun === void 0 ? {} : { sourceRun }
       }
     },
     options
@@ -28508,7 +29389,7 @@ async function runPublicInspector(argv, env, io, parseInspectorArgv2) {
   const projectRoot = parsed.project ?? env.cwd;
   const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction);
   if (parentRunPath !== void 0) {
-    const resumeInstruction = env.reviewReask;
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
     const summons = {
       sourceRunPath: parentRunPath,
       ...resumeInstruction === void 0 ? {
@@ -28553,6 +29434,10 @@ async function runPublicInspector(argv, env, io, parseInspectorArgv2) {
     throw error;
   }
   await markRunAdmitted(admitted, env.principalAuthority);
+  if (parentRunPath !== void 0) {
+    await persistAdmittedSourceRunPath(admitted, parentRunPath);
+    admitted = { ...admitted, sourceRunPath: parentRunPath };
+  }
   const engineMaterial = engineSessionMaterialFromOptions({
     ...pickEngineAxis(env),
     packageRoot: env.packageRoot
@@ -28567,7 +29452,8 @@ async function runPublicInspector(argv, env, io, parseInspectorArgv2) {
     ...env.correlationId === void 0 || env.correlationId.trim() === "" ? {} : { correlationId: env.correlationId },
     continuation: {
       kind: "initial",
-      prompt: buildInspectorTransportPrompt(admitted, engineMaterial)
+      // #879: gate first mint uses parent payload as content; binding stays typed activation.
+      prompt: env.reviewReask ?? env.gateReviewInstruction ?? buildInspectorTransportPrompt(admitted, engineMaterial)
     }
   });
   return await runPostAdmissionOneShot({
@@ -28864,10 +29750,26 @@ function buildDiaristTurnRequest(admitted, options) {
     options
   );
 }
-function diaristAdapters() {
+async function bindAndRelocateDiaristIfBoardBound(admitted, authority, lease) {
+  const boardTicket = await readBoardTicketNumber(admitted.runDirectory);
+  if (boardTicket === void 0) return;
+  if (admitted.ticketNumber === void 0) {
+    await bindAdmittedTicketNumber(admitted, boardTicket);
+  }
+  await relocateAdmittedRunToTicket(admitted, authority, lease);
+}
+function diaristAdapters(env) {
   return {
     trySettle: (admitted, authority, scope) => trySettleDiaristTerminalResult(admitted, authority, scope),
-    shouldPresentSettled: () => true
+    shouldPresentSettled: () => true,
+    // Resume interrupted state: board ticket already on pages, run still under unbound/.
+    beforeDispatch: async (admitted, lease) => {
+      await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
+    },
+    // First post-turn assert: accept hook wrote board pages; relocate before lease release.
+    afterDispatch: async (admitted, lease) => {
+      await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
+    }
   };
 }
 async function runPublicDiarist(argv, env, io, parseDiaristArgv2) {
@@ -28915,7 +29817,8 @@ async function runPublicDiarist(argv, env, io, parseDiaristArgv2) {
       ...parsed.project === void 0 ? {} : { project: parsed.project },
       ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
       ...env.model === void 0 ? {} : { model: env.model },
-      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId }
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      ...handoffTicket === void 0 ? {} : { assertedTicketNumber: handoffTicket }
     });
   } catch (error) {
     if (error instanceof CliUsageError) {
@@ -28925,9 +29828,6 @@ async function runPublicDiarist(argv, env, io, parseDiaristArgv2) {
     throw error;
   }
   await markRunAdmitted(admitted, env.principalAuthority);
-  if (typeof handoffTicket === "number" && Number.isSafeInteger(handoffTicket) && handoffTicket >= 1) {
-    await bindAdmittedTicketNumber(admitted, handoffTicket);
-  }
   const turnProjection = {
     packageRoot: env.packageRoot,
     home: env.home,
@@ -28953,19 +29853,8 @@ async function runPublicDiarist(argv, env, io, parseDiaristArgv2) {
     env,
     io,
     request: turnRequest,
-    adapters: diaristAdapters(),
+    adapters: diaristAdapters(env),
     ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
-  }).then(async (result2) => {
-    if (admitted.ticketNumber === void 0 && result2.admitted !== void 0) {
-      const fromPages = await readRunTicketNumber(admitted.runDirectory);
-      if (fromPages !== void 0) {
-        await bindAdmittedTicketNumber(admitted, fromPages);
-        if (result2.admitted.ticketNumber === void 0) {
-          result2.admitted.ticketNumber = fromPages;
-        }
-      }
-    }
-    return result2;
   });
 }
 async function runPublicDiaristResume(request, env, io) {
@@ -28989,7 +29878,7 @@ async function runPublicDiaristResume(request, env, io) {
         )
       );
     },
-    adapters: diaristAdapters(),
+    adapters: diaristAdapters(env),
     ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
@@ -29016,8 +29905,8 @@ __export(public_role_summons_exports, {
   summonGateOfficer: () => summonGateOfficer,
   summonPublicRole: () => summonPublicRole
 });
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join31 } from "node:path";
 function createCapturingIo() {
   const chunks = [];
   return {
@@ -29040,7 +29929,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 (existsSync10(join31(dir, "package.json")) && existsSync10(join31(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -29134,7 +30023,7 @@ async function createSummonEnv(options) {
 async function summonPublicRole(options) {
   const packageRoot2 = resolveSummonsPackageRoot(options.packageRoot);
   const home = await resolveSummonHome(options);
-  const agentDir = options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join27(home, ".pi", "agent");
+  const agentDir = options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join31(home, ".pi", "agent");
   const {
     loadCredentialProviders: loadCredentialProviders2,
     loadPublicCliConfig: loadPublicCliConfig2,
@@ -29175,6 +30064,8 @@ async function summonPublicRole(options) {
     ...options.signal === void 0 ? {} : { signal: options.signal },
     // #753: reask rides the existing notary same-ticket resume summons.instruction.
     ...options.reviewReask === void 0 ? {} : { reviewReask: options.reviewReask },
+    // #879: verbatim submission body on officer dialogue content channel.
+    ...options.gateReviewInstruction === void 0 ? {} : { gateReviewInstruction: options.gateReviewInstruction },
     ...options.boundTicketNumber === void 0 ? {} : { boundTicketNumber: options.boundTicketNumber },
     // createRunId is the only remaining env overlay — host is seat-selected above.
     ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
@@ -29282,6 +30173,11 @@ async function summonGateOfficer(options) {
     const { homeFromRunDirectory: homeFromRunDirectory3 } = await Promise.resolve().then(() => (init_activation_ledger_topology(), activation_ledger_topology_exports));
     home = homeFromRunDirectory3(options.sourceRunDirectory);
   }
+  let gateReviewInstruction;
+  if (options.reask === void 0 && options.submission !== void 0) {
+    const { readableGateItem: readableGateItem2 } = await Promise.resolve().then(() => (init_readable_gate_item(), readable_gate_item_exports));
+    gateReviewInstruction = readableGateItem2(options.submission);
+  }
   const common = {
     cwd: options.cwd,
     ...home === void 0 ? {} : { home },
@@ -29289,6 +30185,7 @@ async function summonGateOfficer(options) {
     ...options.io === void 0 ? {} : { io: options.io },
     ...options.signal === void 0 ? {} : { signal: options.signal },
     ...options.reask === void 0 ? {} : { reviewReask: options.reask },
+    ...gateReviewInstruction === void 0 ? {} : { gateReviewInstruction },
     ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
     ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
     ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
@@ -29342,6 +30239,30 @@ function buildCountersignTurnRequest(admitted, options) {
     options
   );
 }
+function courtTicketNumbersFromOutcome(roleOutcome, principalTicket) {
+  if (roleOutcome === void 0) return void 0;
+  const payloads = roleOutcome.kind === "accepted" || roleOutcome.kind === "audit_escalation" || roleOutcome.kind === "failure" ? roleOutcome.payloads ?? [] : [];
+  let latest;
+  for (const payload of payloads) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+      continue;
+    }
+    const record4 = payload;
+    if (!Object.hasOwn(record4, "courtTicketNumbers")) continue;
+    const raw = record4.courtTicketNumbers;
+    if (!Array.isArray(raw)) continue;
+    const members = projectCourtTicketNumbers(raw);
+    if (members === null) continue;
+    if (members.length === 0) {
+      if (raw.length === 0) {
+        latest = projectCourtTicketNumbers([], { principalTicket }) ?? void 0;
+      }
+      continue;
+    }
+    latest = projectCourtTicketNumbers(raw, { principalTicket }) ?? void 0;
+  }
+  return latest;
+}
 function courtDiaristEscalated(roleOutcome) {
   if (roleOutcome === void 0) return false;
   if (roleOutcome.kind === "audit_escalation") return true;
@@ -29392,9 +30313,14 @@ async function invokeCourtDiarist(input, env, io) {
     };
   }
   const asserted = result2.admitted?.ticketNumber;
-  if (typeof asserted === "number" && Number.isSafeInteger(asserted) && asserted >= 1) {
+  if (isSafePositiveTicketNumber(asserted)) {
+    const courtTicketNumbers = courtTicketNumbersFromOutcome(roleOutcome, asserted);
     return {
-      identity: { kind: "ticket", ticketNumber: asserted }
+      identity: {
+        kind: "ticket",
+        ticketNumber: asserted,
+        ...courtTicketNumbers === void 0 ? {} : { courtTicketNumbers }
+      }
     };
   }
   return {
@@ -29407,24 +30333,37 @@ async function runCountersignCourtDiaristStation(admitted, env, io) {
     return;
   }
   if (admitted.ticketNumber === void 0) return;
-  const outcome = await invokeCourtDiarist(
-    {
-      instruction: `\u6574\u7406 #${admitted.ticketNumber} \u7684\u672C\u6848\u4F9D\u636E\u3002`,
-      projectRoot: admitted.projectRoot,
-      failureLabel: `ticket #${admitted.ticketNumber}`,
-      // Refresh holds a typed key — hand it off so identity is bound before turn.
-      boundTicketNumber: admitted.ticketNumber
-    },
-    env,
-    io
-  );
-  if (outcome.identity.kind === "escalate") {
-    throw new StationChildExhaustedError(
-      "court diarist station escalated (cannot identify court target)"
-    );
+  let refreshTickets;
+  if (admitted.courtTicketNumbers !== void 0) {
+    if (admitted.courtTicketNumbers.length === 0 || !admitted.courtTicketNumbers.includes(admitted.ticketNumber)) {
+      throw new StationChildExhaustedError(
+        `court diarist station: courtTicketNumbers is damaged (empty or missing principal #${admitted.ticketNumber})`
+      );
+    }
+    refreshTickets = admitted.courtTicketNumbers;
+  } else {
+    refreshTickets = [admitted.ticketNumber];
   }
-  if (outcome.failedWithoutEscalate !== void 0) {
-    throw new StationChildExhaustedError(outcome.failedWithoutEscalate.diagnostic);
+  for (const ticketNumber of refreshTickets) {
+    const outcome = await invokeCourtDiarist(
+      {
+        instruction: `\u6574\u7406 #${ticketNumber} \u7684\u672C\u6848\u4F9D\u636E\u3002`,
+        projectRoot: admitted.projectRoot,
+        failureLabel: `ticket #${ticketNumber}`,
+        // Refresh holds a typed key — hand it off so identity is bound before turn.
+        boundTicketNumber: ticketNumber
+      },
+      env,
+      io
+    );
+    if (outcome.identity.kind === "escalate") {
+      throw new StationChildExhaustedError(
+        "court diarist station escalated (cannot identify court target)"
+      );
+    }
+    if (outcome.failedWithoutEscalate !== void 0) {
+      throw new StationChildExhaustedError(outcome.failedWithoutEscalate.diagnostic);
+    }
   }
 }
 async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
@@ -29460,6 +30399,7 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
   }
   await markRunAdmitted(admitted, env.principalAuthority);
   let typedTicket;
+  let typedCourtTicketNumbers;
   let identityDiaristRan = false;
   if (env.runCourtDiaristStation === void 0) {
     const outcome = await invokeCourtDiarist(
@@ -29503,7 +30443,9 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
       );
     }
     if (outcome.identity.kind === "ticket") {
-      typedTicket = outcome.identity.ticketNumber;
+      const assertedTicket = outcome.identity.ticketNumber;
+      typedTicket = assertedTicket;
+      typedCourtTicketNumbers = outcome.identity.courtTicketNumbers;
       const summons = {
         instruction: parsed.instruction,
         instructionEmpty: parsed.instruction.trim() === "",
@@ -29517,13 +30459,18 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
         freshSummons: env.freshSummons,
         summons,
         resume: async (runId, materials) => {
+          await bindAdmittedTicketNumber(admitted, assertedTicket);
+          await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
           await markRunTerminal(admitted.runDirectory);
           return await runPublicCountersignResume(
             {
               runId,
               ...materials === void 0 ? {} : { summons: materials }
             },
-            env,
+            {
+              ...env,
+              ...typedCourtTicketNumbers === void 0 ? {} : { pendingCourtTicketNumbers: typedCourtTicketNumbers }
+            },
             io
           );
         }
@@ -29533,6 +30480,29 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
       }
     }
   }
+  if (identityDiaristRan && typedTicket !== void 0) {
+    try {
+      await bindAdmittedTicketNumber(admitted, typedTicket);
+      await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+      await bindCourtTicketNumbersOnAdmitted(
+        admitted,
+        typedCourtTicketNumbers ?? [typedTicket]
+      );
+    } catch (error) {
+      return await presentControlledFailure2(
+        admitted,
+        {
+          timedOut: false,
+          code: null,
+          stderr: "",
+          thrown: error
+        },
+        countersignAdapters(),
+        env.principalAuthority,
+        io
+      );
+    }
+  }
   const turnProjection = {
     packageRoot: env.packageRoot,
     home: env.home,
@@ -29553,19 +30523,23 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
     }
   };
   const turnRequest = buildCountersignTurnRequest(admitted, turnProjection);
-  return await runPostAdmissionOneShot({
+  const result2 = await runPostAdmissionOneShot({
     admitted,
     env,
     io,
     request: turnRequest,
     adapters: countersignAdapters({
-      beforeDispatch: async (admittedSeat) => {
+      beforeDispatch: async (admittedSeat, lease) => {
         if (!identityDiaristRan) {
           await runCountersignCourtDiaristStation(admittedSeat, env, io);
         } else if (typedTicket !== void 0) {
-          await bindAdmittedTicketNumber(admittedSeat, typedTicket);
           await runCountersignCourtDiaristStation(admittedSeat, env, io);
         }
+        await relocateAdmittedRunToTicket(
+          admittedSeat,
+          env.principalAuthority,
+          lease
+        );
         Object.assign(
           turnRequest,
           buildCountersignTurnRequest(admittedSeat, turnProjection)
@@ -29574,6 +30548,8 @@ async function runPublicCountersign(argv, env, io, parseCountersignArgv2) {
     }),
     ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
   });
+  await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+  return result2;
 }
 function countersignAdapters(options) {
   return {
@@ -29610,6 +30586,15 @@ async function runPublicCountersignResume(request, env, io) {
     },
     adapters: countersignAdapters({
       beforeDispatch: async (admitted) => {
+        if (admitted.courtTicketNumbersDamage !== void 0) {
+          throw new StationChildExhaustedError(admitted.courtTicketNumbersDamage);
+        }
+        if (env.pendingCourtTicketNumbers !== void 0) {
+          await bindCourtTicketNumbersOnAdmitted(
+            admitted,
+            env.pendingCourtTicketNumbers
+          );
+        }
         await runCountersignCourtDiaristStation(admitted, env, io);
       }
     }),
@@ -29621,6 +30606,8 @@ var init_countersign_run = __esm({
     "use strict";
     init_engine_material();
     init_cli_errors();
+    init_diarist_contracts();
+    init_run_ticket_number();
     init_invocation();
     init_post_admission();
     init_run_lifecycle();
@@ -30276,16 +31263,16 @@ var init_analyst_book_key = __esm({
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { rename as rename2, rm, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname14, join as join28 } from "node:path";
+import { rename as rename3, rm as rm2, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname15, join as join32 } from "node:path";
 async function writeFileAtomically(destination, contents) {
-  const parent = dirname14(destination);
-  const temporary = join28(parent, `.atomic-write-${randomUUID6()}.tmp`);
+  const parent = dirname15(destination);
+  const temporary = join32(parent, `.atomic-write-${randomUUID6()}.tmp`);
   try {
-    await writeFile8(temporary, contents);
-    await rename2(temporary, destination);
+    await writeFile10(temporary, contents);
+    await rename3(temporary, destination);
   } catch (error) {
-    await rm(temporary, { force: true }).catch(() => void 0);
+    await rm2(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -30296,17 +31283,17 @@ var init_atomic_write = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open3, readFile as readFile19, unlink as unlink4 } from "node:fs/promises";
-import { dirname as dirname15, join as join29 } from "node:path";
+import { open as open3, readFile as readFile21, unlink as unlink4 } from "node:fs/promises";
+import { dirname as dirname16, join as join33 } from "node:path";
 function sleep(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve10) => {
+    setTimeout(resolve10, ms);
   });
 }
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   const indexPath = analystLibraryIndexPath(ledgerHome);
-  ensureRealDirectoryTree(ledgerHome, dirname15(indexPath));
-  const lockPath = join29(dirname15(indexPath), LIBRARY_INDEX_LOCK_NAME);
+  ensureRealDirectoryTree(ledgerHome, dirname16(indexPath));
+  const lockPath = join33(dirname16(indexPath), LIBRARY_INDEX_LOCK_NAME);
   assertLedgerFileInsideHome(lockPath, ledgerHome);
   const startedAt = Date.now();
   while (true) {
@@ -30333,7 +31320,7 @@ async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   }
 }
 function analystLibraryIndexPath(ledgerHome) {
-  return join29(ledgerHome, "analyst", "library-index.json");
+  return join33(ledgerHome, "analyst", "library-index.json");
 }
 function rowFromIssueMetricsPage(page) {
   return {
@@ -30424,7 +31411,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile19(path, "utf8");
+    raw = await readFile21(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
       return void 0;
@@ -30442,7 +31429,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
 }
 async function writeAnalystLibraryIndexPage(ledgerHome, page) {
   const path = analystLibraryIndexPath(ledgerHome);
-  ensureRealDirectoryTree(ledgerHome, dirname15(path));
+  ensureRealDirectoryTree(ledgerHome, dirname16(path));
   assertLedgerFileInsideHome(path, ledgerHome);
   await writeFileAtomically(path, `${JSON.stringify(page, null, 2)}
 `);
@@ -30628,9 +31615,9 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir7, readFile as readFile20 } from "node:fs/promises";
-import { join as join30 } from "node:path";
-function isMissingPathError5(error) {
+import { readdir as readdir9, readFile as readFile22 } from "node:fs/promises";
+import { basename as basename8, join as join34 } from "node:path";
+function isMissingPathError6(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 function errorText3(error) {
@@ -30642,7 +31629,7 @@ function isRecord10(value) {
 async function readExistingRunLifecycleState(runDirectory) {
   try {
     const raw = JSON.parse(
-      await readFile20(join30(runDirectory, "run-state.json"), "utf8")
+      await readFile22(join34(runDirectory, "run-state.json"), "utf8")
     );
     if (!isRecord10(raw) || typeof raw.state !== "string") return void 0;
     return raw.state;
@@ -30664,19 +31651,19 @@ function tryResolveBookKeyFromProjectRoot(projectRoot) {
 }
 async function listLedgerBookNames(booksRoot) {
   try {
-    const entries = await readdir7(booksRoot, { withFileTypes: true });
+    const entries = await readdir9(booksRoot, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch (error) {
-    if (isMissingPathError5(error)) return [];
+    if (isMissingPathError6(error)) return [];
     throw error;
   }
 }
 async function readInvocationScopeFields(runDirectory) {
   let raw;
   try {
-    raw = await readFile20(join30(runDirectory, "invocation.json"), "utf8");
+    raw = await readFile22(join34(runDirectory, "invocation.json"), "utf8");
   } catch (error) {
-    if (isMissingPathError5(error)) return void 0;
+    if (isMissingPathError6(error)) return void 0;
     throw error;
   }
   const parsed = JSON.parse(raw);
@@ -30685,8 +31672,9 @@ async function readInvocationScopeFields(runDirectory) {
     return void 0;
   }
   const projectRoot = parsed.projectRoot;
-  if (typeof parsed.ticketNumber === "number" && Number.isInteger(parsed.ticketNumber) && parsed.ticketNumber >= 1) {
-    return { projectRoot, ticketNumber: parsed.ticketNumber };
+  const ticketNumber = await readRunTicketNumber(runDirectory);
+  if (ticketNumber !== void 0) {
+    return { projectRoot, ticketNumber };
   }
   return { projectRoot };
 }
@@ -30706,15 +31694,15 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile20(join30(runDirectory, "invocation.json"), "utf8");
+    const raw = await readFile22(join34(runDirectory, "invocation.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (isRecord10(parsed) && typeof parsed.sessionFile === "string" && parsed.sessionFile.trim() !== "") {
       return parsed.sessionFile;
     }
   } catch (error) {
-    if (!isMissingPathError5(error)) throw error;
+    if (!isMissingPathError6(error)) throw error;
   }
-  return join30(runDirectory, "session", "session.jsonl");
+  return join34(runDirectory, "session", "session.jsonl");
 }
 function attributeSessionRowsForRun(input) {
   if (pathContainedIn(input.runDirectory, input.sessionFile)) {
@@ -30886,9 +31874,9 @@ async function classifyScopedRun(input) {
   }
   let gateCycles;
   try {
-    const parentSessionFile = join30(input.runDirectory, "session", "session.jsonl");
+    const parentSessionFile = join34(input.runDirectory, "session", "session.jsonl");
     gateCycles = await readAnalystGateCyclesFromAuditorRoles(
-      join30(input.runDirectory, "session", "auditor-roles"),
+      join34(input.runDirectory, "session", "auditor-roles"),
       { parentSessionFile }
     );
   } catch (error) {
@@ -30921,7 +31909,7 @@ async function classifyScopedRun(input) {
 async function scanAnalystIssueRuns(input) {
   const ledgerHome = resolveActivationLedgerHome(input.home);
   const scopeTicketNumber = input.ticketNumber;
-  const booksRoot = join30(ledgerHome, "books");
+  const booksRoot = join34(ledgerHome, "books");
   let wholeBook = false;
   let scopeRootIdentity;
   let bookNames;
@@ -30953,19 +31941,18 @@ async function scanAnalystIssueRuns(input) {
   const unreadable = [];
   const scopeConflicts = [];
   for (const book of bookNames) {
-    const runsDir = join30(booksRoot, book, "runs");
-    let runNames;
+    const bookDir = join34(booksRoot, book);
+    let runDirectories;
     try {
-      const entries = await readdir7(runsDir, { withFileTypes: true });
-      runNames = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+      runDirectories = await listBookRunDirectories(bookDir);
     } catch (error) {
-      if (isMissingPathError5(error)) continue;
+      if (isMissingPathError6(error)) continue;
       throw error;
     }
-    for (const runName of runNames) {
+    for (const runDirectory of runDirectories) {
+      const runName = basename8(runDirectory);
       const parsed = parseRunDirectoryName2(runName);
       if (parsed === void 0) continue;
-      const runDirectory = join30(runsDir, runName);
       let scopeFields;
       try {
         scopeFields = await readInvocationScopeFields(runDirectory);
@@ -31005,6 +31992,8 @@ var init_analyst_ledger = __esm({
     "use strict";
     init_activation_ledger_git();
     init_activation_ledger_topology();
+    init_role_run_placement();
+    init_run_ticket_number();
     init_ledger_session_read();
     init_run_terminal_artifacts();
     init_analyst_gate_cycles_read();
@@ -31819,7 +32808,7 @@ var init_analyst_metric_family = __esm({
 
 // src/analyst-page.ts
 import { createHash as createHash5 } from "node:crypto";
-import { dirname as dirname16, join as join31 } from "node:path";
+import { dirname as dirname17, join as join35 } from "node:path";
 function analystIssuePageKey(address) {
   const parts = ["book", address.bookKey];
   if (address.issueNumber !== void 0) {
@@ -31830,7 +32819,7 @@ function analystIssuePageKey(address) {
   return createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
 }
 function analystIssuePagePath(ledgerHome, address) {
-  return join31(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
+  return join35(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
 }
 function analystIssuePageAddressFromPage(page) {
   return {
@@ -31949,7 +32938,7 @@ async function buildAnalystIssueMetricsPage(input) {
 }
 async function writeAnalystIssueMetricsPage(ledgerHome, page) {
   const path = analystIssuePagePath(ledgerHome, analystIssuePageAddressFromPage(page));
-  ensureRealDirectoryTree(ledgerHome, dirname16(path));
+  ensureRealDirectoryTree(ledgerHome, dirname17(path));
   assertLedgerFileInsideHome(path, ledgerHome);
   await writeFileAtomically(path, `${JSON.stringify(page, null, 2)}
 `);
@@ -31966,8 +32955,8 @@ var init_analyst_page = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile21 } from "node:fs/promises";
-function isMissingPathError6(error) {
+import { readFile as readFile23 } from "node:fs/promises";
+function isMissingPathError7(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
 function cachedPageMatchesRequestedScope(page, input) {
@@ -31996,13 +32985,13 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile21(pagePath, "utf8");
+    const raw = await readFile23(pagePath, "utf8");
     const page = JSON.parse(raw);
     if (cachedPageMatchesRequestedScope(page, { bookKey, ...input })) {
       return { mode: "issue", page, pagePath };
     }
   } catch (error) {
-    if (!isMissingPathError6(error)) {
+    if (!isMissingPathError7(error)) {
       throw new AnalystIssueComputeError({
         bookKey,
         projectRoot,
@@ -32091,10 +33080,10 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile21(pagePath, "utf8");
+      const raw = await readFile23(pagePath, "utf8");
       JSON.parse(raw);
     } catch (error) {
-      if (!isMissingPathError6(error)) {
+      if (!isMissingPathError7(error)) {
         throw new AnalystIssueComputeError({ bookKey, projectRoot, cause: error });
       }
       try {
@@ -32190,8 +33179,8 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile22 } from "node:fs/promises";
-import { isAbsolute as isAbsolute10, resolve as resolve10 } from "node:path";
+import { readFile as readFile24 } from "node:fs/promises";
+import { isAbsolute as isAbsolute10, resolve as resolve9 } from "node:path";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
   try {
     return resolveBookKeyFromGit(cwd);
@@ -32240,10 +33229,10 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
     );
   }
   const sourcePath = attachmentPaths[0];
-  const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve10(sourcePath);
+  const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve9(sourcePath);
   let bytes;
   try {
-    bytes = await readFile22(absolute);
+    bytes = await readFile24(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -32363,7 +33352,7 @@ __export(cli_exports, {
   runAkRole: () => runAkRole
 });
 import { realpath as realpath6 } from "node:fs/promises";
-import { join as join32 } from "node:path";
+import { join as join36 } from "node:path";
 function takePublicGlobalFlag(argv, index, options) {
   const tokens = argv.slice(index);
   const taken = options.takeDashed(tokens);
@@ -32460,7 +33449,7 @@ function resolveHome(env) {
   return env.home ?? packageMachineHome();
 }
 function resolveAgentDir(env, home) {
-  return env.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join32(home, ".pi", "agent");
+  return env.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join36(home, ".pi", "agent");
 }
 function parseThinking(value) {
   return value;
@@ -33474,8 +34463,8 @@ var init_cli = __esm({
 });
 
 // src/public-cli/main.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { dirname as dirname17, join as join33 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { dirname as dirname18, join as join37 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/public-cli/host-pi-runtime.ts
@@ -33562,10 +34551,10 @@ function linkPackage(packageRoot2, name, targetDir) {
 }
 
 // src/public-cli/main.ts
-var here = dirname17(fileURLToPath2(import.meta.url));
+var here = dirname18(fileURLToPath2(import.meta.url));
 function resolvePackageRoot(binDir) {
-  const canonical = join33(binDir, "..", "..");
-  if (existsSync10(join33(canonical, "package.json"))) {
+  const canonical = join37(binDir, "..", "..");
+  if (existsSync11(join37(canonical, "package.json"))) {
     return canonical;
   }
   return binDir;