@akagilnc/pi-workflow-roles 0.1.3565 → 0.1.3621

package/src/pi/role-turn-host.ts

@@ -146,6 +146,18 @@ function buildActivationFlagArgs(activation: RoleTurnActivation): string[] {
       return ["--ak-role", "gatekeeper"];
     case "navigator":
       return ["--ak-role", "navigator"];
+    case "auditor":
+      return ["--ak-role", "auditor"];
+    case "evidence-child":
+      return ["--ak-role", "evidence-child"];
+    case "diarist":
+      return [
+        "--ak-role",
+        "diarist",
+        ...(activation.sourcesPath === undefined
+          ? []
+          : ["--ak-diarist-sources", activation.sourcesPath]),
+      ];
     default: {
       const _exhaustive: never = activation;
       return _exhaustive;
@@ -205,6 +217,8 @@ export type PiSpawnRunner = (
     cwd: string;
     env: NodeJS.ProcessEnv;
     timeoutMs?: number;
+    /** Parent cancellation; the child gets the same graceful SIGTERM as a budget. */
+    signal?: AbortSignal;
   },
 ) => Promise<{
   code: number | null;
@@ -338,9 +352,17 @@ export function createDefaultPiSpawnRunner(options: {
           child.kill("SIGTERM");
         }, spawnOptions.timeoutMs);
       };
+      // Parent cancellation reaches the nested activation: same graceful SIGTERM,
+      // same single close settlement. SIGKILL stays forbidden (#675 / ADR 0010).
+      const parentSignal = spawnOptions.signal;
+      const terminateForParentAbort = (): void => {
+        child.kill("SIGTERM");
+      };
+      parentSignal?.addEventListener("abort", terminateForParentAbort, { once: true });
       let identityRecorded: Promise<void> = Promise.resolve();
       child.once("spawn", () => {
         hasSpawned = true;
+        if (parentSignal?.aborted === true) terminateForParentAbort();
         armTimeoutAfterChildReady();
         const runDirectory = spawnOptions.env.AK_ROLE_RUN_DIR;
         if (
@@ -363,11 +385,13 @@ export function createDefaultPiSpawnRunner(options: {
           return;
         }
         if (timer !== undefined) clearTimeout(timer);
+        parentSignal?.removeEventListener("abort", terminateForParentAbort);
         settled = true;
         reject(error);
       });
       child.on("close", (code) => {
         if (timer !== undefined) clearTimeout(timer);
+        parentSignal?.removeEventListener("abort", terminateForParentAbort);
         void identityRecorded.then(
           () => {
             if (settled) return;
@@ -439,10 +463,27 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
         HOME: request.home,
         PI_CODING_AGENT_DIR: request.agentDir,
         AK_ROLE_RUN_DIR: request.runDirectory,
+        // Nested public summons resolve package root without import.meta under jiti (#675).
+        // Child-process scoped only — not written back onto the parent process.env.
+        AK_ROLE_PACKAGE_ROOT: config.packageRoot,
       };
       if (request.courtAttemptId === undefined) delete env.AK_ROLE_COURT_ATTEMPT;
       else env.AK_ROLE_COURT_ATTEMPT = request.courtAttemptId;
       applyEngineChildEnv(env, request.engine);
+      // Nested auditor dossier tool binds the parent run pointer when published.
+      if (
+        typeof process.env.AK_ROLE_AUDITOR_SOURCE_RUN === "string"
+        && process.env.AK_ROLE_AUDITOR_SOURCE_RUN.trim() !== ""
+      ) {
+        env.AK_ROLE_AUDITOR_SOURCE_RUN = process.env.AK_ROLE_AUDITOR_SOURCE_RUN;
+      }
+      // Audited-subject input selects soul materials (same for nested and direct).
+      if (
+        typeof process.env.AK_ROLE_AUDITOR_SUBJECT === "string"
+        && process.env.AK_ROLE_AUDITOR_SUBJECT.trim() !== ""
+      ) {
+        env.AK_ROLE_AUDITOR_SUBJECT = process.env.AK_ROLE_AUDITOR_SUBJECT;
+      }
       if (request.correlationId !== undefined && request.correlationId.trim() !== "") {
         env.AK_CORRELATION_ID = request.correlationId;
       }
@@ -460,6 +501,7 @@ export function createPiRoleTurnHost(config: PiRoleTurnHostConfig): RoleTurnHost
         cwd: request.cwd,
         env,
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        ...(request.signal === undefined ? {} : { signal: request.signal }),
       });
     },
   };

package/src/public-cli/cli.ts

@@ -51,6 +51,7 @@ import {
   parseCoderArgv,
   parseCollectorArgv,
   parseCountersignArgv,
+  parseDiaristArgv,
   parseGleanerLeftArgv,
   parseDoctorArgv,
   parseFixerArgv,
@@ -59,6 +60,8 @@ import {
   parseInspectorArgv,
   parseMergerArgv,
   parseNavigatorArgv,
+  parseAuditorArgv,
+  parseEvidenceChildArgv,
   parseNotaryArgv,
   parseReviewerArgv,
   recordLaunchedPiIdentity,
@@ -78,6 +81,7 @@ import { runPublicCoder, runPublicCoderResume } from "./coder-run.ts";
 import { runPublicInstructionSeat, runPublicInstructionSeatResume } from "./instruction-seat-run.ts";
 import { runPublicCollector, runPublicCollectorResume } from "./collector-run.ts";
 import { runPublicCountersign, runPublicCountersignResume } from "./countersign-run.ts";
+import { runPublicDiarist, runPublicDiaristResume } from "./diarist-run.ts";
 import { runPublicGleanerLeft, runPublicGleanerLeftResume } from "./gleaner-left-run.ts";
 import { runPublicDoctor, runPublicDoctorResume } from "./doctor-run.ts";
 import { runPublicFixer, runPublicFixerResume } from "./fixer-run.ts";
@@ -126,6 +130,9 @@ const RESUME_SEAT_DISPATCH: Record<
   inspector: { seat: "inspector", run: runPublicInspectorResume },
   gatekeeper: { seat: "gatekeeper", run: runPublicInstructionSeatResume },
   navigator: { seat: "navigator", run: runPublicInstructionSeatResume },
+  auditor: { seat: "auditor", run: runPublicInstructionSeatResume },
+  "evidence-child": { seat: "evidence-child", run: runPublicInstructionSeatResume },
+  diarist: { seat: "diarist", run: runPublicDiaristResume },
 };
 import {
   INTERNAL_ROLE_ENTRYPOINT_RELATIVE,
@@ -168,6 +175,9 @@ export const PUBLIC_ROLE_ARGV = {
   reviewer: { parse: parseReviewerArgv, options: optionsForOwner("reviewer") },
   gatekeeper: { parse: parseGatekeeperArgv, options: optionsForOwner("gatekeeper") },
   navigator: { parse: parseNavigatorArgv, options: optionsForOwner("navigator") },
+  auditor: { parse: parseAuditorArgv, options: optionsForOwner("auditor") },
+  "evidence-child": { parse: parseEvidenceChildArgv, options: optionsForOwner("evidence-child") },
+  diarist: { parse: parseDiaristArgv, options: optionsForOwner("diarist") },
   /** Deterministic analysis seat (#336) — argv parse only; no LLM admission. */
   analyst: { parse: parseAnalystArgv, options: optionsForOwner("analyst") },
 } as const;
@@ -1311,6 +1321,31 @@ export async function runAkRole(
       };
     }
 
+    // Diarist public run path (#708): 起居郎 is summoned like any other seat.
+    if (parsed.command === "diarist") {
+      const agentDir = resolveAgentDir(env, home);
+      const cwd = env.cwd ?? process.cwd();
+      const config = await loadAndValidateConfig(home, env.packageRoot);
+      const credentials =
+        env.credentials ?? (await loadCredentialProviders(agentDir));
+      const seat = resolveEffectiveSeat(
+        config,
+        "diarist",
+        credentials,
+        invocationFromParsed(parsed),
+      );
+      const result = await runPublicDiarist(
+        parsed.args,
+        createRoleEnvironment(env, { role: "diarist", home, agentDir, cwd, credentials, seat, config }),
+        io,
+        PUBLIC_ROLE_ARGV.diarist.parse,
+      );
+      return {
+        exitCode: result.exitCode,
+        ...(result.terminal === undefined ? {} : { terminal: result.terminal }),
+      };
+    }
+
     // Coder public run path with package-owned TDD method (#109).
     if (parsed.command === "coder") {
       const agentDir = resolveAgentDir(env, home);
@@ -1510,9 +1545,13 @@ export async function runAkRole(
       };
     }
 
-    // Gatekeeper/Navigator direct public run paths (#639) — instruction seats,
-    // a role like any other; one parameterized branch for both.
-    if (parsed.command === "gatekeeper" || parsed.command === "navigator") {
+    // Instruction seats (#639 / #675): gatekeeper / navigator / auditor / evidence-child.
+    if (
+      parsed.command === "gatekeeper"
+      || parsed.command === "navigator"
+      || parsed.command === "auditor"
+      || parsed.command === "evidence-child"
+    ) {
       const agentDir = resolveAgentDir(env, home);
       const cwd = env.cwd ?? process.cwd();
       const config = await loadAndValidateConfig(home, env.packageRoot);
@@ -1529,9 +1568,7 @@ export async function runAkRole(
         createRoleEnvironment(env, { role: parsed.command, home, agentDir, cwd, credentials, seat, config }),
         io,
         parsed.command,
-        parsed.command === "gatekeeper"
-          ? PUBLIC_ROLE_ARGV.gatekeeper.parse
-          : PUBLIC_ROLE_ARGV.navigator.parse,
+        PUBLIC_ROLE_ARGV[parsed.command].parse,
       );
       return {
         exitCode: result.exitCode,

package/src/public-cli/countersign-run.ts

@@ -1,20 +1,11 @@
 /**
- * Public Countersign Role run: admit ticket materials → diarist pipeline step →
- * shared post-admission coordinator → settle Terminal result
- * (#572 / ADR 0074 / ADR 0075). #599: manual resume continues the exact session.
- * Diarist is a prior station on the court pipeline, not a countersign call.
- * Unbound admission resolves ticket via shared seat LLM bind (#635) before the diary station.
+ * Public Countersign Role run: admit ticket materials → shared post-admission
+ * coordinator → settle Terminal result (#572 / ADR 0074). #599: manual resume
+ * continues the exact session. Unbound admission resolves its ticket via the
+ * shared seat LLM bind (#635). Who runs 起居郎, and when, is the caller's
+ * composition (ADR 0010 / ADR 0075 `no-call-rule`) — not this seat's business.
  */
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
-import {
-  createDiaristIssueFaceFetcher,
-  DiaristIssueSourceError,
-  resolveDiaristGithubOrigin,
-  runDiarist,
-  type DiaristIssueFace,
-  type DiaristRunResult,
-} from "../diarist.ts";
-import { appendIssueSourceFailureDiagnostic } from "../ticket-provenance.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
@@ -29,7 +20,6 @@ import {
   ticketNumberFromProbe,
   tryResumeSameTicketSeatRun,
 } from "./seat-ticket-binding.ts";
-import { tryHomeFromAkRolesPath } from "../activation-ledger-topology.ts";
 import {
   prepareSummonsResumeMaterials,
   runPostAdmissionOneShot,
@@ -194,7 +184,6 @@ export async function runPublicCountersign(
           turnRequest,
           buildCountersignTurnRequest(admitted, turnProjection),
         );
-        await runCountersignDiaristStation(admitted, env);
       },
     }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
@@ -222,10 +211,9 @@ function countersignAdapters(options?: {
 
 /**
  * Resume a previously admitted Countersign run (#599 / DK-3 / #637).
- * Restores role/ticket/session identity. Every court re-entry runs the diarist
- * station first (ADR 0075 refresh-every-court). Same-ticket summons deliver this
- * turn's instruction + frozen attachments on the resume prompt; manual resume
- * keeps package-envelope / caller-message semantics and birth attachments.
+ * Restores role/ticket/session identity. Same-ticket summons deliver this turn's
+ * instruction + frozen attachments on the resume prompt; manual resume keeps
+ * package-envelope / caller-message semantics and birth attachments.
  */
 export async function runPublicCountersignResume(
   request: PublicResumeRequest,
@@ -261,115 +249,7 @@ export async function runPublicCountersignResume(
         ),
       );
     },
-    adapters: countersignAdapters({
-      beforeDispatch: async (admitted) => {
-        await runCountersignDiaristStation(admitted, env);
-      },
-    }),
+    adapters: countersignAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }
-
-/**
- * Court-pipeline prior station: refresh ticket-provenance before countersign turn.
- * Caller-invisible — collector failures append durable volume diagnostics and the
- * station continues; issue-source / ADR source-read / watermark honesty failures
- * leave typed durable diagnostics and propagate (失败诚实).
- * Missing ticketNumber (true-unbound after pre-court resolution) skips the station
- * — no diary is minted for a true-unbound run.
- *
- * Issue body/comments come from the shared GitHub seam only. Attachments stay
- * attachments — never merged and mislabeled as issue-body-comment.
- * Bound ticket never silently degrades to “no issue face”.
- */
-export async function runCountersignDiaristStation(
-  admitted: AdmittedCountersignInvocation,
-  env: Pick<CountersignRunEnv, "cwd" | "packageRoot">,
-): Promise<DiaristRunResult | undefined> {
-  if (admitted.ticketNumber === undefined) return undefined;
-
-  const issueFace = await loadBoundIssueFace(admitted);
-  const home = tryHomeFromAkRolesPath(admitted.runDirectory);
-
-  const result = await runDiarist({
-    ticketNumber: admitted.ticketNumber,
-    cwd: admitted.projectRoot,
-    ...(home === undefined ? {} : { home }),
-    issueFace,
-    sessionCwds: [admitted.projectRoot, env.cwd],
-    ...(env.packageRoot === undefined ? {} : { packageRoot: env.packageRoot }),
-  });
-  return result;
-}
-
-/**
- * Acquire issue face for a bound ticket. Failures are typed + durable on the
- * ticket-provenance volume, then propagated — never washed into empty face.
- */
-function persistIssueSourceFailure(
-  admitted: AdmittedCountersignInvocation,
-  ticketNumber: number,
-  error: DiaristIssueSourceError,
-): never {
-  const home = tryHomeFromAkRolesPath(admitted.runDirectory);
-  appendIssueSourceFailureDiagnostic({
-    ticketNumber,
-    cwd: admitted.projectRoot,
-    ...(home === undefined ? {} : { home }),
-    cause: error.message,
-    reason: error.reason,
-  });
-  throw error;
-}
-
-async function loadBoundIssueFace(
-  admitted: AdmittedCountersignInvocation,
-): Promise<DiaristIssueFace> {
-  const ticketNumber = admitted.ticketNumber;
-  if (ticketNumber === undefined) {
-    throw new Error("loadBoundIssueFace requires a bound ticketNumber");
-  }
-
-  const origin = resolveDiaristGithubOrigin(admitted.projectRoot);
-  if (origin === undefined) {
-    persistIssueSourceFailure(
-      admitted,
-      ticketNumber,
-      new DiaristIssueSourceError(
-        "origin-unresolved",
-        `bound ticket #${ticketNumber} issue face requires a resolvable github.com origin remote`,
-      ),
-    );
-  }
-
-  const fetcher = createDiaristIssueFaceFetcher();
-  let face: DiaristIssueFace | undefined;
-  try {
-    face = await fetcher({
-      owner: origin.owner,
-      repo: origin.repo,
-      ticketNumber,
-    });
-  } catch (error) {
-    const typed =
-      error instanceof DiaristIssueSourceError
-        ? error
-        : new DiaristIssueSourceError(
-            "issue-unavailable",
-            `issue face fetch failed for ${origin.owner}/${origin.repo}#${ticketNumber}`,
-            { cause: error },
-          );
-    persistIssueSourceFailure(admitted, ticketNumber, typed);
-  }
-  if (face === undefined) {
-    persistIssueSourceFailure(
-      admitted,
-      ticketNumber,
-      new DiaristIssueSourceError(
-        "issue-unavailable",
-        `issue face unavailable for ${origin.owner}/${origin.repo}#${ticketNumber}`,
-      ),
-    );
-  }
-  return face;
-}

package/src/public-cli/diarist-run.ts

@@ -0,0 +1,312 @@
+/**
+ * Public Diarist (起居郎) Role run — #708 / ADR 0075 `diarist-is-role`.
+ * Same admit → post-admission → settle shape as the other instruction seats.
+ * Semantic collection is the role's own turn; this seat only freezes the
+ * mechanical source catalog the turn selects from (`diarist-collector-is-own-turn`).
+ * Who calls it and in what order is the caller's business (ADR 0010 `no-call-rule`).
+ */
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
+import {
+  loadDiaristIssueFace,
+  prepareDiaristSourceCatalog,
+  serializeDiaristSourceCatalog,
+} from "../diarist.ts";
+import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
+import { CliUsageError } from "./cli-errors.ts";
+import {
+  admitDiaristInvocation,
+  buildInstructionTransportPrompt,
+  type AdmittedDiaristInvocation,
+  type ParseDiaristArgvResult,
+} from "./invocation.ts";
+import {
+  applyInstructionTicketProbe,
+  probeInstructionTicket,
+  ticketNumberFromProbe,
+  tryResumeSameTicketSeatRun,
+} from "./seat-ticket-binding.ts";
+import {
+  prepareSummonsResumeMaterials,
+  runPostAdmissionOneShot,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
+  type PostAdmissionAdapters,
+  type PostAdmissionEnv,
+} from "./post-admission.ts";
+import {
+  loadResumableDiaristRun,
+  markRunAdmitted,
+  readRoleRunIdentity,
+  type PublicResumeRequest,
+  type SameTicketSummonsMaterials,
+} from "./run-lifecycle.ts";
+import {
+  presentStructuralRejection,
+  trySettleDiaristTerminalResult,
+} from "./settlement.ts";
+import type { CliIo } from "./cli-io.ts";
+import type { TerminalResult } from "./terminal.ts";
+import {
+  projectRoleTurnRequest,
+  type RoleTurnRequestProjectionOptions,
+} from "./turn-request.ts";
+
+export type DiaristRunEnv = PostAdmissionEnv & {
+  principalAuthority: DurablePrincipalAuthority;
+  createRunId?: () => string;
+};
+
+/** Frozen catalog filename inside the run dossier (durable material, not argv). */
+const DIARIST_SOURCE_CATALOG_FILE = "diarist-sources.json" as const;
+
+/** Neutral path identifier only (ADR 0073) — catalog bytes stay on disk. */
+function withDiaristCatalogPath(
+  prompt: string,
+  sourcesPath: string | undefined,
+): string {
+  if (sourcesPath === undefined || sourcesPath.trim() === "") return prompt;
+  return `${prompt}\n\n已冻结来源文件（路径）：\n- ${sourcesPath}`;
+}
+
+/** Project admitted invocation onto the host-neutral turn request. */
+export function buildDiaristTurnRequest(
+  admitted: AdmittedDiaristInvocation,
+  options: RoleTurnRequestProjectionOptions,
+  sourcesPath?: string,
+): RoleTurnRequest {
+  const continuation =
+    sourcesPath === undefined
+      ? options.continuation
+      : {
+          ...options.continuation,
+          prompt: withDiaristCatalogPath(options.continuation.prompt, sourcesPath),
+        };
+  return projectRoleTurnRequest(
+    admitted,
+    {
+      activation: {
+        role: "diarist" as const,
+        ...(sourcesPath === undefined ? {} : { sourcesPath }),
+      },
+    },
+    { ...options, continuation },
+  );
+}
+
+/**
+ * Mechanical source enumeration for a bound summons: establish the per-ticket
+ * volume, freeze this turn's candidate catalog into the run dossier.
+ * A true-unbound summons has no ticket, so no diary is minted — undefined.
+ *
+ * A run that has not settled yet (crash-resume, open-court continuation) keeps
+ * the catalog its candidateIndexes were minted against — re-enumerating there
+ * would rebind the role's indexes to bytes it never saw. Only a settled run
+ * re-enumerates on the next same-ticket summons (ADR 0075 增量).
+ */
+async function freezeDiaristSourceCatalog(
+  admitted: AdmittedDiaristInvocation,
+  env: Pick<DiaristRunEnv, "cwd" | "home">,
+): Promise<string | undefined> {
+  if (admitted.ticketNumber === undefined) return undefined;
+  const path = join(admitted.runDirectory, DIARIST_SOURCE_CATALOG_FILE);
+  if (existsSync(path)) {
+    const identity = await readRoleRunIdentity(admitted.runDirectory);
+    if (identity !== undefined && identity.state !== "terminal") return path;
+  }
+  const issueFace = await loadDiaristIssueFace({
+    ticketNumber: admitted.ticketNumber,
+    projectRoot: admitted.projectRoot,
+    home: env.home,
+  });
+  const catalog = await prepareDiaristSourceCatalog({
+    ticketNumber: admitted.ticketNumber,
+    cwd: admitted.projectRoot,
+    home: env.home,
+    issueFace,
+    sessionCwds: [admitted.projectRoot, env.cwd],
+  });
+  await writeFile(path, serializeDiaristSourceCatalog(catalog), "utf8");
+  return path;
+}
+
+function diaristAdapters(options?: {
+  beforeDispatch?: (
+    admitted: AdmittedDiaristInvocation,
+  ) => void | Promise<void>;
+}): PostAdmissionAdapters<AdmittedDiaristInvocation> {
+  return {
+    trySettle: (admitted, authority, scope) =>
+      trySettleDiaristTerminalResult(admitted, authority, scope),
+    shouldPresentSettled: () => true,
+    ...(options?.beforeDispatch === undefined
+      ? {}
+      : { beforeDispatch: options.beforeDispatch }),
+  };
+}
+
+export async function runPublicDiarist(
+  argv: readonly string[],
+  env: DiaristRunEnv,
+  io: CliIo,
+  parseDiaristArgv: (args: readonly string[]) => ParseDiaristArgvResult,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedDiaristInvocation;
+  terminal?: TerminalResult;
+}> {
+  let parsed: ParseDiaristArgvResult;
+  try {
+    parsed = parseDiaristArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // #637: same ticket → resume this seat's prior run with this summons' materials.
+  // Probe captures DiaristTicketResolutionError so admit+beforeDispatch can settle
+  // controlled failure (bare pre-admit throw skips terminal settlement).
+  const projectRoot = parsed.project ?? env.cwd;
+  const ticketProbe = await probeInstructionTicket(
+    parsed.instruction,
+    projectRoot,
+    env,
+  );
+  const probedTicketNumber = ticketNumberFromProbe(ticketProbe);
+  if (probedTicketNumber !== undefined) {
+    const summons: SameTicketSummonsMaterials = {
+      instruction: parsed.instruction,
+      instructionEmpty: parsed.instruction.trim() === "",
+      attachmentPaths: parsed.attachmentPaths,
+    };
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role: "diarist",
+      ticketNumber: probedTicketNumber,
+      freshSummons: env.freshSummons,
+      summons,
+      resume: (runId, materials) =>
+        runPublicDiaristResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+    });
+    if (resumed !== undefined) return resumed;
+  }
+
+  let admitted: AdmittedDiaristInvocation;
+  try {
+    admitted = await admitDiaristInvocation({
+      home: env.home,
+      principalAuthority: env.principalAuthority,
+      cwd: env.cwd,
+      instruction: parsed.instruction,
+      attachmentPaths: parsed.attachmentPaths,
+      ...(parsed.project === undefined ? {} : { project: parsed.project }),
+      ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
+      ...(env.model === undefined ? {} : { model: env.model }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
+    });
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  await markRunAdmitted(admitted, env.principalAuthority);
+
+  const turnProjection: RoleTurnRequestProjectionOptions = {
+    packageRoot: env.packageRoot,
+    home: env.home,
+    agentDir: env.agentDir,
+    ...(env.model === undefined ? {} : { model: env.model }),
+    ...(env.engine === undefined ? {} : { engine: env.engine }),
+    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+    ...(env.correlationId === undefined || env.correlationId.trim() === ""
+      ? {}
+      : { correlationId: env.correlationId }),
+    continuation: {
+      kind: "initial",
+      prompt: buildInstructionTransportPrompt(
+        admitted,
+        engineSessionMaterialFromOptions({
+          ...(env.engine === undefined ? {} : { engine: env.engine }),
+          packageRoot: env.packageRoot,
+        }),
+      ),
+    },
+  };
+  // Mutable shell: ticket bind + catalog freeze re-project activation before executeTurn.
+  const turnRequest = buildDiaristTurnRequest(admitted, turnProjection);
+
+  return await runPostAdmissionOneShot({
+    admitted,
+    env,
+    io,
+    request: turnRequest,
+    adapters: diaristAdapters({
+      beforeDispatch: async (admittedSeat) => {
+        await applyInstructionTicketProbe(admittedSeat, ticketProbe);
+        const sourcesPath = await freezeDiaristSourceCatalog(admittedSeat, env);
+        Object.assign(
+          turnRequest,
+          buildDiaristTurnRequest(admittedSeat, turnProjection, sourcesPath),
+        );
+      },
+    }),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}
+
+/**
+ * Resume a previously admitted Diarist run (#708 / ADR 0079 同票传召 = resume).
+ * A re-entry into a settled run re-enumerates fresh sources; the offered
+ * watermark keeps the pass incremental so already-seen blocks are not
+ * re-offered. An unfinished run keeps its frozen catalog (see freeze above).
+ */
+export async function runPublicDiaristResume(
+  request: PublicResumeRequest,
+  env: DiaristRunEnv,
+  io: CliIo,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedDiaristInvocation;
+  terminal?: TerminalResult;
+}> {
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: (effective) =>
+      loadResumableDiaristRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: async (admitted, effective) => {
+      const summonsPrepared = await prepareSummonsResumeMaterials(
+        admitted.runDirectory,
+        effective.summons,
+      );
+      const sourcesPath = await freezeDiaristSourceCatalog(admitted, env);
+      return buildDiaristTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(
+          admitted,
+          effective,
+          env,
+          summonsPrepared,
+        ),
+        sourcesPath,
+      );
+    },
+    adapters: diaristAdapters(),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}