@akagilnc/pi-workflow-roles 0.1.4802 → 0.1.4870

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

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