@akagilnc/pi-workflow-roles 0.1.4800 → 0.1.4870

package/src/secretariat-contracts.ts

@@ -10,7 +10,6 @@
 export const SECRETARIAT_OUTPUT_TOOL_NAME = "ak_secretariat_output";
 export const SECRETARIAT_SUMMON_COUNTERSIGN_TOOL_NAME =
   "ak_secretariat_summon_countersign";
-export const SECRETARIAT_ACCEPTED_TEXT = "中书省回执已接受";
 /**
  * #969 durable custom entry: 给事中 terminal (署|上呈) for seat settlement projection.
  * Carries original receipt bytes + nested runId. Envelope persists custom entries

package/src/secretariat-role.ts

@@ -10,7 +10,6 @@ import { withTerminatingOutputDeclarations } from "./package-contracts/terminati
 import type { NamedRoleTurnHostAdapter } from "./public-cli/role-turn-host-resolution.ts";
 import type { PublicSummonResult } from "./public-role-summons.ts";
 import {
-  SECRETARIAT_ACCEPTED_TEXT,
   SECRETARIAT_OUTPUT_TOOL_NAME,
   SECRETARIAT_SUMMON_COUNTERSIGN_TOOL_NAME,
   type SecretariatVerdict,
@@ -18,7 +17,6 @@ import {
 import { runIdFromRunDirectory } from "./run-terminal-artifacts.ts";
 
 export {
-  SECRETARIAT_ACCEPTED_TEXT,
   SECRETARIAT_OUTPUT_TOOL_NAME,
   SECRETARIAT_SUMMON_COUNTERSIGN_TOOL_NAME,
 } from "./secretariat-contracts.ts";

package/src/session-identity.ts

@@ -60,13 +60,28 @@ export function resolveHostAwareSessionAvailability(
   if (host === undefined || host === DEFAULT_ROLE_TURN_HOST) {
     return (principal) => principalAuthority.isAvailable(principal);
   }
+  // Unregistered names have no binding file: absence, not a guess at pi.
+  return async (principal) =>
+    (await readStoredHostSessionId(host, principalAuthority, principal)) !== undefined;
+}
+
+/**
+ * Native session/thread id already stored for this principal on `host`.
+ * Public explicit resume reads it once and hands it to the host adapter.
+ * Pi has no separate binding file. A missing file is absence, not the package run id.
+ */
+export async function readStoredHostSessionId(
+  host: string | undefined,
+  authority: DurablePrincipalAuthority,
+  principal: DurablePrincipal,
+): Promise<string | undefined> {
+  if (host === undefined || host === DEFAULT_ROLE_TURN_HOST) return undefined;
   const description = lookupHostDescription(host) ?? lookupHeadlessHostDescription(host);
-  if (description === undefined) {
-    // Host selection already fails closed on an unregistered name (#510) long
-    // before a turn dispatches; mirror the same fail-closed default here
-    // rather than guessing at pi's binding for a name pi does not own.
-    return () => Promise.resolve(false);
-  }
-  const sessionIdentity = createSessionIdentityAuthority(principalAuthority, description.sessionBindingFile);
-  return async (principal) => (await sessionIdentity.load(principal)) !== undefined;
+  if (description === undefined) return undefined;
+  const sessionId = await createSessionIdentityAuthority(
+    authority,
+    description.sessionBindingFile,
+  ).load(principal);
+  if (sessionId === undefined || sessionId === "") return undefined;
+  return sessionId;
 }

package/src/session-opening-materials.ts

@@ -14,6 +14,7 @@ import {
   INSPECTOR_SESSION_MATERIALS,
   NOTARY_SESSION_MATERIALS,
   PUBLIC_ROLE_RECORDS,
+  packagedRoleSessionMaterials,
   type PackagedRole,
 } from "./packaged-role-registry.ts";
 
@@ -99,7 +100,7 @@ export function loadMainRoleReferenceMaterials(role: MainRoleSession): Promise<s
 /** Gatekeeper province; notary reuses the public notary materials definition. */
 export const GATEKEEPER_SESSION_MATERIALS = {
   // #639: single authority — the public gatekeeper record owns the province list.
-  gatekeeper: PUBLIC_ROLE_RECORDS.find((entry) => entry.role === "gatekeeper")!.sessionMaterials,
+  gatekeeper: packagedRoleSessionMaterials("gatekeeper")!,
   inspector: INSPECTOR_SESSION_MATERIALS,
   notary: NOTARY_SESSION_MATERIALS,
 } as const;

