@akagilnc/pi-workflow-roles 0.1.4802 → 0.1.4870

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

@@ -17,6 +17,7 @@ import { parseCollectorRepository } from "../collector-config.js";
 import { interpretDurableCourtTicketNumbers, sameCourtTicketNumbers, } from "../diarist-contracts.js";
 import { rewriteAdmittedRoleRunPage, rewriteRunDirectoryPathValue, } from "../role-run-relocation.js";
 import { appendEngineSessionMaterial, engineSessionMaterialFromOptions, pickEngineAxis, } from "../package-resources/engine-material.js";
+import { packagedResumeSourcePath, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { recordEffectiveInvocationModel, requireAuthorityRef, isReviewerLens, } from "./invocation.js";
 /** Providers eligible for v1 typed-429 resume (Codex / xAI only).
  * @deprecated v1 429-only gate removed by #416 (owner 2026-08-22: "根本不要有限制"). Kept for compatibility; do not use for new branching.
@@ -154,22 +155,8 @@ async function readRoleRunStateDisk(runDirectory) {
     if (typeof record.runId !== "string" || record.runId.trim() === "") {
         return undefined;
     }
-    if (record.role !== "judge" &&
-        record.role !== "coder" &&
-        record.role !== "fixer" &&
-        record.role !== "collector" &&
-        record.role !== "doctor" &&
-        record.role !== "reviewer" &&
-        record.role !== "merger" &&
-        record.role !== "notary" &&
-        record.role !== "countersign" &&
-        record.role !== "gleaner-left" &&
-        record.role !== "inspector" &&
-        record.role !== "gatekeeper" &&
-        record.role !== "navigator" &&
-        record.role !== "auditor" &&
-        record.role !== "diarist" &&
-        record.role !== "secretariat") {
+    const role = typeof record.role === "string" ? packagedRoleMetadata(record.role)?.role : undefined;
+    if (role === undefined) {
         return undefined;
     }
     if (record.state !== "admitted" &&
@@ -215,7 +202,7 @@ async function readRoleRunStateDisk(runDirectory) {
     const currentCourt = parseCurrentCourtState(record.currentCourt);
     return {
         runId: record.runId,
-        role: record.role,
+        role,
         state: record.state,
         bookKey: record.bookKey,
         projectRoot: record.projectRoot,
@@ -299,6 +286,10 @@ export async function readRoleRunIdentity(runDirectory) {
 }
 export async function markRunAdmitted(admitted, authority) {
     const { sessionDirectory, sessionFile } = authority.decode(admitted.principal);
+    const record = packagedRoleMetadata(admitted.role);
+    const workerPhase = record !== undefined && "worker" in record && record.worker === true && "phase" in admitted
+        ? admitted.phase
+        : undefined;
     await writeRoleRunState(admitted.runDirectory, {
         runId: admitted.runId,
         role: admitted.role,
@@ -308,9 +299,7 @@ export async function markRunAdmitted(admitted, authority) {
         sessionDirectory,
         sessionFile,
         admittedRequestPath: admitted.admittedRequestPath,
-        ...(admitted.role === "coder" || admitted.role === "fixer"
-            ? { phase: admitted.phase }
-            : {}),
+        ...(workerPhase === undefined ? {} : { phase: workerPhase }),
     });
 }
 /**
@@ -818,10 +807,11 @@ async function runHasFormedSessionPrincipal(runDirectory) {
 /**
  * Locate the latest retained run for one seat under a book (#637 / #747).
  * Same walk surface as findRunDirectoryById (listBookRunDirectories). Match by
- * parent run path (officer / gate seats, #747 / #987). runId is UUIDv7 —
- * lexicographic max is latest among runs that formed a session principal. No
- * parallel index. Public ticket-number selection of a prior run was deleted
- * (#987 Result 7); callers use explicit `ak-role resume <runId>`.
+ * parent run path (officer / gate seats, #747 / #987). A typed ticket number
+ * does not select a run. runId is UUIDv7 — lexicographic max is latest among
+ * runs that formed a session principal. No parallel index. Public ticket-number
+ * selection of a prior run was deleted (#987 Result 7); callers use explicit
+ * `ak-role resume <runId>`.
  * Only a truly missing book directory means no history; damage/permission errors propagate.
  */
 export async function findLatestRunIdForSeatTicket(input) {
@@ -1230,9 +1220,8 @@ async function loadResumableRunRecord(home, runId, authority) {
     };
 }
 /**
- * Base admitted projection shared by every seat loader: durable identity +
- * instruction/attachments + principal + restored ticket identity + model (#633).
- * Seat loaders add only their seat-specific fields on top.
+ * Base admitted projection: durable identity, instruction, attachments, principal, ticket, and model.
+ * Seat restore adds only that seat's fields.
  */
 function resumedBaseAdmitted(loaded) {
     return {
@@ -1249,7 +1238,7 @@ function resumedBaseAdmitted(loaded) {
         ...restoredTicketFields(loaded.admittedFields),
     };
 }
-/** Loaded-run envelope projection; seat loaders add only their seat fields. */
+/** Loaded-run envelope. */
 function seatLoadedResult(loaded, admitted) {
     return {
         admitted,
@@ -1257,340 +1246,232 @@ function seatLoadedResult(loaded, admitted) {
         ...(loaded.observation === undefined ? {} : { observation: loaded.observation }),
     };
 }
-/**
- * Load a resumable Judge run for resume. Rejects unknown, terminal,
- * non-resumable, and non-Judge IDs without replaying dispatch.
- */
-export async function loadResumableJudgeRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "judge") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not judge`);
-    }
-    const admitted = {
-        role: "judge",
-        ...resumedBaseAdmitted(loaded),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Coder run for resume. Phase and task path are restored from
- * the admitted request so continuation stays role-correct (#109).
- */
-export async function loadResumableCoderRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "coder") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not coder`);
-    }
-    const phase = loaded.admittedFields.phase ?? loaded.run.phase;
-    if (phase !== "plan" && phase !== "apply") {
-        throw new CliUsageError(`role run admitted coder phase is missing: ${runId}`);
-    }
-    const taskPath = loaded.admittedFields.taskPath;
-    if (taskPath === undefined) {
-        throw new CliUsageError(`role run admitted coder task path is missing: ${runId}`);
-    }
-    if (loaded.admittedFields.instruction.trim() === "") {
-        throw new CliUsageError(`role run admitted coder task is blank: ${runId}`);
-    }
-    const admitted = {
-        role: "coder",
-        phase,
-        ...resumedBaseAdmitted(loaded),
-        instructionEmpty: false,
-        taskPath,
-    };
-    return seatLoadedResult(loaded, admitted);
+export async function peekRoleRunRole(home, runId) {
+    const runDirectory = await findRunDirectoryById(home, runId);
+    if (runDirectory === undefined)
+        return undefined;
+    const run = await readRoleRunIdentity(runDirectory);
+    return run?.role;
 }
 /**
- * Load a resumable Fixer run for resume. Phase, packet, and prerequisites are
- * restored from the admitted request so continuation stays role-correct (#110).
+ * One resume load. The caller supplies the package run id; the disk role
+ * selects the existing restore checks. The stored native host session id is
+ * read on the public explicit resume seam, not from this load.
  */
