@akagilnc/pi-workflow-roles 0.1.5714 → 0.1.5753

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

@@ -8,33 +8,30 @@ import { MISSING_TICKET_REASK_MATERIAL } from "../report-ticket-tool.js";
 import { isUnboundRunDirectory, sessionFileOf } from "../role-run-placement.js";
 import { rewriteRunDirectoryPathValue } from "../role-run-relocation.js";
 import { readPackageMaterial } from "../session-opening-materials.js";
-import { bookDirectOfficerRunPointer, readDirectOfficerRunPointer } from "../archivist-record-pointer.js";
 import { createPiDoctorAuditor } from "../doctor-auditor.js";
 import { officerConclusionReask, gateOfficerForSubject } from "../gatekeeper-role.js";
 import { receivedDiscriminator } from "../submission-errors.js";
 import { REVIEW_QUEUE_STATUSES } from "../review-submission.js";
-import { runJudgeGates } from "../judge-role.js";
+import { JUDGE_GATES, 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 { deliveryLimitFromConfig } from "../receipt-delivery-policy.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 { packagedAdmitsCountersign, packagedBindsBoardTicket, packagedRebindSourceOnResume, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { readAuditorResumeBinding } from "../auditor-soul.js";
 import { CliUsageError } from "./cli-errors.js";
-import { admitPublicRole, bindAdmittedTicketNumber, appendCallerFileFlagPaths, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedSourceRunPath, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, } from "./invocation.js";
+import { admitPublicRole, admittedSourceRunPath, bindAdmittedTicketNumber, appendCallerFileFlagPaths, buildInstructionTransportPrompt, materializeCountersignInvocation, persistAdmittedAuditedSubmissionToolCallId, persistAdmittedSourceRunPath, readAdmittedAuditedSubmissionToolCallId, recordAdmittedCorrelation, recordChildDiaristRun, relocateAdmittedRunToTicket, } from "./invocation.js";
 import { bindDiaristAssertedTicketNumber, presentControlledFailure, packageFaultNoteFor, prepareSummonsResumeMaterials, roleTurnOptions, runPostAdmissionOneShot, runPostAdmissionResumable, runPostAdmissionSeatResume, showResumeErrorPointer, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
 import { presentTerminal } from "./auto-resume.js";
 import { buildAutoResumeContinuationPrompt, loadResumablePublicRole, markRunAdmitted, readCurrentCourt, } from "./run-lifecycle.js";
 import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
-import { presentStructuralRejection, readBoundSessionEntries, attachPostAuditCountersignFact, trySettlePublicSeat, } from "./settlement.js";
+import { presentStructuralRejection, readBoundSessionEntries, 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";
@@ -120,17 +117,14 @@ async function presentOriginalVolume(held, terminal, io, runDirectory) {
     for (const value of held)
         io.stdout(value);
 }
-/** Runtime fact beside the original volume. Payloads stay as submitted. */
-function withUnsettledDirection(parent, officer) {
+/**
+ * Mark this leg's terminal that subsequent audit did not settle a queue word.
+ * Other-seat receipts / run ids stay on those runs — not copied here (#1195).
+ */
+function withUnsettledDirection(parent) {
     const outcome = parent.roleOutcome;
     if (outcome.kind !== "accepted" && outcome.kind !== "audit_escalation")
         return parent;
-    const officerOutcome = officer?.roleOutcome;
-    const officerPayloads = officer?.submissions !== undefined && officer.submissions.length > 0
-        ? officer.submissions
-        : officerOutcome !== undefined && officerOutcome.kind !== "no_receipt"
-            ? officerOutcome.payloads ?? []
-            : [];
     return {
         ...parent,
         roleOutcome: {
@@ -139,9 +133,6 @@ function withUnsettledDirection(parent, officer) {
                 ...(outcome.decisiveFacts ?? {}),
                 directionUnsettled: true,
                 subsequentAudit: "incomplete",
-                ...(officerOutcome === undefined ? {} : { officerRole: officerOutcome.role }),
-                ...(officer?.runId === undefined ? {} : { officerRunId: officer.runId }),
-                ...(officerPayloads.length === 0 ? {} : { officerPayloads }),
             },
         },
     };
@@ -154,11 +145,13 @@ function heldUnreadableTerminal(terminal) {
     const status = latestQueueStatus(terminal);
     return typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status);
 }
-async function presentUnsettledAudit(parent, officer, io, runDirectory) {
-    const terminal = withUnsettledDirection(parent, officer);
+/**
+ * Present the actual audit seat's volume for an unreadable conclusion (ADR 0055).
+ * Parent is not given a copy of the officer receipt (#1195).
+ */
+async function presentUnsettledOfficer(officer, io, runDirectory) {
+    const terminal = withUnsettledDirection(officer);
     await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
-    if (officer !== undefined)
-        await presentTerminal(officer, { ...io, omitFailureStderrDiagnostic: true }, runDirectory);
     return terminal;
 }
 async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io, message = unreadablePostSubmissionStatus(admitted, terminal)) {
@@ -167,7 +160,11 @@ async function reaskUnreadablePostSubmissionStatus(admitted, terminal, env, io,
     const next = withUnreadableReask(env);
     if (next === undefined)
         return UNREADABLE_REASK_EXHAUSTED;
-    return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: message } }, next, io);
+    return runPublicInstructionSeatResume({
+        runId: admitted.runId,
+        runDirectory: admitted.runDirectory,
+        summons: { instruction: message },
+    }, next, io);
 }
 /**
  * #1171: sealed submission still leaves the leg unbound → soft reask once.
@@ -204,7 +201,11 @@ async function reaskMissingTicketOnce(admitted, terminal, env, io) {
         softTicketReaskTurn: true,
         softTicketReaskOwnership,
     };
-    const result = await runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction } }, softReaskEnv, io);
+    const result = await runPublicInstructionSeatResume({
+        runId: admitted.runId,
+        runDirectory: admitted.runDirectory,
+        summons: { instruction },
+    }, softReaskEnv, io);
     if (softTicketReaskOwnership.sealedSubstitute
         || terminalCarriesSealedSubmission(result.terminal)) {
         return { kind: "nested_owns", result };
@@ -347,6 +348,7 @@ async function loadLedgerPeerBody(sourceRunDirectory, projectRoot, home) {
  * One delivery rule for review-seat dialogue on new turns and same-parent resume
  * (#1166 / ADR 0085 / ADR 0087): explicit reask → non-empty caller dispatch →
  * source-only ledger peer body. Identity stays in startup materials.
+ * #1195: ticket-court notary skips peer-body preload (countersign source only).
  */
 async function resolveReviewSeatDialogueBody(input) {
     const reask = input.reask;
@@ -355,26 +357,26 @@ async function resolveReviewSeatDialogueBody(input) {
     const caller = input.callerInstruction ?? "";
     if (caller.length > 0)
         return caller;
-    const sourceRunPath = input.sourceRunPath?.trim() ?? "";
-    if (sourceRunPath === "")
+    const sourceRunPath = admittedSourceRunPath(input)?.trim();
+    if (sourceRunPath === undefined)
         return undefined;
+    if (input.role === "notary") {
+        const { isTicketCourtCountersignSource } = await import("../run-terminal-artifacts.js");
+        if (isTicketCourtCountersignSource(sourceRunPath))
+            return undefined;
+    }
     return await loadLedgerPeerBody(sourceRunPath, input.projectRoot, input.home);
 }
-function admittedSourceRunPath(admitted) {
-    return "sourceRunPath" in admitted
-        && typeof admitted.sourceRunPath === "string"
-        ? admitted.sourceRunPath.trim()
-        : "";
-}
 async function resolveInitialPrompt(admitted, env) {
     const record = roleRecord(admitted.role);
     if ("reaskPrompt" in record && record.reaskPrompt === true) {
         const sourceRunPath = admittedSourceRunPath(admitted);
         const reask = env.reviewReask ?? env.gateReviewInstruction;
         const body = await resolveReviewSeatDialogueBody({
+            role: admitted.role,
             ...(reask === undefined ? {} : { reask }),
             callerInstruction: admitted.instruction,
-            ...(sourceRunPath === "" ? {} : { sourceRunPath }),
+            ...(sourceRunPath === undefined ? {} : { sourceRunPath }),
             projectRoot: admitted.projectRoot,
             home: env.home,
         });
@@ -602,16 +604,21 @@ function resumeSameParentInstructionSeat(input) {
         ...(input.ticketNumber === undefined ? {} : { ticketNumber: input.ticketNumber }),
         freshSummons: input.env.freshSummons,
         summons: input.summons,
-        resume: (runId, materials) => runPublicInstructionSeatResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, input.env, input.io),
+        resume: (runId, materials, runDirectory) => runPublicInstructionSeatResume({
+            runId,
+            runDirectory,
+            ...(materials === undefined ? {} : { summons: materials }),
+        }, input.env, input.io),
     });
 }
 /**
  * Same delivery rule as resolveInitialPrompt for same-parent resume summons.
  * Reask / explicit caller text / source-only ledger peer — one authority.
  */
-async function sameParentDialogue(env, fallback, sourceRunPath, projectRoot) {
+async function sameParentDialogue(env, fallback, sourceRunPath, projectRoot, role) {
     const reask = env.reviewReask ?? env.gateReviewInstruction;
     const body = await resolveReviewSeatDialogueBody({
+        role,
         ...(reask === undefined ? {} : { reask }),
         callerInstruction: fallback.instruction,
         sourceRunPath,
@@ -753,6 +760,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     let auditorSource;
     let auditorTicket;
     let resolvedNotarySource;
+    let instructionSourceRunPath;
     if (record.sameParent === "subject-source") {
         if (parsed.subject === undefined) {
             presentStructuralRejection(new CliUsageError("auditor --subject requires judge|doctor"), io);
@@ -780,7 +788,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             ...(await sameParentDialogue(env, {
                 instruction: parsed.instruction ?? "",
                 instructionEmpty: (parsed.instruction ?? "").length === 0,
-            }, sourceDirectory, projectRoot)),
+            }, sourceDirectory, projectRoot, role)),
             attachmentPaths: parsed.attachmentPaths ?? [],
         };
         const resumed = await withAuditorSoulEnv({
@@ -801,9 +809,8 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     if (record.sameParent === "source-run") {
         // #1166: structured --source-run only. Instruction bytes stay opaque caller/peer text.
         if (parsed.sourceRun !== undefined) {
-            let parentRunPath;
             try {
-                parentRunPath = (await resolveNotarySourceRunLocator({
+                instructionSourceRunPath = (await resolveNotarySourceRunLocator({
                     projectRoot,
                     sourceRun: parsed.sourceRun,
                     home: env.home,
@@ -816,12 +823,13 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
                 }
                 throw error;
             }
+            const parentRunPath = instructionSourceRunPath;
             const summons = {
                 sourceRunPath: parentRunPath,
                 ...(await sameParentDialogue(env, {
                     instruction: parsed.instruction ?? "",
                     instructionEmpty: (parsed.instruction ?? "").length === 0,
-                }, parentRunPath, projectRoot)),
+                }, parentRunPath, projectRoot, role)),
                 attachmentPaths: parsed.attachmentPaths ?? [],
             };
             const resumed = await resumeSameParentInstructionSeat({
@@ -855,7 +863,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
         const summons = {
             sourceRunPath: source.runDirectory,
             sourceRun: source,
-            ...(await sameParentDialogue(env, { instruction: "", instructionEmpty: true }, source.runDirectory, projectRoot)),
+            ...(await sameParentDialogue(env, { instruction: "", instructionEmpty: true }, source.runDirectory, projectRoot, role)),
         };
         resolvedNotarySource = source;
         const resumed = await resumeSameParentInstructionSeat({
@@ -883,14 +891,9 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
             return rejected;
         throw error;
     }
-    if (record.sameParent === "source-run" && parsed.sourceRun !== undefined) {
-        const parentRunPath = (await resolveNotarySourceRunLocator({
-            projectRoot,
-            sourceRun: parsed.sourceRun,
-            home: env.home,
-        })).runDirectory;
-        await persistAdmittedSourceRunPath(admitted, parentRunPath);
-        admitted = { ...admitted, sourceRunPath: parentRunPath };
+    if (instructionSourceRunPath !== undefined) {
+        await persistAdmittedSourceRunPath(admitted, instructionSourceRunPath);
+        admitted = { ...admitted, sourceRunPath: instructionSourceRunPath };
     }
     if (record.sameParent === "subject-source" && auditorSource !== undefined) {
         await persistAdmittedSourceRunPath(admitted, auditorSource, auditorSubject);
@@ -941,6 +944,7 @@ export async function runPublicInstructionSeat(argv, env, io, role, parseArgv) {
     return runAdmitted();
 }
 export async function runPublicInstructionSeatResume(request, env, io) {
+    let selectedRequest = request;
     const resume = async () => {
         const held = [];
         const turnIo = {
@@ -948,11 +952,11 @@ export async function runPublicInstructionSeatResume(request, env, io) {
             stderr: io.stderr,
         };
         const result = await runPostAdmissionSeatResume({
-            request,
+            request: selectedRequest,
             env,
             io: turnIo,
             load: async (effective) => {
-                const loaded = await loadResumablePublicRole(env.home, effective.runId, env.principalAuthority);
+                const loaded = await loadResumablePublicRole(env.home, effective.runId, env.principalAuthority, effective.runDirectory === undefined ? undefined : { runDirectory: effective.runDirectory });
                 if (packagedRebindSourceOnResume(loaded.admitted.role)
                     && effective.summons?.sourceRunPath !== undefined
                     && effective.summons.sourceRun !== undefined) {
@@ -990,9 +994,10 @@ export async function runPublicInstructionSeatResume(request, env, io) {
     };
     let binding;
     try {
-        const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority);
+        const loaded = await loadResumablePublicRole(env.home, request.runId, env.principalAuthority, request.runDirectory === undefined ? undefined : { runDirectory: request.runDirectory });
+        selectedRequest = { ...request, runDirectory: loaded.admitted.runDirectory };
         binding = loaded.admitted.role === "auditor"
-            ? await readAuditorResumeBinding(loaded.admitted.runDirectory)
+            ? await readAuditorResumeBinding(loaded.admitted)
             : undefined;
     }
     catch (error) {
@@ -1060,23 +1065,25 @@ async function queueConclusionFromChild(child, env, io) {
 }
 /** 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);
+    const knownParentDirectory = admittedSourceRunPath(child);
+    const loaded = await loadResumablePublicRole(env.home, parentRunId, env.principalAuthority, knownParentDirectory === undefined ? undefined : { runDirectory: knownParentDirectory });
     if (loaded.run.state !== "admitted" && !AUDITED_ROLES.has(loaded.admitted.role)) {
-        return runPublicInstructionSeatResume({ runId: parentRunId }, env, io);
+        return runPublicInstructionSeatResume({
+            runId: parentRunId,
+            runDirectory: loaded.admitted.runDirectory,
+        }, env, io);
     }
     const admitted = loaded.admitted;
     const resolved = await queueConclusionFromChild(child, env, io);
     if (resolved !== undefined && "stop" in resolved) {
         const stopped = resolved.stop;
+        // Unreadable child conclusion stays on that seat — resume 审核席本人 (ADR 0055 / #1195).
         if (stopped.exitCode === 0
             && heldUnreadableTerminal(stopped.terminal)
-            && stopped.terminal !== undefined) {
-            const parentTerminal = await trySettlePublicSeat(admitted, env.principalAuthority, { ...await readCurrentCourt(admitted.runDirectory), ...packageFaultScope(admitted, env, io) });
-            if (parentTerminal?.roleOutcome.kind === "accepted"
-                || parentTerminal?.roleOutcome.kind === "audit_escalation") {
-                const terminal = await presentUnsettledAudit(parentTerminal, stopped.terminal, io, admitted.runDirectory);
-                return { exitCode: 0, admitted, terminal };
-            }
+            && stopped.terminal !== undefined
+            && stopped.admitted !== undefined) {
+            const terminal = await presentUnsettledOfficer(stopped.terminal, io, stopped.admitted.runDirectory);
+            return { exitCode: 0, admitted: stopped.admitted, terminal };
         }
         return stopped;
     }
@@ -1088,10 +1095,14 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
             const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, { ...await readCurrentCourt(admitted.runDirectory), ...packageFaultScope(admitted, env, io) });
             if (terminal?.roleOutcome.kind !== "accepted")
                 throw new Error("pending submission is not recorded");
-            return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, resolved.admitted, latestQueuePayload(resolved.terminal));
+            // Live child only when admitted-request.auditedSubmissionToolCallId matches
+            // the parent seal under audit (#1195 option 1 / owner 00644146).
+            const live = liveChildForCurrentParentSeal(terminal, resolved.admitted, latestQueuePayload(resolved.terminal));
+            return auditSubmittedRole({ exitCode: 0, admitted, terminal }, env, io, live?.officer, live?.receipt);
         }
         return runPublicInstructionSeatResume({
             runId: parentRunId,
+            runDirectory: admitted.runDirectory,
             summons: { instruction: readableGateItem(latestQueuePayload(resolved.terminal)) },
         }, envForCourtContinue(env), io);
     }
@@ -1100,35 +1111,39 @@ export async function continueParentAfterChild(parentRunId, child, env, io) {
     return result;
 }
 /**
- * A gate is already passed only when an officer run reviewed this submission
- * and its latest queue word is converged. The resumed seat's role is not itself
- * a pass. Unknown or unreadable evidence does not skip the gate.
+ * Hand continueParentAfterChild's live child to audit only when the child's own
+ * admitted-request records this parent seal's toolCallId (#1195 option 1).
+ * Read failures propagate — never wash into "no match".
  */
-async function officerPassedCurrentSubmission(input) {
-    const { env, officer } = input;
-    const pointer = await readDirectOfficerRunPointer(input.parentSessionFile, officer);
-    if (pointer?.runDirectory === undefined)
-        return false;
-    if (pointer.submissionToolCallId !== input.toolCallId)
-        return false;
-    const officerRunId = runIdFromRunDirectory(pointer.runDirectory);
-    if (officerRunId === undefined)
-        return false;
-    let admitted;
-    try {
-        const loaded = await loadResumablePublicRole(env.home, officerRunId, env.principalAuthority);
-        admitted = loaded.admitted;
-    }
-    catch {
+function liveChildForCurrentParentSeal(parentTerminal, child, receipt) {
+    if (receipt === undefined)
+        return undefined;
+    const parentSealId = parentTerminal.submissionToolCallId?.trim() ?? "";
+    if (parentSealId === "")
+        return undefined;
+    const childSealId = readAdmittedAuditedSubmissionToolCallId(child.runDirectory);
+    if (childSealId !== parentSealId)
+        return undefined;
+    return { officer: child, receipt };
+}
+/**
+ * Gate already satisfied for this routing turn when continueParentAfterChild
+ * handed a live converged child that belongs to this parent seal, or — for a
+ * multi-gate chain on that same seal — an earlier gate before that child
+ * (ADR 0003 remaining gates). Parent-side officer pointers are not consulted (#1195).
+ */
+function officerSatisfiedByLiveChild(officer, resumedOfficer, passedReceipt, 
+/** Ordered officers of this parent's gate chain; earlier than live child = done. */
+chainOrder) {
+    if (resumedOfficer === undefined || passedReceipt === undefined)
         return false;
-    }
-    if (admitted.role !== officer)
+    if (resumedOfficer.role === officer)
+        return true;
+    if (chainOrder === undefined)
         return false;
-    // A summon binding identifies the requested review, not its outcome. An open
-    // court (including a failed host turn) must not borrow a previous court's seal.
-    const court = await readCurrentCourt(admitted.runDirectory);
-    const terminal = await trySettlePublicSeat(admitted, env.principalAuthority, court);
-    return latestQueueStatus(terminal) === "converged";
+    const childIndex = chainOrder.indexOf(resumedOfficer.role);
+    const officerIndex = chainOrder.indexOf(officer);
+    return childIndex >= 0 && officerIndex >= 0 && officerIndex < childIndex;
 }
 /** Finished submissions enter the existing audit gate after their tool call has returned. */
 async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt) {
@@ -1156,7 +1171,11 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
             return { ...turn, terminal };
         }
-        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: SECRETARIAT_STATUS_REASK } }, next, io);
+        return runPublicInstructionSeatResume({
+            runId: admitted.runId,
+            runDirectory: admitted.runDirectory,
+            summons: { instruction: SECRETARIAT_STATUS_REASK },
+        }, next, io);
     }
     if (admitted.role === "countersign" && (typeof status !== "string" || !REVIEW_QUEUE_STATUSES.has(status))) {
         if (gateOwnsStatusReask)
@@ -1167,7 +1186,11 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
             return { ...turn, terminal };
         }
-        return runPublicInstructionSeatResume({ runId: admitted.runId, summons: { instruction: officerConclusionReask(status) } }, next, io);
+        return runPublicInstructionSeatResume({
+            runId: admitted.runId,
+            runDirectory: admitted.runDirectory,
+            summons: { instruction: officerConclusionReask(status) },
+        }, next, io);
     }
     // Self-escalation is a valid open routing state for these seats only.
     // Doctor's declared domain is completed|refused — an open "escalate" must
@@ -1208,14 +1231,9 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         },
         abort() { },
     };
-    const passedThisSubmission = (officer) => officerPassedCurrentSubmission({
-        env,
-        parentSessionFile: sessionFile,
-        officer,
-        toolCallId,
-    });
+    const gateSatisfied = (officer, chainOrder) => officerSatisfiedByLiveChild(officer, resumedOfficer, passedReceipt, chainOrder);
     if (admitted.role === "doctor") {
-        if (!await passedThisSubmission("auditor")) {
+        if (!gateSatisfied("auditor")) {
             let lastSummon;
             const decision = await createPiDoctorAuditor()({
                 context, submission: accepted,
@@ -1234,31 +1252,33 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
                         ...(reask === undefined ? {} : { reviewReask: reask }),
                         ...(submission === undefined ? {} : { gateReviewInstruction: submission }),
                     });
-                    const officerSession = sessionFileFromPublicSummon(summoned);
-                    if (officerSession !== undefined) {
-                        bookDirectOfficerRunPointer({
-                            parentSessionFile: sessionFile, officer: "auditor", sessionFile: officerSession,
-                            submissionToolCallId: toolCallId,
-                            ...(summoned.runDirectory === undefined ? {} : { runDirectory: summoned.runDirectory }),
-                        });
-                    }
                     lastSummon = summoned;
+                    const officerDir = summoned.runDirectory ?? summoned.admitted?.runDirectory;
+                    if (officerDir !== undefined && toolCallId.length > 0) {
+                        persistAdmittedAuditedSubmissionToolCallId(officerDir, toolCallId);
+                    }
                     return summoned;
                 },
             });
             if (decision.status === "continue") {
                 return runPublicInstructionSeatResume({
-                    runId: admitted.runId, summons: { instruction: readableGateItem(decision.receipt ?? decision.violations) },
+                    runId: admitted.runId,
+                    runDirectory: admitted.runDirectory,
+                    summons: { instruction: readableGateItem(decision.receipt ?? decision.violations) },
                 }, envForCourtContinue(env), io);
             }
             if (decision.status === "received") {
                 if (lastSummon?.terminal === undefined) {
                     throw new Error("doctor audit kept an unreadable reply with no terminal");
                 }
-                if (turn.terminal === undefined)
-                    throw new Error("doctor submission has no terminal");
-                const terminal = await presentUnsettledAudit(turn.terminal, lastSummon.terminal, io, admitted.runDirectory);
-                return { exitCode: 0, admitted, terminal };
+                const officerAdmitted = lastSummon.admitted;
+                const officerDir = officerAdmitted?.runDirectory ?? lastSummon.runDirectory ?? admitted.runDirectory;
+                const terminal = await presentUnsettledOfficer(lastSummon.terminal, io, officerDir);
+                return {
+                    exitCode: 0,
+                    ...(officerAdmitted === undefined ? { admitted } : { admitted: officerAdmitted }),
+                    terminal,
+                };
             }
             if (decision.status !== "converged") {
                 if (lastSummon?.terminal !== undefined) {
@@ -1280,7 +1300,6 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
         });
         let chain;
-        let officerRunId = resumedOfficer?.runId;
         const runGate = (subject) => requireSubmissionGate({
             context,
             subject,
@@ -1295,8 +1314,10 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             },
         });
         if (admitted.role === "judge") {
+            // Same order as runJudgeGates — sole source JUDGE_GATES + gateOfficerForSubject.
+            const judgeGateOrder = JUDGE_GATES.map(gateOfficerForSubject);
             chain = await runJudgeGates({
-                gateAlreadyConverged: async (subject) => passedThisSubmission(gateOfficerForSubject(subject)),
+                gateAlreadyConverged: async (subject) => gateSatisfied(gateOfficerForSubject(subject), judgeGateOrder),
                 runGate,
             });
         }
@@ -1307,14 +1328,13 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
                     ? { kind: "secretariat_verdict" }
                     : { kind: "countersign_verdict" };
             const officer = gateOfficerForSubject(subject);
-            if (await passedThisSubmission(officer)) {
+            if (gateSatisfied(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: [{
@@ -1329,23 +1349,34 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
             }
         }
         if (chain.status === "needs_reask") {
-            const officerTerminal = chain.passes.at(-1)?.terminal;
+            const pass = chain.passes.at(-1);
+            const officerTerminal = pass?.terminal;
             if (officerTerminal === undefined)
                 throw new Error("unreadable audit has no terminal result");
-            if (turn.terminal === undefined)
-                throw new Error("audited submission has no terminal");
-            const terminal = await presentUnsettledAudit(turn.terminal, officerTerminal, io, admitted.runDirectory);
-            return { exitCode: 0, admitted, terminal };
+            const officerRunDirectory = pass?.runDirectory;
+            const officerRunId = pass?.runId
+                ?? (officerRunDirectory === undefined ? undefined : runIdFromRunDirectory(officerRunDirectory));
+            if (officerRunId === undefined)
+                throw new Error("unreadable audit has no resumable run identity");
+            const officer = await loadResumablePublicRole(env.home, officerRunId, env.principalAuthority, officerRunDirectory === undefined ? undefined : { runDirectory: officerRunDirectory });
+            const terminal = await presentUnsettledOfficer(officerTerminal, io, officer.admitted.runDirectory);
+            return { exitCode: 0, admitted: officer.admitted, terminal };
         }
         if (chain.status === "escalate") {
             const escalation = chain.passes.at(-1);
+            const escalatedRunDirectory = escalation?.runDirectory;
             const escalatedRunId = escalation?.runId
-                ?? (escalation?.runDirectory === undefined
-                    ? undefined : runIdFromRunDirectory(escalation.runDirectory));
+                ?? (escalatedRunDirectory === undefined
+                    ? undefined : runIdFromRunDirectory(escalatedRunDirectory));
             if (escalatedRunId === undefined)
                 throw new Error("escalated audit has no resumable run identity");
-            const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority);
-            const terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, { ...await readCurrentCourt(officer.admitted.runDirectory), ...packageFaultScope(officer.admitted, env, io) });
+            const officer = await loadResumablePublicRole(env.home, escalatedRunId, env.principalAuthority, escalatedRunDirectory === undefined ? undefined : { runDirectory: escalatedRunDirectory });
+            // Prefer the officer terminal already returned. Re-settle only when absent.
+            // Other-seat tables stay on the officer run — parent does not attach copies (#1195).
+            let terminal = escalation?.terminal;
+            if (terminal === undefined) {
+                terminal = await trySettlePublicSeat(officer.admitted, env.principalAuthority, { ...await readCurrentCourt(officer.admitted.runDirectory), ...packageFaultScope(officer.admitted, env, io) });
+            }
             if (terminal === undefined)
                 throw new Error("escalated audit has no terminal result");
             await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, officer.admitted.runDirectory);
@@ -1354,27 +1385,15 @@ async function auditSubmittedRole(turn, env, io, resumedOfficer, passedReceipt)
         if (chain.status === "continue") {
             return runPublicInstructionSeatResume({
                 runId: admitted.runId,
+                runDirectory: admitted.runDirectory,
                 summons: { instruction: readableGateItem(chain.passes.at(-1)?.receipt) },
             }, envForCourtContinue(env), 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, for 中书省, the officer fact. A second settle would
-    // republish the same attempt.
+    // The turn already settled this court. Gate does not project other-seat finals
+    // onto the parent public terminal (#1195) — present this leg's own volume.
     if (turn.terminal === undefined)
         throw new Error(`audited ${admitted.role} submission did not settle`);
-    const terminal = await attachPostAuditCountersignFact(admitted, env.principalAuthority, turn.terminal, packageFaultScope(admitted, env, io));
-    turn = { ...turn, terminal };
-    await presentTerminal(terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
+    await presentTerminal(turn.terminal, { ...io, omitFailureStderrDiagnostic: true }, admitted.runDirectory);
     return turn;
 }

package/dist/public-cli/invocation.js

@@ -26,6 +26,13 @@ import { NotarySourceRunError, resolveNotarySourceRunLocator, } from "../notary-
 import { CliUsageError } from "./cli-errors.js";
 import { REJECTED_PUBLIC_SPELLINGS, createTypedOptionConsumer, evaluateAnalystModeOptionContract, optionsForOwner, resolveAnalystMode, } from "./option-definitions.js";
 import { errorText, isRecord } from "../unknown-value.js";
+/** Nonblank admitted source path, preserving its original bytes. */
+export function admittedSourceRunPath(admitted) {
+    if (!isRecord(admitted))
+        return undefined;
+    const path = admitted.sourceRunPath;
+    return typeof path === "string" && path.trim() !== "" ? path : undefined;
+}
 /** Normalize admitted attachment records (caller path only; #1165). */
 export function normalizeAdmittedAttachment(raw) {
     if (typeof raw !== "object" || raw === null)
@@ -174,6 +181,34 @@ export async function persistAdmittedSourceRunPath(admitted, sourceRunPath, audi
         };
     });
 }
+/**
+ * #1195 option 1: record the parent sealed toolCallId this officer is reviewing
+ * on the officer's own admitted-request (one field). Re-summons for a newer seal
+ * replace the value; continueParentAfterChild only trusts a child whose field
+ * matches the parent seal currently under audit.
+ */
+export function persistAdmittedAuditedSubmissionToolCallId(runDirectory, auditedSubmissionToolCallId) {
+    const id = auditedSubmissionToolCallId.trim();
+    if (id === "") {
+        throw new Error("persistAdmittedAuditedSubmissionToolCallId requires a non-empty id");
+    }
+    // Offline gate mocks may return a runDirectory without admission — skip, do not invent.
+    if (readPageSync(runDirectory, "admitted") === undefined)
+        return;
+    updateSectionSync(runDirectory, "admitted", (current) => {
+        if (current.auditedSubmissionToolCallId === id)
+            return undefined;
+        return { ...current, auditedSubmissionToolCallId: id };
+    });
+}
+/** Read the sealed id this officer admitted-request last recorded (#1195). */
+export function readAdmittedAuditedSubmissionToolCallId(runDirectory) {
+    const page = readPageSync(runDirectory, "admitted");
+    if (page === undefined)
+        return undefined;
+    const id = page.auditedSubmissionToolCallId;
+    return typeof id === "string" && id.trim() !== "" ? id : undefined;
+}
 /**
  * Bind a post-admission resolved ticketNumber onto the in-memory admitted
  * object and both durable sections (invocation + admitted).