package/src/worker-role.ts

@@ -8,10 +8,9 @@ import type {
   AnyCanonicalSkillBinding,
   CanonicalSkillBinding,
 } from "./canonical-skill-binding.ts";
+import { packagedRoleAcceptedText } from "./packaged-role-registry.ts";
 import {
-  CODER_ACCEPTED_TEXT,
   CODER_OUTPUT_TOOL_NAME,
-  FIXER_ACCEPTED_TEXT,
   FIXER_OUTPUT_TOOL_NAME,
   validateAcceptedWorkerDetails,
   type CoderOutput,
@@ -296,7 +295,7 @@ export function createFixerRoleRuntime(
             }
             const acceptedDetails = output;
             return {
-              content: [{ type: "text" as const, text: FIXER_ACCEPTED_TEXT }],
+              content: [{ type: "text" as const, text: packagedRoleAcceptedText("fixer") }],
               details: acceptedDetails,
               terminate: true as const,
             };
@@ -436,7 +435,7 @@ export function createCoderRoleRuntime(
             }
             const acceptedDetails = output;
             return {
-              content: [{ type: "text" as const, text: CODER_ACCEPTED_TEXT }],
+              content: [{ type: "text" as const, text: packagedRoleAcceptedText("coder") }],
               details: acceptedDetails,
               terminate: true as const,
             };

package/dist/doctor-auditor.js

@@ -1,25 +0,0 @@
-import { auditorRunDirectory } from "./auditor-dossier-tool.js";
-import { runComplianceAudit, } from "./compliance-transport.js";
-import { readDoctorAuditSubjects, requireAuditMaterials, resolveAuditDossier, } from "./dossier-resolution.js";
-export const DOCTOR_AUDIT_TOOL_NAME = "ak_doctor_audit_decision";
-/**
- * Doctor compliance via public auditor activation (#675 / ADR 0062 / owner r11).
- * 审刑院 is an independent role; subject=doctor selects souls/doctor-auditor.md.
- */
-export function createPiDoctorAuditor() {
-    return async (options) => {
-        const dossier = resolveAuditDossier(options.context);
-        requireAuditMaterials(dossier);
-        const subjects = readDoctorAuditSubjects(options.context);
-        requireAuditMaterials(subjects);
-        return runComplianceAudit({
-            subject: "doctor",
-            context: options.context,
-            ...(auditorRunDirectory(options.context) === undefined
-                ? {}
-                : { runDirectory: auditorRunDirectory(options.context) }),
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            ...(options.summonAuditor === undefined ? {} : { summonAuditor: options.summonAuditor }),
-        });
-    };
-}

package/dist/public-cli/diarist-run.js

@@ -1,130 +0,0 @@
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
-import { CliUsageError } from "./cli-errors.js";
-import { admitDiaristInvocation, bindAdmittedTicketNumber, buildInstructionTransportPrompt, relocateAdmittedRunToTicket, recordAdmittedCorrelation, } from "./invocation.js";
-import { prepareSummonsResumeMaterials, runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-import { loadResumableDiaristRun, markRunAdmitted, } from "./run-lifecycle.js";
-import { presentStructuralRejection, trySettleDiaristTerminalResult, } from "./settlement.js";
-import { projectRoleTurnRequest, } from "./turn-request.js";
-import { readBoardTicketNumber } from "../run-ticket-number.js";
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildDiaristTurnRequest(admitted, options) {
-    return projectRoleTurnRequest(admitted, { activation: { role: "diarist" } }, options);
-}
-/**
- * Board-bound ticket on pages → memory bind + unbound→ticket relocate under lease.
- * Shared by resume (interrupted board-bound unbound) and post-turn first assert.
- */
-async function bindAndRelocateDiaristIfBoardBound(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 diaristAdapters(env) {
-    return {
-        trySettle: (admitted, authority, scope) => trySettleDiaristTerminalResult(admitted, authority, scope),
-        shouldPresentSettled: () => true,
-        // Resume interrupted state: board ticket already on pages, run still under unbound/.
-        beforeDispatch: async (admitted, lease) => {
-            if (env.correlationId !== undefined && env.correlationId.trim() !== "") {
-                await recordAdmittedCorrelation(admitted, env.correlationId);
-            }
-            await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
-        },
-        // First post-turn assert: accept hook wrote board pages; relocate before lease release.
-        afterDispatch: async (admitted, lease) => {
-            await bindAndRelocateDiaristIfBoardBound(admitted, env.principalAuthority, lease);
-        },
-    };
-}
-export async function runPublicDiarist(argv, env, io, parseDiaristArgv) {
-    let parsed;
-    try {
-        parsed = parseDiaristArgv(argv);
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    // #637 / #771 / ADR 0075 / #779 / #987: ticket identity is the LLM's typed
-    // assertion on this turn, OR a typed handoff key already held by the caller
-    // (countersign refresh bind). Code never pre-judges the summons text and never
-    // freezes a candidate catalog. Public same-ticket resume-by-ticketNumber was
-    // deleted (#987 Result 7); callers continue an existing diarist run only via
-    // explicit `ak-role resume <runId>`. Handoff ticket remains a bind key only.
-    const handoffTicket = env.boundTicketNumber;
-    let admitted;
-    try {
-        admitted = await admitDiaristInvocation({
-            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 }),
-            ...(handoffTicket === undefined ? {} : { assertedTicketNumber: handoffTicket }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    await markRunAdmitted(admitted, env.principalAuthority);
-    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: buildInstructionTransportPrompt(admitted, engineSessionMaterialFromOptions({
-                ...pickEngineAxis(env),
-                packageRoot: env.packageRoot,
-            })),
-        },
-    };
-    const turnRequest = buildDiaristTurnRequest(admitted, turnProjection);
-    return await runPostAdmissionOneShot({
-        admitted,
-        env,
-        io,
-        request: turnRequest,
-        adapters: diaristAdapters(env),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}
-/**
- * Resume a previously admitted Diarist run (#708 / ADR 0079 同票传召 = resume).
- * LLM re-finds materials; entry identity keeps the volume idempotent.
- */
-export async function runPublicDiaristResume(request, env, io) {
-    return await runPostAdmissionSeatResume({
-        request,
-        env,
-        io,
-        load: (effective) => loadResumableDiaristRun(env.home, effective.runId, env.principalAuthority),
-        buildTurnRequest: async (admitted, effective) => {
-            const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
-            return buildDiaristTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared));
-        },
-        adapters: diaristAdapters(env),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}

package/dist/public-cli/doctor-run.js

@@ -1,87 +0,0 @@
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
-import { CliUsageError } from "./cli-errors.js";
-import { admitDoctorInvocation, buildDoctorTransportPrompt } from "./invocation.js";
-import { runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-import { loadResumableDoctorRun, markRunAdmitted, } from "./run-lifecycle.js";
-import { presentStructuralRejection, trySettleDoctorTerminalResult, } from "./settlement.js";
-import { isLawfulTypedTerminalOutcome, } from "./terminal.js";
-import { projectRoleTurnRequest, } from "./turn-request.js";
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildDoctorTurnRequest(admitted, options) {
-    return projectRoleTurnRequest(admitted, {
-        activation: { role: "doctor", casePath: admitted.caseRunsPath },
-    }, options);
-}
-export async function runPublicDoctor(argv, env, io, parseDoctorArgv) {
-    let admitted;
-    try {
-        const parsed = parseDoctorArgv(argv);
-        admitted = await admitDoctorInvocation({
-            home: env.home,
-            principalAuthority: env.principalAuthority,
-            cwd: env.cwd,
-            issueNumber: parsed.issueNumber,
-            instruction: parsed.instruction,
-            attachmentPaths: parsed.attachmentPaths,
-            ...(parsed.project === undefined ? {} : { project: parsed.project }),
-            ...(parsed.runs === undefined ? {} : { runs: parsed.runs }),
-            ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
-            ...(env.model === undefined ? {} : { model: env.model }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    await markRunAdmitted(admitted, env.principalAuthority);
-    const turnRequest = buildDoctorTurnRequest(admitted, {
-        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: buildDoctorTransportPrompt(admitted, engineSessionMaterialFromOptions({
-                ...pickEngineAxis(env),
-                packageRoot: env.packageRoot,
-            })),
-        },
-    });
-    return await runPostAdmissionOneShot({
-        admitted,
-        env,
-        io,
-        request: turnRequest,
-        adapters: doctorAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}
-function doctorAdapters() {
-    return {
-        trySettle: (admitted, authority, scope) => trySettleDoctorTerminalResult(admitted, authority, scope),
-        shouldPresentSettled: (terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome),
-    };
-}
-/**
- * Resume a previously admitted Doctor run (#633). Issue + retained case
- * identity restore from the durable admitted request; the session principal reopens.
- */
-export async function runPublicDoctorResume(request, env, io) {
-    return await runPostAdmissionSeatResume({
-        request,
-        env,
-        io,
-        load: (effective) => loadResumableDoctorRun(env.home, effective.runId, env.principalAuthority),
-        buildTurnRequest: (admitted, effective) => buildDoctorTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env)),
-        adapters: doctorAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}

package/dist/public-cli/inspector-run.js

@@ -1,151 +0,0 @@
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
-import { CliUsageError } from "./cli-errors.js";
-import { tryResumeSameTicketSeatRun } from "./seat-ticket-binding.js";
-import { admitInspectorInvocation, buildInspectorTransportPrompt, persistAdmittedSourceRunPath, } from "./invocation.js";
-import { prepareSummonsResumeMaterials, runPostAdmissionOneShot, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-import { loadResumableInspectorRun, markRunAdmitted, parentRunPathFromGatePointerInstruction, } from "./run-lifecycle.js";
-import { presentStructuralRejection, trySettleInspectorTerminalResult, } from "./settlement.js";
-import { projectRoleTurnRequest, } from "./turn-request.js";
-function inspectorParentRunPath(admitted) {
-    if (typeof admitted.sourceRunPath === "string" && admitted.sourceRunPath.trim() !== "") {
-        return admitted.sourceRunPath;
-    }
-    return parentRunPathFromGatePointerInstruction(admitted.instruction);
-}
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildInspectorTurnRequest(admitted, options) {
-    const sourceRun = inspectorParentRunPath(admitted);
-    return projectRoleTurnRequest(admitted, {
-        activation: {
-            role: "inspector",
-            ...(sourceRun === undefined ? {} : { sourceRun }),
-        },
-    }, options);
-}
-export async function runPublicInspector(argv, env, io, parseInspectorArgv) {
-    let parsed;
-    try {
-        parsed = parseInspectorArgv(argv);
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    // #747: same parent (卷宗指针) → resume prior inspector run with this summons' materials.
-    // #771: no mechanical ticket match against instruction text; parent-run path only.
-    // No bare catch→fresh: lookup/resume failures surface; only true absence mints new.
-    const projectRoot = parsed.project ?? env.cwd;
-    // #747: parentRunPath is the pure 卷宗指针 path only — never reask/materials text.
-    // #753/#786: gate re-ask / verbatim submission body ride summons.instruction on resume.
-    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: "inspector",
-            parentRunPath,
-            freshSummons: env.freshSummons,
-            summons,
-            resume: (runId, materials) => runPublicInspectorResume({ runId, ...(materials === undefined ? {} : { summons: materials }) }, env, io),
-        });
-        if (resumed !== undefined)
-            return resumed;
-    }
-    let admitted;
-    try {
-        admitted = await admitInspectorInvocation({
-            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 }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    await markRunAdmitted(admitted, env.principalAuthority);
-    if (parentRunPath !== undefined) {
-        await persistAdmittedSourceRunPath(admitted, parentRunPath);
-        admitted = { ...admitted, sourceRunPath: parentRunPath };
-    }
-    const engineMaterial = engineSessionMaterialFromOptions({
-        ...pickEngineAxis(env),
-        packageRoot: env.packageRoot,
-    });
-    const turnRequest = buildInspectorTurnRequest(admitted, {
-        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",
-            // #879: gate first mint uses parent payload as content; binding stays typed activation.
-            prompt: (env.reviewReask ?? env.gateReviewInstruction)
-                ?? buildInspectorTransportPrompt(admitted, engineMaterial),
-        },
-    });
-    return await runPostAdmissionOneShot({
-        admitted,
-        env,
-        io,
-        request: turnRequest,
-        adapters: inspectorAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}
-function inspectorAdapters(options) {
-    return {
-        trySettle: (admitted, authority, scope) => trySettleInspectorTerminalResult(admitted, authority, scope),
-        shouldPresentSettled: () => true,
-        ...(options?.beforeDispatch === undefined
-            ? {}
-            : { beforeDispatch: options.beforeDispatch }),
-    };
-}
-/**
- * Resume a previously admitted Inspector run (#633 / #637); the session principal reopens.
- * Same-ticket summons deliver this turn's instruction + frozen attachments; manual
- * resume forwards only caller-supplied message bytes.
- */
-export async function runPublicInspectorResume(request, env, io) {
-    return await runPostAdmissionSeatResume({
-        request,
-        env,
-        io,
-        load: (effective) => loadResumableInspectorRun(env.home, effective.runId, env.principalAuthority),
-        buildTurnRequest: async (admitted, effective) => {
-            const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
-            return buildInspectorTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared));
-        },
-        adapters: inspectorAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}

package/dist/public-cli/judge-run.js

@@ -1,114 +0,0 @@
-import { engineSessionMaterialFromOptions, pickEngineAxis } from "../package-resources/engine-material.js";
-import { CliUsageError } from "./cli-errors.js";
-import { admitJudgeInvocation, buildJudgeTransportPrompt, } from "./invocation.js";
-import { loadResumableJudgeRun, markRunAdmitted, buildAutoResumeContinuationPrompt, } from "./run-lifecycle.js";
-import { presentStructuralRejection, readEngineDetourInfrastructureFailure, trySettleJudgeTerminalResult, } from "./settlement.js";
-import { projectRoleTurnRequest, } from "./turn-request.js";
-import { runPostAdmissionResumable, runPostAdmissionSeatResume, resumeTurnRequestProjectionOptions, } from "./post-admission.js";
-/** Project admitted invocation onto the host-neutral turn request. */
-export function buildJudgeTurnRequest(admitted, options) {
-    return projectRoleTurnRequest(admitted, { activation: { role: "judge" } }, options);
-}
-function judgeAdapters() {
-    return {
-        trySettle: (admitted, authority, scope) => trySettleJudgeTerminalResult(admitted, authority, scope),
-        resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
-            const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
-            return (result.knownFailure ??
-                (infrastructureFailure === undefined
-                    ? undefined
-                    : {
-                        ...(infrastructureFailure.cause === undefined
-                            ? {}
-                            : { cause: infrastructureFailure.cause }),
-                        diagnostic: infrastructureFailure.diagnostic,
-                        ...(infrastructureFailure.identity === undefined
-                            ? {}
-                            : { identity: infrastructureFailure.identity }),
-                    }));
-        },
-    };
-}
-export async function runPublicJudge(argv, env, io, parseJudgeArgv) {
-    let admitted;
-    try {
-        const parsed = parseJudgeArgv(argv);
-        admitted = await admitJudgeInvocation({
-            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 }),
-        });
-    }
-    catch (error) {
-        if (error instanceof CliUsageError) {
-            presentStructuralRejection(error, io);
-            return { exitCode: 2 };
-        }
-        throw error;
-    }
-    await markRunAdmitted(admitted, env.principalAuthority);
-    return await runPostAdmissionResumable({
-        admitted,
-        env,
-        io,
-        buildInitialRequest: () => buildJudgeTurnRequest(admitted, {
-            packageRoot: env.packageRoot,
-            home: env.home,
-            agentDir: env.agentDir,
-            ...(env.model === undefined ? {} : { model: env.model }),
-            ...pickEngineAxis(env),
-            ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-            ...(admitted.correlationId === undefined && env.correlationId === undefined
-                ? {}
-                : { correlationId: admitted.correlationId ?? env.correlationId }),
-            continuation: {
-                kind: "initial",
-                prompt: buildJudgeTransportPrompt(admitted, engineSessionMaterialFromOptions({
-                    ...pickEngineAxis(env),
-                    packageRoot: env.packageRoot,
-                })),
-            },
-        }),
-        buildResumeRequest: () => buildJudgeTurnRequest(admitted, {
-            packageRoot: env.packageRoot,
-            home: env.home,
-            agentDir: env.agentDir,
-            ...(env.model === undefined ? {} : { model: env.model }),
-            ...pickEngineAxis(env),
-            ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-            ...(admitted.correlationId === undefined && env.correlationId === undefined
-                ? {}
-                : { correlationId: admitted.correlationId ?? env.correlationId }),
-            continuation: {
-                kind: "resume",
-                prompt: buildAutoResumeContinuationPrompt({
-                    packageRoot: env.packageRoot,
-                    ...pickEngineAxis(env),
-                }),
-            },
-        }),
-        adapters: judgeAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}
-/**
- * Resume a previously admitted Role run after a typed HTTP 429 interruption.
- * Restores role/project/instruction/attachments/session identity; model override
- * is temporary for this invocation only.
- */
-export async function runPublicResume(request, env, io) {
-    return await runPostAdmissionSeatResume({
-        request,
-        env,
-        io,
-        load: (effective) => loadResumableJudgeRun(env.home, effective.runId, env.principalAuthority),
-        buildTurnRequest: (admitted, effective) => buildJudgeTurnRequest(admitted, resumeTurnRequestProjectionOptions(admitted, effective, env)),
-        adapters: judgeAdapters(),
-        ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-    });
-}