@akagilnc/pi-workflow-roles 0.1.4062 → 0.1.4196

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";
   }
 });
@@ -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)) {
@@ -16065,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);
 }
@@ -16192,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) {
@@ -16281,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);
 }
@@ -16289,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 = [];
@@ -16354,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];
@@ -16396,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();
@@ -16441,7 +16639,7 @@ function piUserDialogueBody(request) {
 }
 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);
@@ -16633,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);
@@ -16683,48 +16881,12 @@ 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) {
-  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;
-  }
-  return void 0;
-}
-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;
-    }
-    return ticketFromRecord(raw);
-  } catch (error) {
-    if (isEnoent(error)) return void 0;
-    throw error;
-  }
-}
-async function readRunTicketNumber(runDirectory) {
-  return await readPageTicketNumber(runDirectory, "admitted-request.json") ?? await readPageTicketNumber(runDirectory, "invocation.json");
-}
-var init_run_ticket_number = __esm({
-  "src/run-ticket-number.ts"() {
-    "use strict";
-  }
-});
-
-// src/sha256.ts
-import { createHash as createHash2 } from "node:crypto";
-function sha256Hex(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
-}
-var init_sha256 = __esm({
-  "src/sha256.ts"() {
+// src/auditor-dossier-tool.ts
+var init_auditor_dossier_tool = __esm({
+  "src/auditor-dossier-tool.ts"() {
     "use strict";
+    init_role_run_placement();
+    init_build();
   }
 });
 
@@ -16754,6 +16916,402 @@ var init_submission_errors = __esm({
   }
 });
 
+// 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 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 value;
+}
+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;
+      }
+    }
+  }
+  if (best === void 0) return value;
+  return rewriteRunDirectoryPathValue(
+    value,
+    best.oldRunDirectory,
+    best.newRunDirectory
+  );
+}
+function rewriteRunDirectoryPathFields(record4, fields, oldRunDirectory, newRunDirectory) {
+  rewriteRunDirectoryPathFieldsAgainstRewrites(record4, fields, [
+    { oldRunDirectory, newRunDirectory }
+  ]);
+}
+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"];
+  }
+});
+
+// src/sha256.ts
+import { createHash as createHash2 } from "node:crypto";
+function sha256Hex(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+var init_sha256 = __esm({
+  "src/sha256.ts"() {
+    "use strict";
+  }
+});
+
 // src/submission-correctable-error.ts
 var correctableSubmissionErrorBrand, CorrectableSubmissionError;
 var init_submission_correctable_error = __esm({
@@ -16844,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);
@@ -16872,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;
@@ -16954,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 });
@@ -16973,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);
@@ -16990,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 });
 }
@@ -17033,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);
   }
@@ -17137,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"));
@@ -17210,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(
@@ -17424,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 });
@@ -17491,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");
@@ -17546,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 {
@@ -17564,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;
@@ -17593,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");
@@ -17623,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"
@@ -17674,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;
@@ -17741,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"
@@ -17909,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) {
@@ -17927,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) {
@@ -17954,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);
         }
       }
     }
@@ -17986,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) {
@@ -18006,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") {
@@ -18014,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;
@@ -18043,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;
@@ -18078,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;
@@ -18096,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) {
@@ -18176,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;
@@ -18189,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;
@@ -18289,6 +18932,7 @@ async function loadResumableRunRecord(home, runId, authority) {
           };
         }
       }
+      admittedIdentityRecord = record4;
       const fromAdmitted = parsePersistedTicketIdentity(record4);
       correlationId = fromAdmitted.correlationId;
       ticketNumber = fromAdmitted.ticketNumber;
@@ -18303,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,
@@ -18321,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}`,
@@ -18328,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,
@@ -18347,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 },
@@ -18494,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);
 }
@@ -18683,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"];
@@ -18714,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;
@@ -18733,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}`,
@@ -18760,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"
     );
@@ -19483,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"
         }
       }
     ];
