@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

package/src/public-cli/instruction-seat-run.ts

@@ -1,202 +1,212 @@
 /**
- * Shared instruction-seat run (#639 / #675 / #637): gatekeeper, navigator, auditor
- * share admit → turn-request → post-admission → settle.
- * Auditor same-parent (--source-run) re-summons resume via tryResumeSameTicketSeatRun
- * (#747); other instruction seats keep ticket-number principal — no independent
- * run/rebind/nest path. (#744: evidence-child public seat deleted.)
+ * One public role run: admit → turn request → post-admission → settle.
+ * Seat differences are composition-root fields. An omitted reviewer lens
+ * starts two ordinary single-axis runs here. Countersign keeps deferred
+ * identity on this entry; the court diarist station stays in countersign-run.
  */
+import { resolve } from "node:path";
+
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
+import { isSafePositiveTicketNumber, readBoardTicketNumber } from "../run-ticket-number.ts";
+import { NotarySourceRunError, resolveNotarySourceRunLocator } from "../notary-source-run.ts";
 import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.ts";
-import { readBoardTicketNumber } from "../run-ticket-number.ts";
+import {
+  loadPackagedMethodSkillMaterial,
+  type PackagedMethodSkillMaterial,
+} from "../package-resources/method-skill.ts";
+import type { PackagedRole } from "../packaged-role-registry.ts";
+import {
+  packagedAdmitsCountersign,
+  packagedBindsBoardTicket,
+  packagedMethodLoadFailureCause,
+  packagedRebindSourceOnResume,
+  packagedRoleMetadata,
+} from "../packaged-role-registry.ts";
+import { isAuditorSoulRole } from "../auditor-soul.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
-  admitAuditorInvocation,
-  admitGatekeeperInvocation,
-  admitNavigatorInvocation,
+  admitPublicRole,
+  bindAdmittedTicketNumber,
+  bindCourtTicketNumbersOnAdmitted,
   buildInstructionTransportPrompt,
+  materializeCountersignInvocation,
   persistAdmittedSourceRunPath,