-export async function loadResumableFixerRun(home, runId, authority) {
+export async function loadResumablePublicRole(home, runId, authority) {
     const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "fixer") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not fixer`);
-    }
-    const phase = loaded.admittedFields.phase ?? loaded.run.phase;
-    if (phase !== "plan" && phase !== "apply") {
-        throw new CliUsageError(`role run admitted fixer phase is missing: ${runId}`);
-    }
-    const packetPath = loaded.admittedFields.packetPath;
-    if (packetPath === undefined) {
-        throw new CliUsageError(`role run admitted fixer packet path is missing: ${runId}`);
-    }
-    if (loaded.admittedFields.instruction.trim() === "") {
-        throw new CliUsageError(`role run admitted fixer instruction is blank: ${runId}`);
-    }
-    const prerequisites = loaded.admittedFields.prerequisites ?? Object.freeze([]);
-    const admitted = {
-        role: "fixer",
-        phase,
-        ...resumedBaseAdmitted(loaded),
-        instructionEmpty: false,
-        packetPath,
-        ...(loaded.admittedFields.prerequisitesPath === undefined
-            ? {}
-            : { prerequisitesPath: loaded.admittedFields.prerequisitesPath }),
-        prerequisites,
-    };
-    return seatLoadedResult(loaded, admitted);
+    return seatLoadedResult(loaded, admitResumedRole(loaded));
 }
 /**
- * Peek the durable role of a run id without enforcing resumable state.
- * Used by public resume dispatch to pick the role-correct seat and path.
- */
-/**
- * Load a resumable Reviewer run for resume. Fixed base is restored from the
- * admitted request; caller instruction remains optional provenance only.
+ * One resume restore. Admission kind comes from the composition-root record;
+ * seat-only required fields stay on that kind. Instruction seats share one face.
  */
-export async function loadResumableReviewerRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "reviewer") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not reviewer`);
-    }
-    // Durable restore keeps run identity — never rebrand record damage as fresh --base/--lens.
-    const rawBase = loaded.admittedFields.baseRevision;
-    if (rawBase === undefined || rawBase.trim() === "") {
-        throw new CliUsageError(`role run admitted reviewer base revision is missing: ${runId}`);
-    }
-    if (/\s/.test(rawBase) || rawBase.startsWith("-")) {
-        throw new CliUsageError(`role run admitted reviewer base revision is damaged: ${runId}`);
-    }
-    const baseRevision = rawBase;
-    const lens = loaded.admittedFields.lens;
-    if (!isReviewerLens(lens)) {
-        throw new CliUsageError(`role run admitted reviewer lens is missing: ${runId}`);
-    }
-    const authorityRefs = Object.freeze([
-        ...(loaded.admittedFields.authorityRefs ?? []),
-    ]);
-    if (authorityRefs.length === 0) {
-        throw new CliUsageError(`role run admitted reviewer authority refs are missing: ${runId}`);
-    }
-    const admitted = {
-        role: "reviewer",
-        ...resumedBaseAdmitted(loaded),
-        baseRevision,
-        lens,
-        authorityRefs,
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Countersign run for resume (#599). Ticket binding and
- * attachments restore from the admitted request.
- */
-export async function loadResumableCountersignRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "countersign") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not countersign`);
-    }
+function admitResumedRole(loaded) {
+    const role = loaded.run.role;
+    const runId = loaded.run.runId;
+    const record = packagedRoleMetadata(role);
+    if (record === undefined) {
+        throw new CliUsageError(`unknown role: ${role}`);
+    }
+    const fields = loaded.admittedFields;
     const base = resumedBaseAdmitted(loaded);
-    const admitted = {
-        role: "countersign",
-        ...base,
-        ...(base.courtTicketNumbers === undefined
-            ? {}
-            : { courtTicketNumbers: base.courtTicketNumbers }),
-        ...(loaded.admittedFields.courtTicketNumbersDamage === undefined
-            ? {}
-            : {
-                courtTicketNumbersDamage: loaded.admittedFields.courtTicketNumbersDamage,
-            }),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Gleaner-Left run for resume (#599). Fixed base restores from
- * the admitted request so continuation stays comparison-correct.
- */
-export async function loadResumableInstructionSeatRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "gatekeeper"
-        && loaded.run.role !== "navigator"
-        && loaded.run.role !== "auditor") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not an instruction seat`);
-    }
-    const admitted = {
-        role: loaded.run.role,
-        ...resumedBaseAdmitted(loaded),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-export async function loadResumableGleanerLeftRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "gleaner-left") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not gleaner-left`);
-    }
-    const baseRevision = loaded.admittedFields.baseRevision;
-    if (baseRevision === undefined || baseRevision.trim() === "") {
-        throw new CliUsageError(`role run admitted gleaner-left base revision is missing: ${runId}`);
-    }
-    const admitted = {
-        role: "gleaner-left",
-        ...resumedBaseAdmitted(loaded),
-        baseRevision,
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-export async function loadResumableDiaristRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "diarist") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not diarist`);
-    }
-    const admitted = {
-        role: "diarist",
-        ...resumedBaseAdmitted(loaded),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-export async function loadResumableSecretariatRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "secretariat") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not secretariat`);
-    }
-    const admitted = {
-        role: "secretariat",
-        ...resumedBaseAdmitted(loaded),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Merger run for resume. Derived envelope + internal input path
- * are restored from the admitted request (#114).
- */
-export async function loadResumableMergerRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "merger") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not merger`);
-    }
-    const mergerInputPath = loaded.admittedFields.mergerInputPath;
-    if (mergerInputPath === undefined) {
-        throw new CliUsageError(`role run admitted merger input path is missing: ${runId}`);
-    }
-    const derived = loaded.admittedFields.derived;
-    if (derived === undefined) {
-        throw new CliUsageError(`role run admitted merger envelope is missing: ${runId}`);
-    }
-    if (loaded.admittedFields.instruction.trim() === "") {
-        throw new CliUsageError(`role run admitted merger task is blank: ${runId}`);
-    }
-    const admitted = {
-        role: "merger",
-        ...resumedBaseAdmitted(loaded),
-        instructionEmpty: false,
-        mergerInputPath,
-        derived,
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Collector run for resume (#633). Admitted repository/PR
- * identity restores from the durable admitted request so the continuation
- * stays binding-correct.
- */
-export async function loadResumableCollectorRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "collector") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not collector`);
-    }
-    const { prNumber, repository, repositoryDisplay, manifestDigest } = loaded.admittedFields;
-    // #676 A: prNumber may be unbound at admission (role bind-target). Repository is required.
-    if (repository === undefined ||
-        repositoryDisplay === undefined ||
-        manifestDigest === undefined) {
-        throw new CliUsageError(`role run admitted collector repository identity is missing: ${runId}`);
-    }
-    let parsedRepository;
-    try {
-        parsedRepository = parseCollectorRepository(repositoryDisplay);
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        throw new CliUsageError(detail, { cause: error });
-    }
-    if (parsedRepository.canonical !== repository) {
-        throw new CliUsageError(`role run admitted collector repository does not match its canonical form: ${runId}`);
-    }
-    const admitted = {
-        role: "collector",
-        ...resumedBaseAdmitted(loaded),
-        ...(prNumber === undefined ? {} : { prNumber }),
-        repository: parsedRepository,
-        ...(loaded.admittedFields.requestManifestPath === undefined
-            ? {}
-            : { requestManifestPath: loaded.admittedFields.requestManifestPath }),
-        ...(loaded.admittedFields.waitWindowMs === undefined
-            ? {}
-            : { waitWindowMs: loaded.admittedFields.waitWindowMs }),
-        manifestDigest,
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Doctor run for resume (#633). Issue + retained case
- * identity restore from the durable admitted request.
- */
-export async function loadResumableDoctorRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "doctor") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not doctor`);
-    }
-    const { issueNumber, caseRunsPath, caseIdentity } = loaded.admittedFields;
-    if (issueNumber === undefined ||
-        caseRunsPath === undefined ||
-        caseIdentity === undefined) {
-        throw new CliUsageError(`role run admitted doctor case identity is missing: ${runId}`);
-    }
-    const admitted = {
-        role: "doctor",
-        ...resumedBaseAdmitted(loaded),
-        issueNumber,
-        caseRunsPath,
-        caseIdentity,
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-/**
- * Load a resumable Notary run for resume (#633). Source-run locator restores
- * from the durable admitted request; the locator is not re-resolved.
- */
-export async function loadResumableNotaryRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "notary") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not notary`);
-    }
-    const { sourceRunPath, sourceRun } = loaded.admittedFields;
-    if (sourceRunPath === undefined || sourceRun === undefined) {
-        throw new CliUsageError(`role run admitted notary source-run locator is missing: ${runId}`);
+    switch (record.admission) {
+        case "instruction": {
+            if (packagedResumeSourcePath(role)) {
+                const admitted = {
+                    role: "inspector",
+                    ...base,
+                    ...(fields.sourceRunPath === undefined
+                        ? {}
+                        : { sourceRunPath: fields.sourceRunPath }),
+                };
+                return admitted;
+            }
+            return {
+                role,
+                ...base,
+            };
+        }
+        case "court-materials": {
+            const admitted = {
+                role: "countersign",
+                ...base,
+                ...(base.courtTicketNumbers === undefined
+                    ? {}
+                    : { courtTicketNumbers: base.courtTicketNumbers }),
+                ...(fields.courtTicketNumbersDamage === undefined
+                    ? {}
+                    : { courtTicketNumbersDamage: fields.courtTicketNumbersDamage }),
+            };
+            return admitted;
+        }
+        case "worker-task": {
+            const phase = resumedWorkerPhase(fields.phase ?? loaded.run.phase, record.phases, role, runId);
+            const taskPath = fields.taskPath;
+            if (taskPath === undefined) {
+                throw new CliUsageError(`role run admitted coder task path is missing: ${runId}`);
+            }
+            if (fields.instruction.trim() === "") {
+                throw new CliUsageError(`role run admitted coder task is blank: ${runId}`);
+            }
+            const admitted = {
+                role: "coder",
+                phase,
+                ...base,
+                instructionEmpty: false,
+                taskPath,
+            };
+            return admitted;
+        }
+        case "worker-packet": {
+            const phase = resumedWorkerPhase(fields.phase ?? loaded.run.phase, record.phases, role, runId);
+            const packetPath = fields.packetPath;
+            if (packetPath === undefined) {
+                throw new CliUsageError(`role run admitted fixer packet path is missing: ${runId}`);
+            }
+            if (fields.instruction.trim() === "") {
+                throw new CliUsageError(`role run admitted fixer instruction is blank: ${runId}`);
+            }
+            const prerequisites = fields.prerequisites ?? Object.freeze([]);
+            const admitted = {
+                role: "fixer",
+                phase,
+                ...base,
+                instructionEmpty: false,
+                packetPath,
+                ...(fields.prerequisitesPath === undefined
+                    ? {}
+                    : { prerequisitesPath: fields.prerequisitesPath }),
+                prerequisites,
+            };
+            return admitted;
+        }
+        case "review-basis": {
+            const rawBase = fields.baseRevision;
+            if (rawBase === undefined || rawBase.trim() === "") {
+                throw new CliUsageError(`role run admitted reviewer base revision is missing: ${runId}`);
+            }
+            if (/\s/.test(rawBase) || rawBase.startsWith("-")) {
+                throw new CliUsageError(`role run admitted reviewer base revision is damaged: ${runId}`);
+            }
+            const lens = fields.lens;
+            if (!isReviewerLens(lens)) {
+                throw new CliUsageError(`role run admitted reviewer lens is missing: ${runId}`);
+            }
+            const authorityRefs = Object.freeze([...(fields.authorityRefs ?? [])]);
+            if (authorityRefs.length === 0) {
+                throw new CliUsageError(`role run admitted reviewer authority refs are missing: ${runId}`);
+            }
+            const admitted = {
+                role: "reviewer",
+                ...base,
+                baseRevision: rawBase,
+                lens,
+                authorityRefs,
+            };
+            return admitted;
+        }
+        case "gleaner": {
+            const baseRevision = fields.baseRevision;
+            if (baseRevision === undefined || baseRevision.trim() === "") {
+                throw new CliUsageError(`role run admitted gleaner-left base revision is missing: ${runId}`);
+            }
+            const admitted = {
+                role: "gleaner-left",
+                ...base,
+                baseRevision,
+            };
+            return admitted;
+        }
+        case "merge-envelope": {
+            const mergerInputPath = fields.mergerInputPath;
+            if (mergerInputPath === undefined) {
+                throw new CliUsageError(`role run admitted merger input path is missing: ${runId}`);
+            }
+            const derived = fields.derived;
+            if (derived === undefined) {
+                throw new CliUsageError(`role run admitted merger envelope is missing: ${runId}`);
+            }
+            if (fields.instruction.trim() === "") {
+                throw new CliUsageError(`role run admitted merger task is blank: ${runId}`);
+            }
+            const admitted = {
+                role: "merger",
+                ...base,
+                instructionEmpty: false,
+                mergerInputPath,
+                derived,
+            };
+            return admitted;
+        }
+        case "collect-target": {
+            const { prNumber, repository, repositoryDisplay, manifestDigest } = fields;
+            if (repository === undefined ||
+                repositoryDisplay === undefined ||
+                manifestDigest === undefined) {
+                throw new CliUsageError(`role run admitted collector repository identity is missing: ${runId}`);
+            }
+            let parsedRepository;
+            try {
+                parsedRepository = parseCollectorRepository(repositoryDisplay);
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new CliUsageError(detail, { cause: error });
+            }
+            if (parsedRepository.canonical !== repository) {
+                throw new CliUsageError(`role run admitted collector repository does not match its canonical form: ${runId}`);
+            }
+            const admitted = {
+                role: "collector",
+                ...base,
+                ...(prNumber === undefined ? {} : { prNumber }),
+                repository: parsedRepository,
+                ...(fields.requestManifestPath === undefined
+                    ? {}
+                    : { requestManifestPath: fields.requestManifestPath }),
+                ...(fields.waitWindowMs === undefined ? {} : { waitWindowMs: fields.waitWindowMs }),
+                manifestDigest,
+            };
+            return admitted;
+        }
+        case "case-identity": {
+            const { issueNumber, caseRunsPath, caseIdentity } = fields;
+            if (issueNumber === undefined ||
+                caseRunsPath === undefined ||
+                caseIdentity === undefined) {
+                throw new CliUsageError(`role run admitted doctor case identity is missing: ${runId}`);
+            }
+            const admitted = {
+                role: "doctor",
+                ...base,
+                issueNumber,
+                caseRunsPath,
+                caseIdentity,
+            };
+            return admitted;
+        }
+        case "source-locator": {
+            const { sourceRunPath, sourceRun } = fields;
+            if (sourceRunPath === undefined || sourceRun === undefined) {
+                throw new CliUsageError(`role run admitted notary source-run locator is missing: ${runId}`);
+            }
+            const admitted = {
+                role: "notary",
+                ...base,
+                sourceRunPath,
+                sourceRun,
+            };
+            return admitted;
+        }
     }
-    const admitted = {
-        role: "notary",
-        ...resumedBaseAdmitted(loaded),
-        sourceRunPath,
-        sourceRun,
-    };
-    return seatLoadedResult(loaded, admitted);
 }
-/** Load a resumable Inspector run for resume (#633); base admitted identity only. */
-export async function loadResumableInspectorRun(home, runId, authority) {
-    const loaded = await loadResumableRunRecord(home, runId, authority);
-    if (loaded.run.role !== "inspector") {
-        throw new CliUsageError(`role run ${runId} belongs to ${loaded.run.role}, not inspector`);
+/** Worker phase on resume: value must belong to the registry phase set. */
+function resumedWorkerPhase(phase, phases, role, runId) {
+    if (phase === "plan" || phase === "apply") {
+        if (phases.some((item) => item === phase)) {
+            return phase;
+        }
     }
-    const admitted = {
-        role: "inspector",
-        ...resumedBaseAdmitted(loaded),
-        ...(loaded.admittedFields.sourceRunPath === undefined
-            ? {}
-            : { sourceRunPath: loaded.admittedFields.sourceRunPath }),
-    };
-    return seatLoadedResult(loaded, admitted);
-}
-export async function peekRoleRunRole(home, runId) {
-    const runDirectory = await findRunDirectoryById(home, runId);
-    if (runDirectory === undefined)
-        return undefined;
-    const run = await readRoleRunIdentity(runDirectory);
-    return run?.role;
+    throw new CliUsageError(`role run admitted ${role} phase is missing: ${runId}`);
 }