@@ -19919,6 +20587,7 @@ __export(invocation_exports, {
   admitNotaryInvocation: () => admitNotaryInvocation,
   admitReviewerInvocation: () => admitReviewerInvocation,
   bindAdmittedTicketNumber: () => bindAdmittedTicketNumber,
+  bindCourtTicketNumbersOnAdmitted: () => bindCourtTicketNumbersOnAdmitted,
   bindTicketNumberOnRunDirectory: () => bindTicketNumberOnRunDirectory,
   buildCoderTransportPrompt: () => buildCoderTransportPrompt,
   buildCollectorTransportPrompt: () => buildCollectorTransportPrompt,
@@ -19963,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
   };
@@ -19999,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)}
 `,
@@ -20027,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;
@@ -20060,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)}
 `,
@@ -20068,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,
@@ -20085,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)}
 `,
@@ -20100,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;
@@ -20136,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(
@@ -20146,7 +20886,7 @@ async function bindTicketNumberOnRunDirectory(runDirectory, ticketNumber) {
       );
     }
   }
-  await writeFile4(
+  await writeFile5(
     admittedPath,
     `${JSON.stringify({ ...admitted, ticketNumber }, null, 2)}
 `,
@@ -20163,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(
@@ -20404,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}`,
@@ -20419,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,
@@ -20449,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;
@@ -20498,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
@@ -20521,7 +21268,8 @@ async function admitStandardMaterialInvocation(role, options) {
     runDirectory,
     principal,
     admittedRequestPath,
-    ...correlationFields
+    ...correlationFields,
+    ...ticketFields
   };
 }
 async function admitJudgeInvocation(options) {
@@ -20563,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() === "";
@@ -20602,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
@@ -20628,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;
@@ -20646,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) {
@@ -20663,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,
@@ -20703,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
@@ -20751,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}`,
@@ -20769,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,
@@ -20824,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
@@ -20994,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 {
@@ -21023,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() === "";
@@ -21045,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",
@@ -21071,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
@@ -21169,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"
   );
@@ -21187,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"
@@ -21203,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) {
@@ -21226,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;
@@ -21276,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() === "";
@@ -21302,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
@@ -21387,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({
@@ -21401,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,
@@ -21434,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
@@ -21505,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 = {
@@ -21536,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
@@ -21626,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() === "";
@@ -21666,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
@@ -21765,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)
@@ -21776,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;
@@ -21812,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)}
 `,
@@ -21843,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
@@ -21897,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}`
@@ -22101,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();
@@ -22117,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;
@@ -22147,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;
@@ -22283,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");
@@ -22301,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);
@@ -22398,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);
   }
@@ -22416,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);
     }
@@ -22435,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);
   }
@@ -22513,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) {
@@ -22725,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);
 }
@@ -22941,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: readFile24 } = await import("node:fs/promises");
+  const { readFile: readFile25 } = await import("node:fs/promises");
   let raw;
   try {
-    raw = JSON.parse(await readFile24(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)}`,
@@ -22967,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();
@@ -22976,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;
@@ -23027,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) {
@@ -23059,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,
@@ -23096,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;
@@ -23119,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;
   }
@@ -23135,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") {
@@ -23149,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",
@@ -23163,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) {
@@ -23200,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;
@@ -23312,13 +24040,17 @@ function mapOwnedToSubmissionRows(owned) {
 }
 async function readRecordedSubmissionRows(cwd, runId, homeOrScope) {
   const scope = resolveReadScope(homeOrScope);
-  const { owned } = await readOwnedSubmissionRecords(cwd, runId, scope.home);
+  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);
+  const { owned } = await readOwnedSubmissionRecords(
+    cwd,
+    runId,
+    home === void 0 ? {} : { home }
+  );
   return mapOwnedToSubmissionRows(owned.filter((record4) => recordAttemptId(record4) === attemptId));
 }
 async function readRecordedSubmissions(cwd, runId, homeOrScope) {
@@ -23332,30 +24064,31 @@ var init_submission_ledger = __esm({
     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 = [];
@@ -23597,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 {
@@ -23618,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;
@@ -23975,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 }
   };
 }
@@ -24022,7 +24756,7 @@ async function attemptProducedFreshSubmission(admitted, scope) {
     admitted.projectRoot,
     admitted.runId,
     scope.courtAttemptId,
-    sealedLedgerHome(admitted)
+    ledgerReadScope(admitted, scope)
   );
 }
 async function recordedSubmissionPayloads(admitted, scope) {
@@ -24117,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)
@@ -24320,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) {
@@ -24349,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 {
@@ -24410,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) {
@@ -24436,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");
     }
@@ -24471,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;
@@ -24502,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");
       }