-  type AdmittedAuditorInvocation,
-  type AdmittedGatekeeperInvocation,
-  type AdmittedNavigatorInvocation,
-  type ParseInstructionArgvResult,
+  recordAdmittedCorrelation,
+  relocateAdmittedRunToTicket,
+  withPreparedAttachments,
+  type AdmittedCountersignInvocation,
+  type AdmittedRoleInvocation,
+  type PublicSeatParse,
 } from "./invocation.ts";
 import {
+  presentControlledFailure,
   prepareSummonsResumeMaterials,
+  resolveResumeMethodMaterialAdapters,
+  roleTurnOptions,
   runPostAdmissionOneShot,
+  runPostAdmissionResumable,
   runPostAdmissionSeatResume,
   resumeTurnRequestProjectionOptions,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
 } from "./post-admission.ts";
 import {
-  loadResumableInstructionSeatRun,
+  buildAutoResumeContinuationPrompt,
+  loadResumablePublicRole,
   markRunAdmitted,
+  parentRunPathFromGatePointerInstruction,
   type PublicResumeRequest,
+  type RunWriterLease,
   type SameTicketSummonsMaterials,
 } from "./run-lifecycle.ts";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.ts";
 import {
   presentStructuralRejection,
-  readEngineDetourInfrastructureFailure,
-  trySettleAuditorTerminalResult,
-  trySettleGatekeeperTerminalResult,
-  trySettleNavigatorTerminalResult,
+  seatKnownFailureResolver,
+  trySettlePublicSeat,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
-import type { TerminalResult } from "./terminal.ts";
 import {
+  formatTerminalResult,
+  isLawfulTypedTerminalOutcome,
+  type TerminalResult,
+} from "./terminal.ts";
+import {
+  admittedSeatTurnDetails,
+  packagedSettleSkill,
   projectRoleTurnRequest,
   type RoleTurnRequestProjectionOptions,
 } from "./turn-request.ts";
+import {
+  invokeCourtDiarist,
+  runCountersignCourtDiaristStation,
+  type CountersignRunEnv,
+} from "./countersign-run.ts";
 
-export type InstructionSeatRole =
-  | "gatekeeper"
-  | "navigator"
-  | "auditor";
-
-export type AdmittedInstructionSeatInvocation =
-  | AdmittedGatekeeperInvocation
-  | AdmittedNavigatorInvocation
-  | AdmittedAuditorInvocation;
-
-export type InstructionSeatRunEnv = PostAdmissionEnv & {
-  principalAuthority: DurablePrincipalAuthority;
-  createRunId?: () => string;
-  /**
-   * #756 nested gate re-ask for auditor: plain-language instruction on same-ticket resume.
-   * Only set by summonPublicRole when the prior officer reply was not three-state.
-   * Never a public CLI argv — must not pollute the --source-run parent lookup key (#747).
-   */
-  reviewReask?: string;
-  /**
-   * #879 gate summons: verbatim parent-submission body for officer dialogue content.
-   * Rides summons.instruction / first-mint prompt when reviewReask is absent.
-   */
-  gateReviewInstruction?: string;
+export type InstructionSeatRunEnv = PostAdmissionEnv & Pick<
+  CountersignRunEnv,
+  "reviewReask" | "gateReviewInstruction" | "parentRunPath" | "runCourtDiaristStation"
+>;
+
+type SeatRunResult = {
+  exitCode: number;
+  admitted?: AdmittedRoleInvocation;
+  terminal?: TerminalResult;
 };
 
-/** Project an admitted instruction-seat invocation onto the host-neutral turn request. */
+function roleRecord(role: PackagedRole) {
+  const record = packagedRoleMetadata(role);
+  if (record === undefined) {
+    throw new CliUsageError(`unknown role: ${role}`);
+  }
+  return record;
+}
+
+/** Project any admitted public role onto the host-neutral turn request. */
 export function buildInstructionSeatTurnRequest(
-  admitted: AdmittedInstructionSeatInvocation,
+  admitted: AdmittedRoleInvocation,
   options: RoleTurnRequestProjectionOptions,
 ): RoleTurnRequest {
   return projectRoleTurnRequest(
     admitted,
-    {
-      activation: {
-        role: admitted.role,
-      },
-    },
+    admittedSeatTurnDetails(admitted, options.packageRoot),
     options,
   );
 }
 
-function instructionSeatAdapters(options?: {
-  beforeDispatch?: (
-    admitted: AdmittedInstructionSeatInvocation,
-  ) => void | Promise<void>;
-}): PostAdmissionAdapters<AdmittedInstructionSeatInvocation> {
-  return {
-    trySettle: (
-      admitted: AdmittedInstructionSeatInvocation,
-      authority: DurablePrincipalAuthority,
-      scope?: { readonly courtAttemptId?: string },
-    ) => {
-      switch (admitted.role) {
-        case "gatekeeper":
-          return trySettleGatekeeperTerminalResult(admitted, authority, scope);
-        case "navigator":
-          return trySettleNavigatorTerminalResult(admitted, authority, scope);
-        case "auditor":
-          return trySettleAuditorTerminalResult(admitted, authority, scope);
-      }
-    },
-    // Accepted receipts and failure terminals both present via shared path.
-    shouldPresentSettled: () => true,
-    // #675 / #357 T2: failInfrastructure abort after engine-detour tool failure must not
-    // wash the durable toolResult diagnostic (same seam as reviewer-run / judge-run).
-    resolveRunnerKnownFailure: async ({
-      result,
-      sessionFile,
-    }: {
-      result: { knownFailure?: import("../host-contracts.ts").RoleTurnKnownFailure };
-      sessionFile: string;
-    }) => {
-      const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
-      return infrastructureFailure === undefined
-        ? result.knownFailure
-        : {
-            ...(infrastructureFailure.cause === undefined
-              ? {}
-              : { cause: infrastructureFailure.cause }),
-            diagnostic: infrastructureFailure.diagnostic,
-            ...(infrastructureFailure.identity === undefined
-              ? {}
-              : { identity: infrastructureFailure.identity }),
-          };
-    },
-    ...(options?.beforeDispatch === undefined
-      ? {}
-      : { beforeDispatch: options.beforeDispatch }),
-  };
+function initialPrompt(
+  admitted: AdmittedRoleInvocation,
+  env: InstructionSeatRunEnv,
+): string {
+  const record = roleRecord(admitted.role);
+  const reask = env.reviewReask ?? env.gateReviewInstruction;
+  if (reask !== undefined && "reaskPrompt" in record && record.reaskPrompt === true) {
+    return reask;
+  }
+  return buildInstructionTransportPrompt(
+    admitted,
+    engineSessionMaterialFromOptions({
+      ...pickEngineAxis(env),
+      packageRoot: env.packageRoot,
+    }),
+  );
+}
+
+function hostTurnCwd(env: InstructionSeatRunEnv): { readonly cwd: string } | undefined {
+  return env.executionCwd === undefined ? undefined : { cwd: env.executionCwd };
+}
+
+function wantsFreshExecutionCopy(role: PackagedRole): boolean {
+  const record = roleRecord(role);
+  return "freshExecutionCopy" in record && record.freshExecutionCopy === true;
+}
+
+function infraFailure(role: PackagedRole) {
+  const resolveRunnerKnownFailure = seatKnownFailureResolver(role);
+  return resolveRunnerKnownFailure === undefined ? {} : { resolveRunnerKnownFailure };
+}
+
+function isBoardTicketSeat(
+  seat: AdmittedRoleInvocation,
+): seat is AdmittedRoleInvocation & { role: "diarist" } {
+  return packagedBindsBoardTicket(seat.role);
 }
 
-async function admitInstructionSeat(
-  role: InstructionSeatRole,
-  options: Parameters<typeof admitGatekeeperInvocation>[0],
-): Promise<AdmittedInstructionSeatInvocation> {
-  switch (role) {
-    case "gatekeeper":
-      return admitGatekeeperInvocation(options);
-    case "navigator":
-      return admitNavigatorInvocation(options);
-    case "auditor":
-      return admitAuditorInvocation(options);
+async function bindAndRelocateDiarist(
+  admitted: AdmittedRoleInvocation & { role: "diarist" },
+  authority: DurablePrincipalAuthority,
+  lease?: RunWriterLease,
+): Promise<void> {
+  const boardTicket = await readBoardTicketNumber(admitted.runDirectory);
+  if (boardTicket === undefined) return;
+  if (admitted.ticketNumber === undefined) {
+    await bindAdmittedTicketNumber(admitted, boardTicket);
   }
+  await relocateAdmittedRunToTicket(admitted, authority, lease);
 }
 
-export async function runPublicInstructionSeatResume(
-  request: PublicResumeRequest,
+function seatAdapters(
+  admitted: AdmittedRoleInvocation,
   env: InstructionSeatRunEnv,
-  io: CliIo,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedInstructionSeatInvocation;
-  terminal?: TerminalResult;
-}> {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) => loadResumableInstructionSeatRun(
-      env.home,
-      effective.runId,
-      env.principalAuthority,
-    ),
-    buildTurnRequest: async (admitted, effective) => {
-      const summonsPrepared = await prepareSummonsResumeMaterials(
-        admitted.runDirectory,
-        effective.summons,
-      );
-      return buildInstructionSeatTurnRequest(
-        admitted,
-        resumeTurnRequestProjectionOptions(
-          admitted,
-          effective,
-          env,
-          summonsPrepared,
-        ),
-      );
-    },
-    adapters: instructionSeatAdapters(),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
+  material?: PackagedMethodSkillMaterial,
+): PostAdmissionAdapters<AdmittedRoleInvocation> {
+  const record = roleRecord(admitted.role);
+  const present = "presentSettled" in record ? record.presentSettled : "default";
+  return {
+    trySettle: (seat, authority, scope) =>
+      trySettlePublicSeat(seat, authority, scope, material, env.packageRoot),
+    ...(present === "always" ? { shouldPresentSettled: () => true } : {}),
+    ...(present === "typed"
+      ? { shouldPresentSettled: (terminal: TerminalResult) => isLawfulTypedTerminalOutcome(terminal.roleOutcome) }
+      : {}),
+    ...infraFailure(admitted.role),
+    ...(packagedBindsBoardTicket(admitted.role)
+      ? {
+        beforeDispatch: async (seat: AdmittedRoleInvocation, lease?: RunWriterLease) => {
+          if (!isBoardTicketSeat(seat)) return;
+          if (env.correlationId !== undefined && env.correlationId.trim() !== "") {
+            await recordAdmittedCorrelation(seat, env.correlationId);
+          }
+          await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
+        },
+        afterDispatch: async (seat: AdmittedRoleInvocation, lease?: RunWriterLease) => {
+          if (!isBoardTicketSeat(seat)) return;
+          await bindAndRelocateDiarist(seat, env.principalAuthority, lease);
+        },
+      }
+      : {}),
+  };
+}
+
+function usageExit(error: unknown, io: CliIo): SeatRunResult | undefined {
+  if (error instanceof CliUsageError) {
+    presentStructuralRejection(error, io);
+    return { exitCode: 2 };
+  }
+  return undefined;
 }
 
-/** Scope auditor subject/source-run env for the duration of one seat turn. */
-async function withAuditorSoulEnv<
-  T,
->(options: {
+async function withAuditorSoulEnv<T>(options: {
   readonly subject?: "judge" | "doctor";
   readonly sourceRunDirectory?: string;
   readonly run: () => Promise<T>;
@@ -204,14 +214,10 @@ async function withAuditorSoulEnv<
   if (options.subject === undefined && options.sourceRunDirectory === undefined) {
     return options.run();
   }
-  const { AK_ROLE_AUDITOR_SUBJECT_ENV, AK_ROLE_AUDITOR_SOURCE_RUN_ENV } = await import(
-    "../auditor-soul.ts"
-  );
+  const { AK_ROLE_AUDITOR_SUBJECT_ENV, AK_ROLE_AUDITOR_SOURCE_RUN_ENV } = await import("../auditor-soul.ts");
   const priorSubject = process.env[AK_ROLE_AUDITOR_SUBJECT_ENV];
   const priorSource = process.env[AK_ROLE_AUDITOR_SOURCE_RUN_ENV];
-  if (options.subject !== undefined) {
-    process.env[AK_ROLE_AUDITOR_SUBJECT_ENV] = options.subject;
-  }
+  if (options.subject !== undefined) process.env[AK_ROLE_AUDITOR_SUBJECT_ENV] = options.subject;
   if (options.sourceRunDirectory !== undefined) {
     process.env[AK_ROLE_AUDITOR_SOURCE_RUN_ENV] = options.sourceRunDirectory;
   }
@@ -229,147 +235,295 @@ async function withAuditorSoulEnv<
   }
 }
 
-export async function runPublicInstructionSeat(
-  argv: readonly string[],
+async function dispatchAdmitted(
+  admitted: AdmittedRoleInvocation,
   env: InstructionSeatRunEnv,
   io: CliIo,
-  role: InstructionSeatRole,
-  parseArgv: (args: readonly string[]) => ParseInstructionArgvResult,
-): Promise<{
-  exitCode: number;
-  admitted?: AdmittedInstructionSeatInvocation;
-  terminal?: TerminalResult;
-}> {
-  let parsed: ParseInstructionArgvResult;
-  try {
-    parsed = parseArgv(argv);
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
+): Promise<SeatRunResult> {
+  const record = roleRecord(admitted.role);
+  let material: PackagedMethodSkillMaterial | undefined;
+  const skill = packagedSettleSkill(admitted);
+  if (skill !== undefined) {
+    try {
+      material = await loadPackagedMethodSkillMaterial(env.packageRoot, skill);
+    } catch (error) {
+      const knownCause = packagedMethodLoadFailureCause(admitted.role);
+      return await presentControlledFailure(admitted, {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error,
+        ...(knownCause === undefined ? {} : { knownCause }),
+      }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
     }
-    throw error;
   }
-
-  let auditorSubject: "judge" | "doctor" | undefined;
-  let auditorSourceRun: string | undefined;
-  let auditorSourceTicket: number | undefined;
-
-  // #637 / #747 / #771: resume prior seat run with this summons' materials.
-  // Auditor (#747): parent --source-run path is the lookup key (typed inherit).
-  // Other instruction seats: no mechanical ticket match against instruction text.
-  // No bare catch→fresh.
-  const projectRoot = parsed.project ?? env.cwd;
-  if (role === "auditor") {
-    if (parsed.subject !== "judge" && parsed.subject !== "doctor") {
-      presentStructuralRejection(
-        new CliUsageError("auditor --subject requires judge|doctor"),
-        io,
-      );
-      return { exitCode: 2 };
-    }
-    auditorSubject = parsed.subject;
-    const source = typeof parsed.sourceRun === "string" ? parsed.sourceRun.trim() : "";
-    if (source === "") {
-      presentStructuralRejection(
-        new CliUsageError("auditor --source-run requires a run locator"),
+  const adapters = seatAdapters(admitted, env, material);
+  const execute = async (activeEnv: InstructionSeatRunEnv): Promise<SeatRunResult> => {
+    const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
+    const cwd = hostTurnCwd(activeEnv);
+    if (auto) {
+      return await runPostAdmissionResumable({
+        admitted,
+        env: activeEnv,
         io,
-      );
-      return { exitCode: 2 };
-    }
-    try {
-      const { resolveNotarySourceRunLocator } = await import("../notary-source-run.ts");
-      const resolved = await resolveNotarySourceRunLocator({
-        projectRoot,
-        sourceRun: source,
-        home: env.home,
+        buildInitialRequest: () => buildInstructionSeatTurnRequest(
+          admitted,
+          roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }, cwd),
+        ),
+        buildResumeRequest: () => buildInstructionSeatTurnRequest(
+          admitted,
+          roleTurnOptions(activeEnv, admitted, {
+            kind: "resume",
+            prompt: buildAutoResumeContinuationPrompt({
+              packageRoot: activeEnv.packageRoot,
+              ...pickEngineAxis(activeEnv),
+            }),
+          }, cwd),
+        ),
+        adapters,
+        ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
       });
-      auditorSourceRun = resolved.runDirectory;
-      // Auditor inherits board identity only — migration-derived is display, not admission.
-      auditorSourceTicket = await readBoardTicketNumber(resolved.runDirectory);
-    } catch (error) {
-      presentStructuralRejection(
-        new CliUsageError(error instanceof Error ? error.message : String(error)),
-        io,
-      );
-      return { exitCode: 2 };
     }
+    return await runPostAdmissionOneShot({
+      admitted,
+      env: activeEnv,
+      io,
+      request: buildInstructionSeatTurnRequest(
+        admitted,
+        roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }, cwd),
+      ),
+      adapters,
+      ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
+    });
+  };
+  if (!wantsFreshExecutionCopy(admitted.role)) return execute(env);
+  try {
+    if (env.executionCwd !== undefined) return await execute(env);
+    const { withEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+    return await withEphemeralReviewerWorktree({
+      projectRoot: admitted.projectRoot,
+      onCleanupDiagnostic: (diagnostic) => {
+        io.stderr(`${diagnostic}\n`);
+      },
+      run: (executionCwd) => execute({ ...env, executionCwd }),
+    });
+  } catch (error) {
+    return await presentControlledFailure(admitted, {
+      timedOut: false,
+      code: null,
+      stderr: "",
+      thrown: error,
+    }, adapters, env.principalAuthority, io) as SeatRunResult;
   }
+}
 
-  // #756/#879: auditor reask / verbatim submission body ride summons.instruction.
-  // Binding pointer stays --source-run / argv 卷宗指针; content is body or reask.
-  const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
-  const summons: SameTicketSummonsMaterials = {
-    ...(resumeInstruction === undefined
+/**
+ * Omitted lens on a parallel-lens seat: two ordinary single-axis runs, no parent run.
+ * Each leg reuses this call's argv and only adds `--lens`.
+ */
+async function runOmittedLensBatch(
+  argv: readonly string[],
+  parsed: PublicSeatParse,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+): Promise<SeatRunResult> {
+  const { summonParallelReviewerLenses } = await import("../public-role-summons.ts");
+  const children = await summonParallelReviewerLenses({
+    argv,
+    cwd: env.cwd,
+    projectRoot: resolve(parsed.project ?? env.cwd),
+    baseRevision: parsed.baseRevision ?? "",
+    home: env.home,
+    agentDir: env.agentDir,
+    ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
+    ...(env.model === undefined ? {} : { model: env.model }),
+    ...(env.host === undefined ? {} : { host: env.host }),
+    ...(env.engine === undefined ? {} : { engine: env.engine }),
+    ...(env.engineModel === undefined ? {} : { engineModel: env.engineModel }),
+    packageRoot: env.packageRoot,
+    ...(env.signal === undefined ? {} : { signal: env.signal }),
+    ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
+    roleTurnHost: env.roleTurnHost,
+    ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+    principalAuthority: env.principalAuthority,
+    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+  });
+  const childResults = [children.completeness, children.correctness] as const;
+  const terminals = childResults
+    .map((child) => child.terminal)
+    .filter((terminal): terminal is TerminalResult => terminal !== undefined);
+  const failedChildren = childResults.filter((child) =>
+    child.terminal === undefined
+    || !isLawfulTypedTerminalOutcome(child.terminal.roleOutcome)).length;
+  const overlayExit = childResults.some((child) => child.exitCode !== 0);
+  const failed = failedChildren > 0 || overlayExit;
+  const overlayDiagnostics = [...new Set(
+    childResults
+      .map((child) => child.stderr)
+      .filter((text): text is string => typeof text === "string" && text !== ""),
+  )];
+  const terminal: TerminalResult = {
+    batch: "reviewer",
+    roleOutcome: failed
       ? {
-          instruction: parsed.instruction,
-          instructionEmpty: parsed.instruction.trim() === "",
+          kind: "failure",
+          role: "reviewer",
+          diagnostic: failedChildren > 0
+            ? "Reviewer batch child failure"
+            : (overlayDiagnostics[0] ?? "Reviewer batch infrastructure failure"),
+          decisiveFacts: { failedChildren },
+          payloads: terminals,
         }
-      : { instruction: resumeInstruction, instructionEmpty: false }),
-    attachmentPaths: parsed.attachmentPaths,
+      : { kind: "accepted", role: "reviewer", payloads: terminals },
+    reviewerChildren: {
+      ...(children.completeness.terminal === undefined ? {} : { completeness: children.completeness.terminal }),
+      ...(children.correctness.terminal === undefined ? {} : { correctness: children.correctness.terminal }),
+    },
+    reviewerChildOutcomes: {
+      completeness: { exitCode: children.completeness.exitCode, ...(children.completeness.stderr === undefined ? {} : { stderr: children.completeness.stderr }) },
+      correctness: { exitCode: children.correctness.exitCode, ...(children.correctness.stderr === undefined ? {} : { stderr: children.correctness.stderr }) },
+    },
+    navigator: {
+      disposition: "unavailable",
+      source: "unknown",
+      reason: "Reviewer batch has no parent-run Navigator attendance",
+    },
+    artifacts: terminals.flatMap((item) => item.artifacts),
   };
-  if (role === "auditor" && auditorSourceRun !== undefined) {
-    const resumed = await withAuditorSoulEnv({
-      ...(auditorSubject === undefined ? {} : { subject: auditorSubject }),
-      sourceRunDirectory: auditorSourceRun,
-      run: () =>
-        tryResumeSameTicketSeatRun({
-          home: env.home,
-          projectRoot,
-          role,
-          parentRunPath: auditorSourceRun,
-          freshSummons: env.freshSummons,
-          summons,
-          resume: (runId, materials) =>
-            runPublicInstructionSeatResume(
-              { runId, ...(materials === undefined ? {} : { summons: materials }) },
-              env,
-              io,
-            ),
-        }),
+  io.stdout(formatTerminalResult(terminal));
+  return { exitCode: failed ? 1 : 0, terminal };
+}
+
+/**
+ * Countersign on the shared entry: gate parent resume, deferred materialization,
+ * 起居郎 identity, then the same one-shot settlement as every other seat.
+ * Court refresh stays on runCountersignCourtDiaristStation.
+ */
+async function runCountersignBody(
+  parsed: PublicSeatParse,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+): Promise<SeatRunResult> {
+  const gateParentRunPath =
+    typeof env.parentRunPath === "string" && env.parentRunPath.trim() !== ""
+      ? env.parentRunPath
+      : undefined;
+  if (gateParentRunPath !== undefined) {
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction ?? parsed.instruction ?? "";
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot: resolve(parsed.project ?? env.cwd),
+      role: "countersign",
+      parentRunPath: gateParentRunPath,
+      freshSummons: env.freshSummons,
+      summons: {
+        sourceRunPath: gateParentRunPath,
+        instruction: resumeInstruction,
+        instructionEmpty: resumeInstruction.trim() === "",
+      },
+      resume: (runId, materials) => runPublicInstructionSeatResume(
+        { runId, ...(materials === undefined ? {} : { summons: materials }) },
+        env,
+        io,
+      ),
     });
-    if (resumed !== undefined) return resumed;
-    // #836: reask without a prior same-parent run still mints; summons.instruction
-    // already carries the reask text. Do not structurally terminate the queue.
+    if (resumed != null) return resumed;
   }
 
-  let admitted: AdmittedInstructionSeatInvocation;
+  let admitted: AdmittedCountersignInvocation;
   try {
-    admitted = await admitInstructionSeat(role, {
-      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 }),
-      ...(auditorSourceTicket === undefined
-        ? {}
-        : { assertedTicketNumber: auditorSourceTicket }),
-    });
+    admitted = await admitPublicRole("countersign", parsed, env, { deferPersistence: true });
   } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
+    const rejected = usageExit(error, io);
+    if (rejected !== undefined) return rejected;
     throw error;
   }
 
-  if (role === "auditor" && auditorSourceRun !== undefined) {
-    await persistAdmittedSourceRunPath(admitted, auditorSourceRun);
-  }
+  try {
+    return await withPreparedAttachments(parsed.attachmentPaths ?? [], async (preparedAttachments) => {
+      const materializeAdmission = async (ticketNumber?: number): Promise<void> => {
+        await materializeCountersignInvocation(admitted, {
+          home: env.home,
+          principalAuthority: env.principalAuthority,
+          preparedAttachments,
+          ...(env.model === undefined ? {} : { model: env.model }),
+          ...(ticketNumber === undefined ? {} : { ticketNumber }),
+        });
+      };
 
-  return await withAuditorSoulEnv({
-    ...(auditorSubject === undefined ? {} : { subject: auditorSubject }),
-    ...(auditorSourceRun === undefined
-      ? {}
-      : { sourceRunDirectory: auditorSourceRun }),
-    run: async () => {
+      let typedTicket: number | undefined;
+      let typedCourtTicketNumbers: readonly number[] | undefined;
+      let identityDiaristRan = false;
+
+      if (env.runCourtDiaristStation === undefined) {
+        let outcome: Awaited<ReturnType<typeof invokeCourtDiarist>>;
+        try {
+          outcome = await invokeCourtDiarist({
+            instruction: parsed.instruction ?? "",
+            projectRoot: admitted.projectRoot,
+            failureLabel: "unbound summons",
+            ...(env.boundTicketNumber === undefined ? {} : { boundTicketNumber: env.boundTicketNumber }),
+          }, env, io);
+        } catch (error) {
+          await materializeAdmission(
+            isSafePositiveTicketNumber(env.boundTicketNumber) ? env.boundTicketNumber : undefined,
+          );
+          await markRunAdmitted(admitted, env.principalAuthority);
+          return await presentControlledFailure(admitted, {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: error,
+          }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
+        }
+        identityDiaristRan = true;
+        if (outcome.identity.kind === "escalate" || outcome.failedWithoutEscalate !== undefined) {
+          const diagnostic = outcome.identity.kind === "escalate"
+            ? outcome.identity.diagnostic
+            : outcome.failedWithoutEscalate?.diagnostic ?? "";
+          await materializeAdmission(
+            isSafePositiveTicketNumber(env.boundTicketNumber) ? env.boundTicketNumber : undefined,
+          );
+          await markRunAdmitted(admitted, env.principalAuthority);
+          return await presentControlledFailure(admitted, {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: new Error(diagnostic),
+          }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
+        }
+        if (outcome.identity.kind === "ticket") {
+          typedTicket = isSafePositiveTicketNumber(env.boundTicketNumber)
+            ? env.boundTicketNumber
+            : outcome.identity.ticketNumber;
+          typedCourtTicketNumbers = outcome.identity.courtTicketNumbers;
+        } else if (isSafePositiveTicketNumber(env.boundTicketNumber)) {
+          typedTicket = env.boundTicketNumber;
+        }
+      }
+
+      await materializeAdmission(typedTicket);
       await markRunAdmitted(admitted, env.principalAuthority);
+      if (gateParentRunPath !== undefined) {
+        await persistAdmittedSourceRunPath(admitted, gateParentRunPath);
+        admitted = { ...admitted, sourceRunPath: gateParentRunPath };
+      }
+      if (identityDiaristRan && typedTicket !== undefined) {
+        try {
+          await bindAdmittedTicketNumber(admitted, typedTicket);
+          await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+          await bindCourtTicketNumbersOnAdmitted(admitted, typedCourtTicketNumbers ?? [typedTicket]);
+        } catch (error) {
+          return await presentControlledFailure(admitted, {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: error,
+          }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
+        }
+      }
 
-      const turnRequest = buildInstructionSeatTurnRequest(admitted, {
+      const turnProjection: RoleTurnRequestProjectionOptions = {
         packageRoot: env.packageRoot,
         home: env.home,
         agentDir: env.agentDir,
@@ -381,7 +535,6 @@ export async function runPublicInstructionSeat(
           : { correlationId: env.correlationId }),
         continuation: {
           kind: "initial",
-          // #879: gate first mint uses parent payload as content when present.
           prompt: (env.reviewReask ?? env.gateReviewInstruction)
             ?? buildInstructionTransportPrompt(
               admitted,
@@ -391,16 +544,344 @@ export async function runPublicInstructionSeat(
               }),
             ),
         },
-      });
-
-      return await runPostAdmissionOneShot({
+      };
+      const turnRequest = buildInstructionSeatTurnRequest(admitted, turnProjection);
+      const result = await runPostAdmissionOneShot({
         admitted,
         env,
         io,
         request: turnRequest,
-        adapters: instructionSeatAdapters(),
+        adapters: {
+          ...seatAdapters(admitted, env),
+          beforeDispatch: async (admittedSeat, lease) => {
+            if (!packagedAdmitsCountersign(admittedSeat.role)) return;
+            if (!identityDiaristRan || typedTicket !== undefined) {
+              await runCountersignCourtDiaristStation(admittedSeat, env, io);
+            }
+            await relocateAdmittedRunToTicket(admittedSeat, env.principalAuthority, lease);
+            Object.assign(turnRequest, buildInstructionSeatTurnRequest(admittedSeat, turnProjection));
+          },
+        },
         ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
       });
+      await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+      return result;
+    });
+  } catch (error) {
+    const rejected = usageExit(error, io);
+    if (rejected !== undefined) return rejected;
+    throw error;
+  }
+}
+
+export async function runPublicInstructionSeat(
+  argv: readonly string[],
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+  role: PackagedRole,
+  parseArgv: (args: readonly string[]) => PublicSeatParse,
+): Promise<SeatRunResult> {
+  const record = roleRecord(role);
+  let parsed: PublicSeatParse;
+  try {
+    parsed = parseArgv(argv);
+  } catch (error) {
+    const rejected = usageExit(error, io);
+    if (rejected !== undefined) return rejected;
+    throw error;
+  }
+  if (packagedAdmitsCountersign(role)) {
+    return runCountersignBody(parsed, env, io);
+  }
+
+  if ("parallelLenses" in record && record.parallelLenses === true) {
+    if (parsed.baseRevision === undefined) {
+      presentStructuralRejection(new CliUsageError("reviewer requires --base"), io);
+      return { exitCode: 2 };
+    }
+    if (parsed.lens === undefined) {
+      return runOmittedLensBatch(argv, parsed, env, io);
+    }
+  }
+
+  const projectRoot = parsed.project ?? env.cwd;
+  let auditorSubject: "judge" | "doctor" | undefined;
+  let auditorSource: string | undefined;
+  let auditorTicket: number | undefined;
+  if (record.sameParent === "subject-source") {
+    if (!isAuditorSoulRole(parsed.subject)) {
+      presentStructuralRejection(new CliUsageError("auditor --subject requires judge|doctor"), io);
+      return { exitCode: 2 };
+    }
+    auditorSubject = parsed.subject;
+    const source = typeof parsed.sourceRun === "string" ? parsed.sourceRun.trim() : "";
+    if (source === "") {
+      presentStructuralRejection(new CliUsageError("auditor --source-run requires a run locator"), io);
+      return { exitCode: 2 };
+    }
+    try {
+      const resolved = await resolveNotarySourceRunLocator({ projectRoot, sourceRun: source, home: env.home });
+      auditorSource = resolved.runDirectory;
+      auditorTicket = await readBoardTicketNumber(resolved.runDirectory);
+    } catch (error) {
+      presentStructuralRejection(new CliUsageError(error instanceof Error ? error.message : String(error)), io);
+      return { exitCode: 2 };
+    }
+    if (auditorSource === undefined) return { exitCode: 2 };
+    const sourceDirectory = auditorSource;
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
+    const summons: SameTicketSummonsMaterials = {
+      ...(resumeInstruction === undefined
+        ? { instruction: parsed.instruction ?? "", instructionEmpty: (parsed.instruction ?? "").trim() === "" }
+        : { instruction: resumeInstruction, instructionEmpty: false }),
+      attachmentPaths: parsed.attachmentPaths ?? [],
+    };
+    const resumed = await withAuditorSoulEnv({
+      subject: auditorSubject,
+      sourceRunDirectory: auditorSource,
+      run: () => tryResumeSameTicketSeatRun({
+        home: env.home,
+        projectRoot,
+        role,
+        parentRunPath: sourceDirectory,
+        freshSummons: env.freshSummons,
+        summons,
+        resume: (runId, materials) => runPublicInstructionSeatResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+      }),
+    });
+    if (resumed != null) return resumed;
+  }
+
+  if (record.sameParent === "gate-pointer") {
+    const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction ?? "");
+    if (parentRunPath !== undefined) {
+      const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
+      const summons: SameTicketSummonsMaterials = {
+        sourceRunPath: parentRunPath,
+        ...(resumeInstruction === undefined
+          ? { instruction: parsed.instruction ?? "", instructionEmpty: (parsed.instruction ?? "").trim() === "" }
+          : { instruction: resumeInstruction, instructionEmpty: false }),
+        attachmentPaths: parsed.attachmentPaths ?? [],
+      };
+      const resumed = await tryResumeSameTicketSeatRun({
+        home: env.home,
+        projectRoot,
+        role,
+        parentRunPath,
+        freshSummons: env.freshSummons,
+        summons,
+        resume: (runId, materials) => runPublicInstructionSeatResume(
+          { runId, ...(materials === undefined ? {} : { summons: materials }) },
+          env,
+          io,
+        ),
+      });
+      if (resumed != null) return resumed;
+    }
+  }
+
+  if (record.sameParent === "source-locator") {
+    let source;
+    try {
+      source = await resolveNotarySourceRunLocator({
+        projectRoot,
+        sourceRun: parsed.sourceRun ?? "",
+        home: env.home,
+      });
+    } catch (error) {
+      if (error instanceof NotarySourceRunError) {
+        presentStructuralRejection(new CliUsageError(error.message, { cause: error }), io);
+        return { exitCode: 2 };
+      }
+      throw error;
+    }
+    const resumeInstruction = env.reviewReask ?? env.gateReviewInstruction;
+    const summons: SameTicketSummonsMaterials = {
+      sourceRunPath: source.runDirectory,
+      sourceRun: source,
+      ...(resumeInstruction === undefined ? {} : { instruction: resumeInstruction, instructionEmpty: false }),
+    };
+    const resumed = await tryResumeSameTicketSeatRun({
+      home: env.home,
+      projectRoot,
+      role,
+      parentRunPath: source.runDirectory,
+      freshSummons: env.freshSummons,
+      summons,
+      resume: (runId, materials) => runPublicInstructionSeatResume(
+        { runId, ...(materials === undefined ? {} : { summons: materials }) },
+        env,
+        io,
+      ),
+    });
+    if (resumed != null) return resumed;
+  }
+
+  let admitted: AdmittedRoleInvocation;
+  try {
+    admitted = await admitPublicRole(
+      role,
+      parsed,
+      env,
+      auditorTicket === undefined ? undefined : { assertedTicketNumber: auditorTicket },
+    );
+  } catch (error) {
+    const rejected = usageExit(error, io);
+    if (rejected !== undefined) return rejected;
+    throw error;
+  }
+
+  if (record.sameParent === "gate-pointer") {
+    const parentRunPath = parentRunPathFromGatePointerInstruction(parsed.instruction ?? "");
+    if (parentRunPath !== undefined) {
+      await persistAdmittedSourceRunPath(admitted, parentRunPath);
+      const sourcePatch = { sourceRunPath: parentRunPath };
+      admitted = { ...admitted, ...sourcePatch };
+    }
+  }
+  if (record.sameParent === "subject-source" && auditorSource !== undefined) {
+    await persistAdmittedSourceRunPath(admitted, auditorSource);
+  }
+
+  const runAdmitted = async (): Promise<SeatRunResult> => {
+    await markRunAdmitted(admitted, env.principalAuthority);
+    if (record.sameParent === "court-diarist") {
+      const { invokeCourtDiarist } = await import("./countersign-run.ts");
+      const outcome = await invokeCourtDiarist({
+        instruction: parsed.instruction ?? "",
+        projectRoot: admitted.projectRoot,
+        failureLabel: "secretariat unbound summons",
+        attachmentPaths: admitted.attachments.map((attachment) => attachment.frozenPath),
+        correlationId: admitted.runId,
+      }, {
+        cwd: env.cwd,
+        home: env.home,
+        agentDir: env.agentDir,
+        packageRoot: env.packageRoot,
+        ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
+        ...(env.signal === undefined ? {} : { signal: env.signal }),
+        ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+      }, io);
+      if (outcome.identity.kind === "escalate" || outcome.failedWithoutEscalate !== undefined) {
+        const diagnostic = outcome.identity.kind === "escalate"
+          ? outcome.identity.diagnostic
+          : outcome.failedWithoutEscalate?.diagnostic ?? "";
+        return await presentControlledFailure(admitted, {
+          timedOut: false,
+          code: null,
+          stderr: "",
+          thrown: new Error(diagnostic),
+        }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
+      }
+      if (outcome.identity.kind === "ticket") {
+        try {
+          await bindAdmittedTicketNumber(admitted, outcome.identity.ticketNumber);
+          await relocateAdmittedRunToTicket(admitted, env.principalAuthority);
+        } catch (error) {
+          return await presentControlledFailure(admitted, {
+            timedOut: false,
+            code: null,
+            stderr: "",
+            thrown: error,
+          }, seatAdapters(admitted, env), env.principalAuthority, io) as SeatRunResult;
+        }
+      }
+    }
+    return dispatchAdmitted(admitted, env, io);
+  };
+
+  if (record.sameParent === "subject-source") {
+    return withAuditorSoulEnv({
+      ...(auditorSubject === undefined ? {} : { subject: auditorSubject }),
+      ...(auditorSource === undefined ? {} : { sourceRunDirectory: auditorSource }),
+      run: runAdmitted,
+    });
+  }
+  return runAdmitted();
+}
+
+export async function runPublicInstructionSeatResume(
+  request: PublicResumeRequest,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+): Promise<SeatRunResult> {
+  const execution: { cwd?: string } = {
+    ...(env.executionCwd === undefined ? {} : { cwd: env.executionCwd }),
+  };
+  return runPostAdmissionSeatResume<AdmittedRoleInvocation>({
+    request,
+    env,
+    io,
+    load: async (effective) => {
+      const loaded = await loadResumablePublicRole(env.home, effective.runId, env.principalAuthority);
+      if (
+        packagedRebindSourceOnResume(loaded.admitted.role)
+        && effective.summons?.sourceRunPath !== undefined
+        && effective.summons.sourceRun !== undefined
+      ) {
+        return {
+          ...loaded,
+          admitted: {
+            ...loaded.admitted,
+            sourceRunPath: effective.summons.sourceRunPath,
+            sourceRun: effective.summons.sourceRun,
+          },
+        };
+      }
+      return loaded;
+    },
+    buildTurnRequest: async (admitted, effective) => {
+      const activeEnv = execution.cwd === undefined ? env : { ...env, executionCwd: execution.cwd };
+      const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
+      return buildInstructionSeatTurnRequest(
+        admitted,
+        {
+          ...resumeTurnRequestProjectionOptions(admitted, effective, activeEnv, summonsPrepared),
+          ...(execution.cwd === undefined ? {} : { cwd: execution.cwd }),
+        },
+      );
+    },
+    adapters: {
+      trySettle: async () => undefined,
+    },
+    afterAdmittedLoad: (admitted) => {
+      const skill = packagedSettleSkill(admitted);
+      if (skill === undefined) {
+        return Promise.resolve({ kind: "continue" as const, adapters: seatAdapters(admitted, env) });
+      }
+      const knownCause = packagedMethodLoadFailureCause(admitted.role);
+      return resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        loadMaterial: () => loadPackagedMethodSkillMaterial(env.packageRoot, skill),
+        adaptersWith: (material) => seatAdapters(admitted, env, material),
+        emptyAdapters: seatAdapters(admitted, env),
+        ...(knownCause === undefined ? {} : { knownCause }),
+      });
+    },
+    afterAdmittedPrepare: async (admitted) => {
+      if (!wantsFreshExecutionCopy(admitted.role)) return {};
+      if (execution.cwd !== undefined) {
+        return { env: { ...env, executionCwd: execution.cwd } };
+      }
+      const { openEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+      const opened = await openEphemeralReviewerWorktree({
+        projectRoot: admitted.projectRoot,
+        onCleanupDiagnostic: (diagnostic) => {
+          io.stderr(`${diagnostic}\n`);
+        },
+      });
+      execution.cwd = opened.executionCwd;
+      return {
+        env: { ...env, executionCwd: opened.executionCwd },
+        cleanup: opened.close,
+      };
     },
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }