@akagilnc/pi-workflow-roles 0.1.5153 → 0.1.5196

package/dist/public-cli/instruction-seat-run.js

@@ -4,22 +4,89 @@
  * 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.js";
+import { bookDirectOfficerRunPointer } from "../archivist-record-pointer.js";
+import { createPiDoctorAuditor } from "../doctor-auditor.js";
+import { officerConclusionReask, gateOfficerForSubject } from "../gatekeeper-role.js";
+import { runJudgeGates } from "../judge-role.js";
+import { WORKER_DONE_STATUSES } from "../worker-submission-contracts.js";
+import { SECRETARIAT_GATE_OFFICER_ENTRY_TYPE } from "../secretariat-contracts.js";
+import { readableGateItem } from "../readable-gate-item.js";
+import { runIdFromRunDirectory } from "../run-terminal-artifacts.js";
+import { createDefaultGateOfficerSummon, requireSubmissionGate } from "../submission-gate.js";
+import { readRecordedSubmissionRows } from "../submission-ledger.js";
+import { summonPublicRole } from "../public-role-summons.js";
+import { sessionFileFromPublicSummon } from "../session-assistant-usage.js";
+import { latestQueuePayload, latestQueueStatus, } from "../submission-gate.js";
 import { isSafePositiveTicketNumber, readBoardTicketNumber } from "../run-ticket-number.js";
 import { NotarySourceRunError, resolveNotarySourceRunLocator } from "../notary-source-run.js";
 import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
 import { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSourceOnResume, packagedRoleMetadata, } from "../packaged-role-registry.js";