@@ -24675,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",
@@ -25022,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
   });
@@ -25104,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",
@@ -25121,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(
       {
@@ -25137,7 +25871,7 @@ async function publishJudgeArtifacts(admitted, roleOutcome, coordinates) {
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25166,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(
       {
@@ -25183,7 +25917,7 @@ async function publishCoderArtifacts(admitted, roleOutcome, coordinates, options
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25217,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");
   }
 }
@@ -25304,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(
       {
@@ -25321,7 +26055,7 @@ async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25392,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(
       {
@@ -25408,7 +26142,7 @@ async function publishCollectorArtifacts(admitted, roleOutcome, coordinates) {
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25510,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(
       {
@@ -25528,7 +26262,7 @@ async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, option
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25766,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(
       {
@@ -25782,7 +26516,7 @@ async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, opti
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25871,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(
       {
@@ -25887,7 +26621,7 @@ async function publishMergerArtifacts(admitted, roleOutcome, coordinates, option
 `,
     "utf8"
   );
-  await writeFile5(
+  await writeFile6(
     evidencePath,
     `${JSON.stringify(
       {
@@ -25991,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 };
@@ -26013,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)}
 `,
@@ -26058,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",
@@ -26272,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([
@@ -26327,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");
         }
@@ -26349,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);
     }
   };
 }
@@ -26386,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);
@@ -26404,21 +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 readFile18, rm, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdtemp, readFile as readFile19, rm, writeFile as writeFile8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join27 } from "node:path";
 function describeDossierFile(path) {
   return path;
 }
@@ -26444,10 +27180,10 @@ async function deliverCaseDossierAsAttachment(input) {
     home: input.home
   });
   if (section === void 0) return void 0;
-  const stagingDir = await mkdtemp(join24(tmpdir(), "ak-case-dossier-"));
+  const stagingDir = await mkdtemp(join27(tmpdir(), "ak-case-dossier-"));
   try {
-    const stagingPath = join24(stagingDir, CASE_DOSSIER_ATTACH_FILE);
-    await writeFile7(stagingPath, `${section}
+    const stagingPath = join27(stagingDir, CASE_DOSSIER_ATTACH_FILE);
+    await writeFile8(stagingPath, `${section}
 `, "utf8");
     return await freezeAttachmentsIntoRun(
       [stagingPath],
@@ -26471,9 +27207,9 @@ var init_case_dossier_delivery = __esm({
 });
 
 // src/host-transition-prior-native.ts
-import { access as access3, readdir as readdir6 } from "node:fs/promises";
-import { dirname as dirname13, join as join25 } 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) {
@@ -26481,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 = join25(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();
@@ -26566,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 join26 } 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);
@@ -26602,24 +27338,21 @@ async function finalizeExceptionRunBestEffort(runDirectory, io) {
     );
   }
 }
-function runArtifactsDirectory(runDirectory) {
-  return join26(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");
     }
@@ -26649,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) {
@@ -26685,7 +27418,7 @@ function jsonSafeReplacer() {
   };
 }
 async function writeHardenedArtifactFile(artifactsDir, namePrefix, payload) {
-  const filePath = join26(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;
@@ -26934,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();
@@ -26956,8 +27690,8 @@ var init_auto_resume = __esm({
 
 // src/public-cli/post-admission.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readFile as readFile19, writeFile as writeFile8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute8, join as join27, 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;
@@ -26980,9 +27714,9 @@ function withOnceSuccessfulBeforeDispatch(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;
     }
   };
@@ -27001,8 +27735,8 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
   } catch (appendError) {
     try {
       const artifactsDir = await ensureRealArtifactsDirectory(admitted.runDirectory);
-      await writeFile8(
-        join27(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" }
@@ -27018,7 +27752,7 @@ async function recordBestEffortPostDispatchDiagnostic(admitted, env, diagnostic,
 }
 async function readInvocationHost(runDirectory) {
   try {
-    const raw = JSON.parse(await readFile19(join27(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;
@@ -27136,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,
@@ -27187,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,
@@ -27262,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 writeFile8(
-        join27(admitted.runDirectory, "stderr.log"),
+      await writeFile9(
+        join30(admitted.runDirectory, "stderr.log"),
         result2.stderr,
         "utf8"
       );
@@ -27341,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) {
@@ -27362,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);
@@ -27392,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(
@@ -27408,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,
@@ -27433,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();
@@ -27513,8 +28285,8 @@ async function dispatchAfterWriterLease(input) {
   }
 }
 function isAlreadyFrozenSummonsAttachment(runDirectory, attachmentPath) {
-  const absolute = isAbsolute8(attachmentPath) ? attachmentPath : resolve9(attachmentPath);
-  return pathContainedIn(join27(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;
@@ -28163,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)),
@@ -28211,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) {
@@ -28253,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 }
       });
     }
@@ -28983,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) {
@@ -29034,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) {
@@ -29044,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,
@@ -29072,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) {
@@ -29108,7 +29878,7 @@ async function runPublicDiaristResume(request, env, io) {
         )
       );
     },
-    adapters: diaristAdapters(),
+    adapters: diaristAdapters(env),
     ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
@@ -29135,8 +29905,8 @@ __export(public_role_summons_exports, {
   summonGateOfficer: () => summonGateOfficer,
   summonPublicRole: () => summonPublicRole
 });
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join31 } from "node:path";
 function createCapturingIo() {
   const chunks = [];
   return {
@@ -29159,7 +29929,7 @@ function parentDir(path) {
 function walkPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 12; i += 1) {
-    if (existsSync9(join28(dir, "package.json")) && existsSync9(join28(dir, "souls"))) {
+    if (existsSync10(join31(dir, "package.json")) && existsSync10(join31(dir, "souls"))) {
       return dir;
     }
     const parent = parentDir(dir);
@@ -29253,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 ?? join28(home, ".pi", "agent");
+  const agentDir = options.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join31(home, ".pi", "agent");
   const {
     loadCredentialProviders: loadCredentialProviders2,
     loadPublicCliConfig: loadPublicCliConfig2,
@@ -29469,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;
@@ -29519,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 {
@@ -29534,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) {
@@ -29587,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(
@@ -29630,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() === "",
@@ -29644,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
           );
         }
@@ -29660,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,
@@ -29680,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)
@@ -29701,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 {
@@ -29737,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);
       }
     }),
@@ -29748,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();
@@ -30403,14 +31263,14 @@ var init_analyst_book_key = __esm({
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { rename as rename2, rm as rm2, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname14, join as join29 } 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 = join29(parent, `.atomic-write-${randomUUID6()}.tmp`);
+  const parent = dirname15(destination);
+  const temporary = join32(parent, `.atomic-write-${randomUUID6()}.tmp`);
   try {
-    await writeFile9(temporary, contents);
-    await rename2(temporary, destination);
+    await writeFile10(temporary, contents);
+    await rename3(temporary, destination);
   } catch (error) {
     await rm2(temporary, { force: true }).catch(() => void 0);
     throw error;
@@ -30423,17 +31283,17 @@ var init_atomic_write = __esm({
 });
 
 // src/analyst-index.ts
-import { open as open3, readFile as readFile20, unlink as unlink4 } from "node:fs/promises";
-import { dirname as dirname15, join as join30 } 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 = join30(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) {
@@ -30460,7 +31320,7 @@ async function withAnalystLibraryIndexLock(ledgerHome, fn) {
   }
 }
 function analystLibraryIndexPath(ledgerHome) {
-  return join30(ledgerHome, "analyst", "library-index.json");
+  return join33(ledgerHome, "analyst", "library-index.json");
 }
 function rowFromIssueMetricsPage(page) {
   return {
@@ -30551,7 +31411,7 @@ async function readAnalystLibraryIndexPage(ledgerHome) {
   const path = analystLibraryIndexPath(ledgerHome);
   let raw;
   try {
-    raw = await readFile20(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;
@@ -30569,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)}
 `);
@@ -30755,9 +31615,9 @@ var init_analyst_cohort = __esm({
 });
 
 // src/analyst-ledger.ts
-import { readdir as readdir7, readFile as readFile21 } from "node:fs/promises";
-import { join as join31 } 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) {
@@ -30769,7 +31629,7 @@ function isRecord10(value) {
 async function readExistingRunLifecycleState(runDirectory) {
   try {
     const raw = JSON.parse(
-      await readFile21(join31(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;
@@ -30791,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 readFile21(join31(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);
@@ -30812,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 };
 }
@@ -30833,15 +31694,15 @@ function decideIssueScope(input) {
 }
 async function resolveSessionFile(runDirectory) {
   try {
-    const raw = await readFile21(join31(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 join31(runDirectory, "session", "session.jsonl");
+  return join34(runDirectory, "session", "session.jsonl");
 }
 function attributeSessionRowsForRun(input) {
   if (pathContainedIn(input.runDirectory, input.sessionFile)) {
@@ -31013,9 +31874,9 @@ async function classifyScopedRun(input) {
   }
   let gateCycles;
   try {
-    const parentSessionFile = join31(input.runDirectory, "session", "session.jsonl");
+    const parentSessionFile = join34(input.runDirectory, "session", "session.jsonl");
     gateCycles = await readAnalystGateCyclesFromAuditorRoles(
-      join31(input.runDirectory, "session", "auditor-roles"),
+      join34(input.runDirectory, "session", "auditor-roles"),
       { parentSessionFile }
     );
   } catch (error) {
@@ -31048,7 +31909,7 @@ async function classifyScopedRun(input) {
 async function scanAnalystIssueRuns(input) {
   const ledgerHome = resolveActivationLedgerHome(input.home);
   const scopeTicketNumber = input.ticketNumber;
-  const booksRoot = join31(ledgerHome, "books");
+  const booksRoot = join34(ledgerHome, "books");
   let wholeBook = false;
   let scopeRootIdentity;
   let bookNames;
@@ -31080,19 +31941,18 @@ async function scanAnalystIssueRuns(input) {
   const unreadable = [];
   const scopeConflicts = [];
   for (const book of bookNames) {
-    const runsDir = join31(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 = join31(runsDir, runName);
       let scopeFields;
       try {
         scopeFields = await readInvocationScopeFields(runDirectory);
@@ -31132,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();
@@ -31946,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 join32 } 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) {
@@ -31957,7 +32819,7 @@ function analystIssuePageKey(address) {
   return createHash5("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
 }
 function analystIssuePagePath(ledgerHome, address) {
-  return join32(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
+  return join35(ledgerHome, "analyst", "issues", `${analystIssuePageKey(address)}.json`);
 }
 function analystIssuePageAddressFromPage(page) {
   return {
@@ -32076,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)}
 `);
@@ -32093,8 +32955,8 @@ var init_analyst_page = __esm({
 });
 
 // src/analyst-entry.ts
-import { readFile as readFile22 } 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) {
@@ -32123,13 +32985,13 @@ async function readOrComputeAnalystIssuePage(input, options) {
     ...issueNumber === void 0 && input.bookKey === void 0 ? { scopeRootIdentity: projectRoot } : {}
   });
   try {
-    const raw = await readFile22(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,
@@ -32218,10 +33080,10 @@ async function runAnalystModelGroupsMode(input, home) {
       scopeRootIdentity: projectRoot
     });
     try {
-      const raw = await readFile22(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 {
@@ -32317,8 +33179,8 @@ var init_analyst_entry = __esm({
 });
 
 // src/public-cli/analyst-run.ts
-import { readFile as readFile23 } 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);
@@ -32367,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 readFile23(absolute);
+    bytes = await readFile24(absolute);
   } catch (error) {
     throw new CliUsageError(
       `analyst sweep attachment is not a readable regular file: ${sourcePath}`,
@@ -32490,7 +33352,7 @@ __export(cli_exports, {
   runAkRole: () => runAkRole
 });
 import { realpath as realpath6 } from "node:fs/promises";
-import { join as join33 } 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);
@@ -32587,7 +33449,7 @@ function resolveHome(env) {
   return env.home ?? packageMachineHome();
 }
 function resolveAgentDir(env, home) {
-  return env.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join33(home, ".pi", "agent");
+  return env.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? join36(home, ".pi", "agent");
 }
 function parseThinking(value) {
   return value;
@@ -33601,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 join34 } 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
@@ -33689,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 = join34(binDir, "..", "..");
-  if (existsSync10(join34(canonical, "package.json"))) {
+  const canonical = join37(binDir, "..", "..");
+  if (existsSync11(join37(canonical, "package.json"))) {
     return canonical;
   }
   return binDir;