@akagilnc/pi-workflow-roles 0.1.5153 → 0.1.5196

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

@@ -199,6 +199,17 @@ export function courtTicketNumbersFromOutcome(
   return latest;
 }
 
+/** Latest payload only. An earlier escalate must not block a later non-escalate submission. */
+export function latestPayloadEscalated(
+  roleOutcome: TerminalRoleOutcome | undefined,
+): boolean {
+  if (roleOutcome === undefined) return false;
+  if (roleOutcome.kind === "audit_escalation") return true;
+  if (roleOutcome.kind !== "accepted") return false;
+  const payloads = roleOutcome.payloads ?? [];
+  return isEscalatePayload(payloads[payloads.length - 1]);
+}
+
 /** Routing boolean over the child's own typed sequence — does not pick or rewrite a sole row. */
 export function courtDiaristEscalated(
   roleOutcome: TerminalRoleOutcome | undefined,

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

@@ -4,9 +4,26 @@
  * starts two ordinary single-axis runs here. Countersign keeps deferred
  * identity on this entry; the court diarist station stays in countersign-run.
  */
-import { resolve, sep } from "node:path";
+import { dirname, resolve, sep } from "node:path";
+import { AUDITOR_DOSSIER_PROMPT } from "../compliance-transport.ts";
+import { bookDirectOfficerRunPointer } from "../archivist-record-pointer.ts";
+import { createPiDoctorAuditor } from "../doctor-auditor.ts";
 
-import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
+import type { DurablePrincipalAuthority, HostContext, RoleTurnRequest } from "../host-contracts.ts";
+import { officerConclusionReask, gateOfficerForSubject } from "../gatekeeper-role.ts";
+import { runJudgeGates } from "../judge-role.ts";
+import { WORKER_DONE_STATUSES } from "../worker-submission-contracts.ts";
+import { SECRETARIAT_GATE_OFFICER_ENTRY_TYPE } from "../secretariat-contracts.ts";
+import { readableGateItem } from "../readable-gate-item.ts";
+import { runIdFromRunDirectory } from "../run-terminal-artifacts.ts";
+import { createDefaultGateOfficerSummon, requireSubmissionGate } from "../submission-gate.ts";
+import { readRecordedSubmissionRows } from "../submission-ledger.ts";
+import { summonPublicRole, type PublicSummonResult } from "../public-role-summons.ts";
+import { sessionFileFromPublicSummon } from "../session-assistant-usage.ts";
+import {
+  latestQueuePayload,
+  latestQueueStatus,
+} from "../submission-gate.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";
@@ -17,7 +34,7 @@ import {
   packagedRebindSourceOnResume,
   packagedRoleMetadata,
 } from "../packaged-role-registry.ts";
-import { isAuditorSoulRole } from "../auditor-soul.ts";
+import { isAuditorSoulRole, readAuditorResumeBinding } from "../auditor-soul.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import {
   admitPublicRole,
@@ -59,7 +76,9 @@ import {
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.ts";
 import {
   presentStructuralRejection,
+  readBoundSessionEntries,
   seatKnownFailureResolver,
+  attachPostAuditProjection,
   trySettlePublicSeat,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
@@ -68,6 +87,7 @@ import {
   formatTerminalResult,
   isLawfulTypedTerminalOutcome,
   type TerminalResult,
+  type TerminalRoleName,
 } from "./terminal.ts";
 import {
   admittedSeatTurnDetails,
@@ -77,10 +97,10 @@ import {
 } from "./turn-request.ts";
 import {
   invokeCourtDiarist,
+  latestPayloadEscalated,
   runCountersignCourtDiaristStation,
   type CountersignRunEnv,
 } from "./countersign-run.ts";
-
 export type InstructionSeatRunEnv = PostAdmissionEnv & Pick<
   CountersignRunEnv,
   "reviewReask" | "gateReviewInstruction" | "parentRunPath" | "runCourtDiaristStation"
@@ -92,6 +112,76 @@ type SeatRunResult = {
   terminal?: TerminalResult;
 };
 
+const AUDITED_ROLES = new Set<PackagedRole>(["judge", "fixer", "coder", "secretariat", "countersign", "doctor"]);
+const SECRETARIAT_STATUS_REASK = "secretariatStatus 不是 converged、escalate 之一。请重新交卷，secretariatStatus 写明其一。";
+const COUNTERSIGN_STATUS_REASK = "status 不是 converged、continue、escalate 三态之一。请重新交卷，status 写明其一。";
+const WORKER_ROUTING_STATUSES: ReadonlySet<string> = new Set([
+  "planned", "completed", "refused", "partially_completed", "unfinished",
+]);
+const WORKER_STATUS_REASK =
+  "status 不是 planned、completed、refused、partially_completed、unfinished 之一。请重新交卷，status 写明其一。";
+const DOCTOR_ROUTING_STATUSES: ReadonlySet<string> = new Set(["completed", "refused"]);
+const DOCTOR_STATUS_REASK =
+  "status 不是 completed、refused 之一。请重新交卷，status 写明其一。";
+const POST_SUBMISSION_ROUTING: Partial<Record<PackagedRole, {
+  readonly statuses: ReadonlySet<string>;
+  readonly reask: string;
+}>> = {
+  judge: {
+    statuses: new Set(["converged", "continue", "escalate"]),
+    reask: "status 不是 converged、continue、escalate 三态之一。请重新交卷，status 写明其一。",
+  },
+  coder: {
+    statuses: WORKER_ROUTING_STATUSES,
+    reask: WORKER_STATUS_REASK,
+  },
+  fixer: {
+    statuses: WORKER_ROUTING_STATUSES,
+    reask: WORKER_STATUS_REASK,
+  },
+  diarist: {
+    statuses: new Set(["completed", "escalate"]),
+    reask: "status 不是 completed、escalate 之一。请重新交卷，status 写明其一。",
+  },
+  // Doctor contract domain is completed|refused; open-domain escalate is accepted
+  // by the tool then routed back here before mandatory auditor (#1057).
+  doctor: {
+    statuses: DOCTOR_ROUTING_STATUSES,
+    reask: DOCTOR_STATUS_REASK,
+  },
+} as const;
+
+function unreadablePostSubmissionStatus(
+  admitted: AdmittedRoleInvocation,
+  terminal: TerminalResult | undefined,
+): string | undefined {
+  if (terminal?.roleOutcome.kind !== "accepted") return undefined;
+  const route = POST_SUBMISSION_ROUTING[admitted.role];
+  if (route === undefined) return undefined;
+  const payload = terminal.roleOutcome.payloads?.at(-1);
+  const status = payload !== null && typeof payload === "object" && !Array.isArray(payload)
+    ? (payload as Record<string, unknown>).status
+    : undefined;
+  return typeof status === "string" && route.statuses.has(status)
+    ? undefined
+    : route.reask;
+}
+
+async function reaskUnreadablePostSubmissionStatus(
+  admitted: AdmittedRoleInvocation,
+  terminal: TerminalResult | undefined,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+): Promise<SeatRunResult | undefined> {
+  const message = unreadablePostSubmissionStatus(admitted, terminal);
+  if (message === undefined) return undefined;
+  return runPublicInstructionSeatResume(
+    { runId: admitted.runId, message },
+    { ...env, autoResumeLimit: 0 },
+    io,
+  );
+}
+
 function roleRecord(role: PackagedRole) {
   const record = packagedRoleMetadata(role);
   if (record === undefined) {
@@ -231,13 +321,21 @@ async function dispatchAdmitted(
   const record = roleRecord(admitted.role);
   await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
   const adapters = seatAdapters(admitted, env);
+  const held: string[] = [];
+  const turnIo: CliIo = AUDITED_ROLES.has(admitted.role)
+    || POST_SUBMISSION_ROUTING[admitted.role] !== undefined
+    ? { stdout: (value) => held.push(value), stderr: io.stderr }
+    : io;
   const execute = async (activeEnv: InstructionSeatRunEnv): Promise<SeatRunResult> => {
+    if (activeEnv.correlationId !== undefined && activeEnv.correlationId.trim() !== "") {
+      await recordAdmittedCorrelation(admitted, activeEnv.correlationId);
+    }
     const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
     if (auto) {
       return await runPostAdmissionResumable({
         admitted,
         env: activeEnv,
-        io,
+        io: turnIo,
         buildInitialRequest: () => buildInstructionSeatTurnRequest(
           admitted,
           roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
@@ -259,7 +357,7 @@ async function dispatchAdmitted(
     return await runPostAdmissionOneShot({
       admitted,
       env: activeEnv,
-      io,
+      io: turnIo,
       request: buildInstructionSeatTurnRequest(
         admitted,
         roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
@@ -268,7 +366,19 @@ async function dispatchAdmitted(
       ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
     });
   };
-  return execute(env);
+  const result = await execute(env);
+  const unreadableReask = await reaskUnreadablePostSubmissionStatus(
+    admitted,
+    result.terminal,
+    env,
+    io,
+  );
+  if (unreadableReask !== undefined) return unreadableReask;
+  if (AUDITED_ROLES.has(admitted.role) && result.terminal?.roleOutcome.kind === "accepted") {
+    return auditSubmittedRole(result, env, io);
+  }
+  for (const value of held) io.stdout(value);
+  return result;
 }
 
 /**
@@ -297,7 +407,7 @@ async function runOmittedLensBatch(
     packageRoot: env.packageRoot,
     ...(env.signal === undefined ? {} : { signal: env.signal }),
     ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
-    roleTurnHost: env.roleTurnHost,
+    ...(env.hostAdapters === undefined ? { roleTurnHost: env.roleTurnHost } : {}),
     ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
     principalAuthority: env.principalAuthority,
     ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
@@ -560,7 +670,13 @@ export async function runPublicInstructionSeat(
     throw error;
   }
   if (packagedAdmitsCountersign(role)) {
-    return runCountersignBody(parsed, env, io);
+    const held: string[] = [];
+    const result = await runCountersignBody(parsed, env, {
+      stdout: (value) => held.push(value), stderr: io.stderr,
+    });
+    if (result.terminal?.roleOutcome.kind === "accepted") return auditSubmittedRole(result, env, io);
+    for (const value of held) io.stdout(value);
+    return result;
   }
 
   if ("parallelLenses" in record && record.parallelLenses === true) {
@@ -713,7 +829,7 @@ export async function runPublicInstructionSeat(
     }
   }
   if (record.sameParent === "subject-source" && auditorSource !== undefined) {
-    await persistAdmittedSourceRunPath(admitted, auditorSource);
+    await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
   }
 
   const runAdmitted = async (): Promise<SeatRunResult> => {
@@ -765,10 +881,17 @@ export async function runPublicInstructionSeatResume(
   env: InstructionSeatRunEnv,
   io: CliIo,
 ): Promise<SeatRunResult> {
-  return runPostAdmissionSeatResume<AdmittedRoleInvocation>({
+  const resume = async () => {
+    const held: string[] = [];
+    const turnIo: CliIo = {
+      stdout: (value) => held.push(value),
+      stderr: io.stderr,
+    };
+    const result = await runPostAdmissionSeatResume<AdmittedRoleInvocation>({
+
     request,
     env,
-    io,
+    io: turnIo,
     load: async (effective) => {
       const loaded = await loadResumablePublicRole(env.home, effective.runId, env.principalAuthority);
       if (
@@ -804,10 +927,87 @@ export async function runPublicInstructionSeatResume(
       return { kind: "continue" as const, adapters: seatAdapters(admitted, env) };
     },
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
+    });
+    const unreadableReask = result.admitted === undefined
+      ? undefined
+      : await reaskUnreadablePostSubmissionStatus(
+        result.admitted,
+        result.terminal,
+        env,
+        io,
+      );
+    if (unreadableReask !== undefined) return unreadableReask;
+    if (result.admitted !== undefined && AUDITED_ROLES.has(result.admitted.role)
+      && result.terminal?.roleOutcome.kind === "accepted") {
+      return auditSubmittedRole(result, env, io);
+    }
+    for (const value of held) io.stdout(value);
+    return result;
+  };
+  let binding: Awaited<ReturnType<typeof readAuditorResumeBinding>>;
+  try {
+    const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority, true);
+    binding = loaded.admitted.role === "auditor"
+      ? await readAuditorResumeBinding(loaded.admitted.runDirectory)
+      : undefined;
+  } catch (error) {
+    if (!(error instanceof CliUsageError)) throw error;
+  }
+  if (binding !== undefined) {
+    return withAuditorSoulEnv({
+      subject: binding.subject,
+      sourceRunDirectory: binding.sourceRunDirectory,
+      run: resume,
+    });
+  }
+  return resume();
 }
 
-/** Continue the parent once any escalated child has submitted. */
+const QUEUE_CONCLUSIONS = new Set(["converged", "continue", "escalate"]);
+const GATE_CHILD_ROLES = new Set(["notary", "auditor", "inspector", "countersign"]);
+
+/**
+ * A gate child's conclusion outside the three states goes back to that child.
+ * The words are the existing officer re-ask. A host failure stops here.
+ */
+async function queueConclusionFromChild(
+  child: AdmittedRoleInvocation,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+): Promise<
+  | { readonly admitted: AdmittedRoleInvocation; readonly terminal: TerminalResult; readonly status: string }
+  | { readonly stop: SeatRunResult }
+  | undefined
+> {
+  if (!GATE_CHILD_ROLES.has(child.role)) return undefined;
+  let current = child;
+  for (;;) {
+    const terminal = await trySettlePublicSeat(
+      current,
+      env.principalAuthority,
+      undefined,
+    );
+    const status = latestQueueStatus(terminal);
+    if (terminal !== undefined && status !== undefined && QUEUE_CONCLUSIONS.has(status)) {
+      return { admitted: current, terminal, status };
+    }
+    const reasked = await runPublicInstructionSeatResume({
+      runId: current.runId,
+      message: officerConclusionReask(status),
+    }, env, io);
+    if (reasked.exitCode !== 0 || reasked.admitted === undefined || reasked.terminal === undefined) {
+      return { stop: reasked };
+    }
+    const reaskedStatus = latestQueueStatus(reasked.terminal);
+    if (reaskedStatus !== undefined && QUEUE_CONCLUSIONS.has(reaskedStatus)) {
+      return { admitted: reasked.admitted, terminal: reasked.terminal, status: reaskedStatus };
+    }
+    if (latestPayloadEscalated(reasked.terminal.roleOutcome)) return { stop: reasked };
+    current = reasked.admitted;
+  }
+}
+
+/** Continue the parent once a child has submitted. The child words ride the existing resume. */
 export async function continueParentAfterChild(
   parentRunId: string,
   child: AdmittedRoleInvocation,
@@ -815,18 +1015,235 @@ export async function continueParentAfterChild(
   io: CliIo,
 ): Promise<SeatRunResult> {
   const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority, true);
-  if (loaded.run.state !== "admitted") {
+  if (loaded.run.state !== "admitted" && !AUDITED_ROLES.has(loaded.admitted.role)) {
     return runPublicInstructionSeatResume({ runId: parentRunId }, env, io);
   }
   const admitted = loaded.admitted;
-  if (admitted.role === "countersign" && admitted.ticketNumber !== undefined) {
+  // Court diarist refresh advances only after a diarist child; gate officers
+  // (notary/auditor/…) resume straight into queueConclusionFromChild (#1057).
+  if (admitted.role === "countersign" && admitted.ticketNumber !== undefined
+    && child.role === "diarist") {
     const refresh = await runCountersignCourtDiaristStation(admitted, env, io, child.ticketNumber);
     if (refresh !== undefined) {
       io.stdout(formatTerminalResult(refresh.terminal));
       return { exitCode: 0, admitted, terminal: refresh.terminal };
     }
   }
+  const resolved = await queueConclusionFromChild(child, env, io);
+  if (resolved !== undefined && "stop" in resolved) return resolved.stop;
+  if (resolved !== undefined && resolved.status === "escalate") {
+    return { exitCode: 0, admitted: resolved.admitted, terminal: resolved.terminal };
+  }
+  if (resolved !== undefined && (resolved.status === "continue" || resolved.status === "converged")) {
+    if (AUDITED_ROLES.has(admitted.role) && resolved.status === "converged") {
+      const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, undefined);
+      if (terminal?.roleOutcome.kind !== "accepted") throw new Error("pending submission is not recorded");
+      return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted.role, latestQueuePayload(resolved.terminal), resolved.admitted.runId);
+    }
+    return runPublicInstructionSeatResume({
+      runId: parentRunId,
+      message: readableGateItem(latestQueuePayload(resolved.terminal)),
+    }, { ...env, autoResumeLimit: 0 }, io);
+  }
   const result = await dispatchAdmitted(admitted, env, { ...io, omitFailureStderrDiagnostic: true });
   showResumeErrorPointer(io, result.exitCode, result.terminal);
   return result;
 }
+
+/** Finished submissions enter the existing audit gate after their tool call has returned. */
+async function auditSubmittedRole(
+  turn: SeatRunResult,
+  env: InstructionSeatRunEnv,
+  io: CliIo,
+  passedOfficer?: PackagedRole,
+  passedReceipt?: unknown,
+  passedRunId?: string,
+): Promise<SeatRunResult> {
+  const admitted = turn.admitted;
+  if (admitted === undefined || !AUDITED_ROLES.has(admitted.role)
+    || turn.terminal?.roleOutcome.kind !== "accepted") return turn;
+  const accepted = turn.terminal.roleOutcome.payloads?.at(-1);
+  if (accepted === undefined) throw new Error("accepted submission has no payload");
+  const record = accepted !== null && typeof accepted === "object" && !Array.isArray(accepted)
+    ? accepted as Record<string, unknown> : undefined;
+  const status = admitted.role === "secretariat" ? record?.secretariatStatus : record?.status;
+  if (admitted.role === "secretariat" && status !== "converged" && status !== "escalate") {
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message: SECRETARIAT_STATUS_REASK },
+      { ...env, autoResumeLimit: 0 }, io);
+  }
+  if (admitted.role === "countersign" && (typeof status !== "string" || !QUEUE_CONCLUSIONS.has(status))) {
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message: COUNTERSIGN_STATUS_REASK },
+      { ...env, autoResumeLimit: 0 }, io);
+  }
+  // Self-escalation is a valid open routing state for these seats only.
+  // Doctor's declared domain is completed|refused — an open "escalate" must
+  // not skip its mandatory auditor (#1057 / PR #1075).
+  const selfEscalationSkipsAudit = status === "escalate"
+    && (admitted.role === "judge" || admitted.role === "secretariat"
+      || admitted.role === "countersign");
+  const skipAudit = selfEscalationSkipsAudit
+    || ((admitted.role === "fixer" || admitted.role === "coder")
+      && (typeof status !== "string" || !WORKER_DONE_STATUSES.has(status)));
+  if (skipAudit) {
+    io.stdout(formatTerminalResult(turn.terminal));
+    return turn;
+  }
+  const rows = await readRecordedSubmissionRows(admitted.projectRoot, admitted.runId, env.home);
+  const acceptedRow = [...rows].reverse().find((row) => row.role === admitted.role && row.kind === "accepted");
+  const toolCallId = acceptedRow?.toolCallId;
+  if (toolCallId === undefined) throw new Error("accepted submission has no tool call identity");
+  const sessionFile = env.principalAuthority.decode(admitted.principal).sessionFile;
+  const entries = admitted.role === "doctor" ? await readBoundSessionEntries(sessionFile) : [];
+  const context: HostContext = {
+    cwd: admitted.projectRoot,
+    mode: "print",
+    model: undefined,
+    runDirectory: admitted.runDirectory,
+    sessionManager: {
+      getSessionFile: () => sessionFile,
+      getSessionDir: () => dirname(sessionFile),
+      getEntries: () => entries as unknown as Iterable<{ type: string }>,
+      getLeafEntry: () => undefined,
+      getLeafId: () => admitted.runId,
+      getHeader: () => ({ type: "session", id: admitted.runId }),
+    },
+    abort() {},
+  };
+  if (admitted.role === "doctor") {
+    if (passedOfficer !== "auditor") {
+      let lastSummon: PublicSummonResult | undefined;
+      const decision = await createPiDoctorAuditor()({
+        context, submission: accepted,
+        ...(env.signal === undefined ? {} : { signal: env.signal }),
+        summonAuditor: async (subject, sourceRunDirectory, signal, reask, submission) => {
+          const summoned = await summonPublicRole({
+            role: "auditor",
+            argv: ["--subject", subject, "--source-run", sourceRunDirectory,
+              `${AUDITOR_DOSSIER_PROMPT}${sourceRunDirectory}`],
+            cwd: admitted.projectRoot, home: env.home, packageRoot: env.packageRoot,
+            principalAuthority: env.principalAuthority,
+            correlationId: admitted.runId,
+            ...(env.credentials === undefined ? {} : { credentials: env.credentials }),
+            ...(env.hostAdapters === undefined ? { roleTurnHost: env.roleTurnHost } : { hostAdapters: env.hostAdapters }),
+            ...(signal === undefined ? {} : { signal }),
+            ...(reask === undefined ? {} : { reviewReask: reask }),
+            ...(submission === undefined ? {} : { gateReviewInstruction: submission }),
+          });
+          const officerSession = sessionFileFromPublicSummon(summoned);
+          if (officerSession !== undefined) {
+            bookDirectOfficerRunPointer({
+              parentSessionFile: sessionFile, officer: "auditor", sessionFile: officerSession,
+              ...(summoned.runDirectory === undefined ? {} : { runDirectory: summoned.runDirectory }),
+            });
+          }
+          lastSummon = summoned;
+          return summoned;
+        },
+      });
+      if (decision.status === "continue") {
+        return runPublicInstructionSeatResume({
+          runId: admitted.runId, message: readableGateItem(decision.receipt ?? decision.violations),
+        }, { ...env, autoResumeLimit: 0 }, io);
+      }
+      if (decision.status !== "converged") {
+        if (lastSummon?.terminal !== undefined) {
+          io.stdout(formatTerminalResult(lastSummon.terminal));
+          return { exitCode: lastSummon.exitCode,
+            ...(lastSummon.admitted === undefined ? {} : { admitted: lastSummon.admitted }),
+            terminal: lastSummon.terminal };
+        }
+        throw new Error(`doctor audit did not converge: ${decision.status}`);
+      }
+    }
+  } else {
+    const summonOfficer = createDefaultGateOfficerSummon({
+      cwd: admitted.projectRoot,
+      home: env.home,
+      packageRoot: env.packageRoot,
+      roleTurnHost: env.roleTurnHost,
+      ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+    });
+    let chain: Awaited<ReturnType<typeof runJudgeGates>>;
+    let officerRunId = passedRunId;
+    const runGate = (subject: Parameters<typeof requireSubmissionGate>[0]["subject"]) =>
+      requireSubmissionGate({
+        context,
+        subject,
+        toolCallId,
+        submission: accepted,
+        summonOfficer,
+        ...(env.signal === undefined ? {} : { signal: env.signal }),
+        hostActions: {
+          failInfrastructure(error): never { throw error; },
+          bindSubmissionNonPass() {},
+        },
+      });
+    if (admitted.role === "judge") {
+      chain = await runJudgeGates({
+        gateAlreadyConverged: async (subject) => passedOfficer === "auditor"
+          || (passedOfficer === "notary" && subject.kind === "judge_draft"),
+        runGate,
+      });
+    } else {
+      const subject = admitted.role === "fixer" || admitted.role === "coder"
+        ? { kind: "worker_completion" as const }
+        : admitted.role === "secretariat"
+          ? { kind: "secretariat_verdict" as const }
+          : { kind: "countersign_verdict" as const };
+      const officer = gateOfficerForSubject(subject);
+      if (passedOfficer === officer) {
+        chain = { status: "converged", passes: [] };
+      } else {
+        const pass = await runGate(subject);
+        if (pass === undefined) throw new Error("audit gate returned no conclusion");
+        officerRunId = pass.runId;
+        chain = {
+          status: pass.status,
+          passes: [{
+            subject,
+            status: pass.status,
+            receipt: pass.receipt,
+            ...(pass.runId === undefined ? {} : { runId: pass.runId }),
+            ...(pass.runDirectory === undefined ? {} : { runDirectory: pass.runDirectory }),
+          }],
+        };
+      }
+    }
+    if (chain.status === "escalate") {
+      const escalation = chain.passes.at(-1);
+      const escalatedRunId = escalation?.runId
+        ?? (escalation?.runDirectory === undefined
+          ? undefined : runIdFromRunDirectory(escalation.runDirectory));
+      if (escalatedRunId === undefined) throw new Error("escalated audit has no resumable run identity");
+      const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority, true);
+      const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, undefined);
+      if (terminal === undefined) throw new Error("escalated audit has no terminal result");
+      io.stdout(formatTerminalResult(terminal));
+      return { exitCode: 0, admitted: officer.admitted, terminal };
+    }
+    if (chain.status === "continue") {
+      return runPublicInstructionSeatResume({
+        runId: admitted.runId,
+        message: readableGateItem(chain.passes.at(-1)?.receipt),
+      }, { ...env, autoResumeLimit: 0 }, io);
+    }
+    if (admitted.role === "secretariat") {
+      const pass = chain.passes.at(-1);
+      const receipt = pass?.receipt ?? passedReceipt;
+      if (receipt !== undefined) {
+        await env.sessionAppender(env.principalAuthority, admitted.principal, SECRETARIAT_GATE_OFFICER_ENTRY_TYPE, {
+          officer: "countersign", receipt,
+          ...(officerRunId === undefined ? {} : { runId: officerRunId }),
+        });
+      }
+    }
+  }
+  // The turn already settled this court (payloads, usage, autoResumeCount, history).
+  // Audit only adds gate rounds and, for 中书省, the officer fact. A second
+  // settle would republish the same attempt.
+  if (turn.terminal === undefined) throw new Error(`audited ${admitted.role} submission did not settle`);
+  const terminal = await attachPostAuditProjection(admitted, env.principalAuthority, turn.terminal);
+  turn = { ...turn, terminal };
+  io.stdout(formatTerminalResult(terminal));
+  return turn;
+}

package/src/public-cli/invocation.ts

@@ -519,6 +519,7 @@ async function mergeInvocationIdentityPage(
 export async function persistAdmittedSourceRunPath(
   admitted: AdmittedRoleInvocation,
   sourceRunPath: string,
+  auditorSubject?: "judge" | "doctor",
 ): Promise<void> {
   if (sourceRunPath.trim() === "") {
     throw new Error("persistAdmittedSourceRunPath requires a non-empty sourceRunPath");
@@ -528,15 +529,20 @@ export async function persistAdmittedSourceRunPath(
     string,
     unknown
   >;
-  if (typeof current.sourceRunPath === "string") {
-    if (current.sourceRunPath === sourceRunPath) return;
+  if (typeof current.sourceRunPath === "string" && current.sourceRunPath !== sourceRunPath) {
     throw new Error(
       `persistAdmittedSourceRunPath refuses to replace ${current.sourceRunPath} with ${sourceRunPath}`,
     );
   }
+  const sameSubject = auditorSubject === undefined || current.auditorSubject === auditorSubject;
+  if (current.sourceRunPath === sourceRunPath && sameSubject) return;
   await writeFile(
     admittedPath,
-    `${JSON.stringify({ ...current, sourceRunPath }, null, 2)}\n`,
+    `${JSON.stringify({
+      ...current,
+      sourceRunPath,
+      ...(auditorSubject === undefined ? {} : { auditorSubject }),
+    }, null, 2)}\n`,
     "utf8",
   );
 }

package/src/public-cli/post-admission.ts

@@ -1084,7 +1084,6 @@ export async function dispatchPostAdmissionTurn<
         directHostFailureSignal
         || (result.code !== null && result.code !== 0)
         || resolution.knownFailure !== undefined;
-
       settled = await adapters.trySettle(admitted, env.principalAuthority, courtScope);
       if (settled !== undefined) {
         settled = await attachRecordedSubmissions(admitted, settled, courtScope) as T;