-import { isAuditorSoulRole } from "../auditor-soul.js";
+import { isAuditorSoulRole, readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
 import { admitPublicRole, bindAdmittedTicketNumber, bindCourtTicketNumbersOnAdmitted, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, withPreparedAttachments, } from "./invocation.js";
 import { presentControlledFailure, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, parentRunPathFromGatePointerInstruction, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
-import { presentStructuralRejection, seatKnownFailureResolver, trySettlePublicSeat, } from "./settlement.js";
+import { presentStructuralRejection, readBoundSessionEntries, seatKnownFailureResolver, attachPostAuditProjection, trySettlePublicSeat, } from "./settlement.js";
 import { warnMissingMethodSkills } from "./machine-method-skills.js";
 import { formatTerminalResult, isLawfulTypedTerminalOutcome, } from "./terminal.js";
 import { admittedSeatTurnDetails, projectRoleTurnRequest, requiredMethodSkills, } from "./turn-request.js";
-import { invokeCourtDiarist, runCountersignCourtDiaristStation, } from "./countersign-run.js";
+import { invokeCourtDiarist, latestPayloadEscalated, runCountersignCourtDiaristStation, } from "./countersign-run.js";
+const AUDITED_ROLES = new Set(["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 = new Set([
+    "planned", "completed", "refused", "partially_completed", "unfinished",
+]);
+const WORKER_STATUS_REASK = "status 不是 planned、completed、refused、partially_completed、unfinished 之一。请重新交卷，status 写明其一。";
+const DOCTOR_ROUTING_STATUSES = new Set(["completed", "refused"]);
+const DOCTOR_STATUS_REASK = "status 不是 completed、refused 之一。请重新交卷，status 写明其一。";
+const POST_SUBMISSION_ROUTING = {
+    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,
+    },
+};
+function unreadablePostSubmissionStatus(admitted, terminal) {
+    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.status
+        : undefined;
+    return typeof status === "string" && route.statuses.has(status)
+        ? undefined
+        : route.reask;
+}
+async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io) {
+    const message = unreadablePostSubmissionStatus(admitted, terminal);
+    if (message === undefined)
+        return undefined;
+    return runPublicInstructionSeatResume({ runId: admitted.runId, message }, { ...env, autoResumeLimit: 0 }, io);
+}
 function roleRecord(role) {
     const record = packagedRoleMetadata(role);
     if (record === undefined) {
@@ -128,13 +195,21 @@ async function dispatchAdmitted(admitted, env, io) {
     const record = roleRecord(admitted.role);
     await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
     const adapters = seatAdapters(admitted, env);
+    const held = [];
+    const turnIo = AUDITED_ROLES.has(admitted.role)
+        || POST_SUBMISSION_ROUTING[admitted.role] !== undefined
+        ? { stdout: (value) => held.push(value), stderr: io.stderr }
+        : io;
     const execute = async (activeEnv) => {
+        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) })),
                 buildResumeRequest: () => buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, {
                     kind: "resume",
@@ -150,13 +225,22 @@ async function dispatchAdmitted(admitted, env, io) {
         return await runPostAdmissionOneShot({
             admitted,
             env: activeEnv,
-            io,
+            io: turnIo,
             request: buildInstructionSeatTurnRequest(admitted, roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) })),
             adapters,
             ...(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;
 }
 /**
  * Omitted lens on a parallel-lens seat: two ordinary single-axis runs, no parent run.
@@ -179,7 +263,7 @@ async function runOmittedLensBatch(argv, parsed, env, io) {
         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 }),
@@ -421,7 +505,15 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         throw error;
     }
     if (packagedAdmitsCountersign(role)) {
-        return runCountersignBody(parsed, env, io);
+        const held = [];
+        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) {
         if (parsed.baseRevision === undefined) {
@@ -559,7 +651,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         }
     }
     if (record.sameParent === "subject-source" && auditorSource !== undefined) {
-        await persistAdmittedSourceRunPath(admitted, auditorSource);
+        await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
     }
     const runAdmitted = async () => {
         await markRunAdmitted(admitted, env.principalAuthority);
@@ -605,57 +697,345 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     return runAdmitted();
 }
 export async function runPublicInstructionSeatResume(request, env, io) {
-    return runPostAdmissionSeatResume({
-        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 summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
-            return buildInstructionSeatTurnRequest(admitted, {
-                ...resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared),
-            });
-        },
-        adapters: {
-            trySettle: async () => undefined,
-        },
-        afterAdmittedLoad: async (admitted) => {
-            await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
-            return { kind: "continue", adapters: seatAdapters(admitted, env) };
-        },
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
+    const resume = async () => {
+        const held = [];
+        const turnIo = {
+            stdout: (value) => held.push(value),
+            stderr: io.stderr,
+        };
+        const result = await runPostAdmissionSeatResume({
+            request,
+            env,
+            io: turnIo,
+            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 summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
+                return buildInstructionSeatTurnRequest(admitted, {
+                    ...resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared),
+                });
+            },
+            adapters: {
+                trySettle: async () => undefined,
+            },
+            afterAdmittedLoad: async (admitted) => {
+                await warnMissingMethodSkills(env.home, env.host, admitted.role, requiredMethodSkills(admitted), io.stdout);
+                return { kind: "continue", 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;
+    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, env, io) {
+    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, child, env, io) {
     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, env, io, passedOfficer, passedReceipt, passedRunId) {
+    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 : 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 = {
+        cwd: admitted.projectRoot,
+        mode: "print",
+        model: undefined,
+        runDirectory: admitted.runDirectory,
+        sessionManager: {
+            getSessionFile: () => sessionFile,
+            getSessionDir: () => dirname(sessionFile),
+            getEntries: () => entries,
+            getLeafEntry: () => undefined,
+            getLeafId: () => admitted.runId,
+            getHeader: () => ({ type: "session", id: admitted.runId }),
+        },
+        abort() { },
+    };
+    if (admitted.role === "doctor") {
+        if (passedOfficer !== "auditor") {
+            let lastSummon;
+            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;
+        let officerRunId = passedRunId;
+        const runGate = (subject) => requireSubmissionGate({
+            context,
+            subject,
+            toolCallId,
+            submission: accepted,
+            summonOfficer,
+            ...(env.signal === undefined ? {} : { signal: env.signal }),
+            hostActions: {
+                failInfrastructure(error) { 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" }
+                : admitted.role === "secretariat"
+                    ? { kind: "secretariat_verdict" }
+                    : { kind: "countersign_verdict" };
+            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/dist/public-cli/invocation.js

@@ -148,18 +148,23 @@ async function mergeInvocationIdentityPage(runDirectory, fields) {
  * Persist parent --source-run path onto admitted-request for officer resume lookup (#747).
  * Reuses the existing notary sourceRunPath key; does not invent a new field name.
  */
-export async function persistAdmittedSourceRunPath(admitted, sourceRunPath) {
+export async function persistAdmittedSourceRunPath(admitted, sourceRunPath, auditorSubject) {
     if (sourceRunPath.trim() === "") {
         throw new Error("persistAdmittedSourceRunPath requires a non-empty sourceRunPath");
     }
     const admittedPath = admitted.admittedRequestPath;
     const current = JSON.parse(await readFile(admittedPath, "utf8"));
-    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}`);
     }
-    await writeFile(admittedPath, `${JSON.stringify({ ...current, sourceRunPath }, null, 2)}\n`, "utf8");
+    const sameSubject = auditorSubject === undefined || current.auditorSubject === auditorSubject;
+    if (current.sourceRunPath === sourceRunPath && sameSubject)
+        return;
+    await writeFile(admittedPath, `${JSON.stringify({
+        ...current,
+        sourceRunPath,
+        ...(auditorSubject === undefined ? {} : { auditorSubject }),
+    }, null, 2)}\n`, "utf8");
 }
 /**
  * Bind a post-admission resolved ticketNumber onto the in-memory admitted