@akagilnc/pi-workflow-roles 0.1.3280 → 0.1.3353

package/src/public-cli/cli.ts

@@ -37,6 +37,7 @@ import {
 import { seatModelOnly } from "./registry.ts";
 import { CliUsageError } from "./cli-errors.ts";
 import type { CliIo } from "./cli-io.ts";
+import type { PostAdmissionEnv } from "./post-admission.ts";
 import type { RoleTurnHost } from "../host-contracts.ts";
 import { loadProductionGrokHostFactory } from "./load-production-grok-host.ts";
 import {
@@ -73,15 +74,14 @@ import {
   type TypedOptionConsumer,
 } from "./option-definitions.ts";
 import { runPublicCoder, runPublicCoderResume } from "./coder-run.ts";
-import { runPublicInstructionSeat } from "./instruction-seat-run.ts";
-import { runPublicCollector } from "./collector-run.ts";
+import { runPublicInstructionSeat, runPublicInstructionSeatResume } from "./instruction-seat-run.ts";
+import { runPublicCollector, runPublicCollectorResume } from "./collector-run.ts";
 import { runPublicCountersign, runPublicCountersignResume } from "./countersign-run.ts";
 import { runPublicGleanerLeft, runPublicGleanerLeftResume } from "./gleaner-left-run.ts";
-import { ONE_SHOT_ROLES } from "../packaged-role-registry.ts";
-import { runPublicDoctor } from "./doctor-run.ts";
+import { runPublicDoctor, runPublicDoctorResume } from "./doctor-run.ts";
 import { runPublicFixer, runPublicFixerResume } from "./fixer-run.ts";
-import { runPublicNotary } from "./notary-run.ts";
-import { runPublicInspector } from "./inspector-run.ts";
+import { runPublicNotary, runPublicNotaryResume } from "./notary-run.ts";
+import { runPublicInspector, runPublicInspectorResume } from "./inspector-run.ts";
 import { runPublicJudge, runPublicResume } from "./judge-run.ts";
 import { runPublicMerger, runPublicMergerResume } from "./merger-run.ts";
 import { runPublicReviewer, runPublicReviewerResume } from "./reviewer-run.ts";
@@ -91,6 +91,41 @@ import {
   peekRoleRunRole,
   type PublicResumeRequest,
 } from "./run-lifecycle.ts";
+
+/**
+ * Single authoritative resume dispatch (#633): durable role → seat + public
+ * resume runner. Seat-specific loader validation, turn projection, and
+ * adapters live in each seat's resume module.
+ */
+const RESUME_SEAT_DISPATCH: Record<
+  NonNullable<Awaited<ReturnType<typeof peekRoleRunRole>>>,
+  {
+    readonly seat: PublicCallableRole;
+    readonly run: (
+      request: PublicResumeRequest,
+      env: PostAdmissionEnv,
+      io: CliIo,
+    ) => Promise<{
+      exitCode: number;
+      terminal?: TerminalResult;
+      staleWriterLeaseReclaimed?: true;
+    }>;
+  }
+> = {
+  judge: { seat: "judge", run: runPublicResume },
+  coder: { seat: "coder", run: runPublicCoderResume },
+  fixer: { seat: "fixer", run: runPublicFixerResume },
+  reviewer: { seat: "reviewer", run: runPublicReviewerResume },
+  merger: { seat: "merger", run: runPublicMergerResume },
+  countersign: { seat: "countersign", run: runPublicCountersignResume },
+  "gleaner-left": { seat: "gleaner-left", run: runPublicGleanerLeftResume },
+  collector: { seat: "collector", run: runPublicCollectorResume },
+  doctor: { seat: "doctor", run: runPublicDoctorResume },
+  notary: { seat: "notary", run: runPublicNotaryResume },
+  inspector: { seat: "inspector", run: runPublicInspectorResume },
+  gatekeeper: { seat: "gatekeeper", run: runPublicInstructionSeatResume },
+  navigator: { seat: "navigator", run: runPublicInstructionSeatResume },
+};
 import {
   INTERNAL_ROLE_ENTRYPOINT_RELATIVE,
   isPublicCallableRole,
@@ -1148,135 +1183,25 @@ export async function runAkRole(
         env.credentials ?? (await loadCredentialProviders(agentDir));
       const resumeRequest = parseResumeRequest(parsed.args);
       const resumeRole = await peekRoleRunRole(home, resumeRequest.runId);
-      // One-shot seats refuse resume — single typed owner, not a per-role chain.
-      if (resumeRole !== undefined && ONE_SHOT_ROLES.includes(resumeRole)) {
-        throw new CliUsageError(
-          `${resumeRole} role runs are one-shot and cannot be resumed`,
-        );
-      }
-      const resumeSeatRole =
-        resumeRole === "coder"
-          ? "coder"
-          : resumeRole === "fixer"
-            ? "fixer"
-            : resumeRole === "reviewer"
-              ? "reviewer"
-              : resumeRole === "merger"
-                ? "merger"
-                : resumeRole === "countersign"
-                  ? "countersign"
-                  : resumeRole === "gleaner-left"
-                    ? "gleaner-left"
-                    : "judge";
+      // #633: single authoritative resume dispatch — the seat follows the
+      // durable admitted role; missing durable role keeps the judge path.
+      const dispatch =
+        resumeRole === undefined
+          ? RESUME_SEAT_DISPATCH.judge
+          : RESUME_SEAT_DISPATCH[resumeRole];
       // #617 DK-4: resume resolves model/host/engine from the live seat table
       // exactly as a new leg would (flag → persistent → default). Cross-host
       // resume delivers prior native records as context to the target host.
       const seat = resolveEffectiveSeat(
         config,
-        resumeSeatRole,
+        dispatch.seat,
         credentials,
         invocationFromParsed(parsed),
       );
-      if (resumeRole === "coder") {
-        const result = await runPublicCoderResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "coder",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      if (resumeRole === "fixer") {
-        const result = await runPublicFixerResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "fixer",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      if (resumeRole === "reviewer") {
-        const result = await runPublicReviewerResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "reviewer",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      if (resumeRole === "merger") {
-        const result = await runPublicMergerResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "merger",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      if (resumeRole === "countersign") {
-        const result = await runPublicCountersignResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "countersign",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      if (resumeRole === "gleaner-left") {
-        const result = await runPublicGleanerLeftResume(
-          resumeRequest,
-          createRoleEnvironment(env, {
-            role: "gleaner-left",
-            home,
-            agentDir,
-            cwd,
-            credentials,
-            seat,
-            config,
-          }),
-          io,
-        );
-        return cliResultFromRoleRun(result);
-      }
-      const result = await runPublicResume(
+      const result = await dispatch.run(
         resumeRequest,
         createRoleEnvironment(env, {
-          role: "judge",
+          role: dispatch.seat,
           home,
           agentDir,
           cwd,

package/src/public-cli/coder-run.ts

@@ -44,6 +44,7 @@ import {
   runPostAdmissionResumable,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
 
 export type CoderRunEnv = PostAdmissionEnv & {
@@ -256,25 +257,10 @@ export async function runPublicCoderResume(
     }
   }
 
-  const turnRequest = buildCoderTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...(env.engine === undefined ? {} : { engine: env.engine }),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(admitted.correlationId === undefined && env.correlationId === undefined
-      ? {}
-      : { correlationId: admitted.correlationId ?? env.correlationId }),
-    continuation: {
-      kind: "resume",
-      prompt: buildResumeContinuationPrompt({
-        packageRoot: env.packageRoot,
-        ...(env.engine === undefined ? {} : { engine: env.engine }),
-        ...(request.message === undefined ? {} : { message: request.message }),
-      }),
-    },
-  });
+  const turnRequest = buildCoderTurnRequest(
+    admitted,
+    resumeTurnRequestProjectionOptions(admitted, request, env),
+  );
 
   return await runPostAdmissionManualResume({
     admitted,

package/src/public-cli/collector-run.ts

@@ -1,7 +1,7 @@
 /**
  * Public Collector Role run: admit a structured PR target → explicit Internal activate
- * → settle Terminal result (#112 / #517). One-shot; no resume path (Collector rejects
- * session resume/fork/reload). Lifecycle is the shared post-admission coordinator.
+ * → settle Terminal result (#112 / #517). #633: manual resume continues the exact
+ * session. Lifecycle is the shared post-admission coordinator.
  */
 import type { DurablePrincipalAuthority, RoleTurnRequest } from "../host-contracts.ts";
 import { engineSessionMaterialFromOptions } from "../package-resources/engine-material.ts";
@@ -14,9 +14,16 @@ import {
 } from "./invocation.ts";
 import {
   runPostAdmissionOneShot,
+  type PostAdmissionAdapters,
   type PostAdmissionEnv,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
-import { markRunAdmitted } from "./run-lifecycle.ts";
+import {
+  loadResumableCollectorRun,
+  markRunAdmitted,
+  type PublicResumeRequest,
+} from "./run-lifecycle.ts";
 import {
   presentStructuralRejection,
   readCollectorInfrastructureFailure,
@@ -109,25 +116,62 @@ export async function runPublicCollector(
     env,
     io,
     request: turnRequest,
-    adapters: {
-      trySettle: (admitted, authority) => trySettleCollectorTerminalResult(admitted, authority),
-      shouldPresentSettled: () => true,
-      resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
-        const infrastructureFailure = await readCollectorInfrastructureFailure(sessionFile);
-        return (
-          result.knownFailure ??
-          (infrastructureFailure === undefined
-            ? undefined
-            : {
-                cause: infrastructureFailure.cause,
-                diagnostic: infrastructureFailure.diagnostic,
-                ...(infrastructureFailure.identity === undefined
-                  ? {}
-                  : { identity: infrastructureFailure.identity }),
-              })
-        );
-      },
+    adapters: collectorAdapters(),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}
+
+function collectorAdapters(): PostAdmissionAdapters<AdmittedCollectorInvocation> {
+  return {
+    trySettle: (admitted, authority) => trySettleCollectorTerminalResult(admitted, authority),
+    shouldPresentSettled: () => true,
+    resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
+      const infrastructureFailure = await readCollectorInfrastructureFailure(sessionFile);
+      return (
+        result.knownFailure ??
+        (infrastructureFailure === undefined
+          ? undefined
+          : {
+              cause: infrastructureFailure.cause,
+              diagnostic: infrastructureFailure.diagnostic,
+              ...(infrastructureFailure.identity === undefined
+                ? {}
+                : { identity: infrastructureFailure.identity }),
+            })
+      );
     },
+  };
+}
+
+/**
+ * Resume a previously admitted Collector run (#633). Repository/PR identity
+ * restores from the durable admitted request; the session principal reopens.
+ */
+export async function runPublicCollectorResume(
+  request: PublicResumeRequest,
+  env: CollectorRunEnv,
+  io: CliIo,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedCollectorInvocation;
+  terminal?: TerminalResult;
+}> {
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: () =>
+      loadResumableCollectorRun(
+      env.home,
+      request.runId,
+      env.principalAuthority,
+    ),
+    buildTurnRequest: (admitted) =>
+      buildCollectorTurnRequest(
+      admitted,
+      resumeTurnRequestProjectionOptions(admitted, request, env),
+    ),
+    adapters: collectorAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

package/src/public-cli/countersign-run.ts

@@ -33,14 +33,14 @@ import {
 } from "./invocation.ts";
 import { tryHomeFromAkRolesPath } from "../activation-ledger-topology.ts";
 import {
-  runPostAdmissionManualResume,
   runPostAdmissionOneShot,
   type PostAdmissionEnv,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
 import {
   loadResumableCountersignRun,
   markRunAdmitted,
-  buildResumeContinuationPrompt,
   type PublicResumeRequest,
 } from "./run-lifecycle.ts";
 import {
@@ -187,47 +187,21 @@ export async function runPublicCountersignResume(
   admitted?: AdmittedCountersignInvocation;
   terminal?: TerminalResult;
 }> {
-  let loaded;
-  try {
-    loaded = await loadResumableCountersignRun(
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: () =>
+      loadResumableCountersignRun(
       env.home,
       request.runId,
       env.principalAuthority,
-    );
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  const { admitted } = loaded;
-  const turnRequest = buildCountersignTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...(env.engine === undefined ? {} : { engine: env.engine }),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(admitted.correlationId === undefined && env.correlationId === undefined
-      ? {}
-      : { correlationId: admitted.correlationId ?? env.correlationId }),
-    continuation: {
-      kind: "resume",
-      prompt: buildResumeContinuationPrompt({
-        packageRoot: env.packageRoot,
-        ...(env.engine === undefined ? {} : { engine: env.engine }),
-        ...(request.message === undefined ? {} : { message: request.message }),
-      }),
-    },
-  });
-
-  return await runPostAdmissionManualResume({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
+    ),
+    buildTurnRequest: (admitted) =>
+      buildCountersignTurnRequest(
+      admitted,
+      resumeTurnRequestProjectionOptions(admitted, request, env),
+    ),
     adapters: countersignAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });

package/src/public-cli/doctor-run.ts

@@ -14,9 +14,16 @@ import {
 } from "./invocation.ts";
 import {
   runPostAdmissionOneShot,
+  type PostAdmissionAdapters,
   type PostAdmissionEnv,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
-import { markRunAdmitted } from "./run-lifecycle.ts";
+import {
+  loadResumableDoctorRun,
+  markRunAdmitted,
+  type PublicResumeRequest,
+} from "./run-lifecycle.ts";
 import {
   presentStructuralRejection,
   trySettleDoctorTerminalResult,
@@ -106,11 +113,48 @@ export async function runPublicDoctor(
     env,
     io,
     request: turnRequest,
-    adapters: {
-      trySettle: (admitted, authority) => trySettleDoctorTerminalResult(admitted, authority),
-      shouldPresentSettled: (terminal) =>
-        isLawfulTypedTerminalOutcome(terminal.roleOutcome),
-    },
+    adapters: doctorAdapters(),
+    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
+  });
+}
+
+function doctorAdapters(): PostAdmissionAdapters<AdmittedDoctorInvocation> {
+  return {
+    trySettle: (admitted, authority) => trySettleDoctorTerminalResult(admitted, authority),
+    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: PublicResumeRequest,
+  env: DoctorRunEnv,
+  io: CliIo,
+): Promise<{
+  exitCode: number;
+  admitted?: AdmittedDoctorInvocation;
+  terminal?: TerminalResult;
+}> {
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: () =>
+      loadResumableDoctorRun(
+      env.home,
+      request.runId,
+      env.principalAuthority,
+    ),
+    buildTurnRequest: (admitted) =>
+      buildDoctorTurnRequest(
+      admitted,
+      resumeTurnRequestProjectionOptions(admitted, request, env),
+    ),
+    adapters: doctorAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

package/src/public-cli/fixer-run.ts

@@ -47,6 +47,7 @@ import {
   runPostAdmissionResumable,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
 
 export type FixerRunEnv = PostAdmissionEnv & {
@@ -264,25 +265,10 @@ export async function runPublicFixerResume(
     )) as { exitCode: number; admitted: AdmittedFixerInvocation; terminal: TerminalResult };
   }
 
-  const turnRequest = buildFixerTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...(env.engine === undefined ? {} : { engine: env.engine }),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(admitted.correlationId === undefined && env.correlationId === undefined
-      ? {}
-      : { correlationId: admitted.correlationId ?? env.correlationId }),
-    continuation: {
-      kind: "resume",
-      prompt: buildResumeContinuationPrompt({
-        packageRoot: env.packageRoot,
-        ...(env.engine === undefined ? {} : { engine: env.engine }),
-        ...(request.message === undefined ? {} : { message: request.message }),
-      }),
-    },
-  });
+  const turnRequest = buildFixerTurnRequest(
+    admitted,
+    resumeTurnRequestProjectionOptions(admitted, request, env),
+  );
 
   return await runPostAdmissionManualResume({
     admitted,

package/src/public-cli/gleaner-left-run.ts

@@ -13,14 +13,14 @@ import {
   type ParseGleanerLeftArgvResult,
 } from "./invocation.ts";
 import {
-  runPostAdmissionManualResume,
   runPostAdmissionOneShot,
   type PostAdmissionEnv,
+  runPostAdmissionSeatResume,
+  resumeTurnRequestProjectionOptions,
 } from "./post-admission.ts";
 import {
   loadResumableGleanerLeftRun,
   markRunAdmitted,
-  buildResumeContinuationPrompt,
   type PublicResumeRequest,
 } from "./run-lifecycle.ts";
 import {
@@ -143,47 +143,21 @@ export async function runPublicGleanerLeftResume(
   admitted?: AdmittedGleanerLeftInvocation;
   terminal?: TerminalResult;
 }> {
-  let loaded;
-  try {
-    loaded = await loadResumableGleanerLeftRun(
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: () =>
+      loadResumableGleanerLeftRun(
       env.home,
       request.runId,
       env.principalAuthority,
-    );
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  const { admitted } = loaded;
-  const turnRequest = buildGleanerLeftTurnRequest(admitted, {
-    packageRoot: env.packageRoot,
-    home: env.home,
-    agentDir: env.agentDir,
-    ...(env.model === undefined ? {} : { model: env.model }),
-    ...(env.engine === undefined ? {} : { engine: env.engine }),
-    ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-    ...(admitted.correlationId === undefined && env.correlationId === undefined
-      ? {}
-      : { correlationId: admitted.correlationId ?? env.correlationId }),
-    continuation: {
-      kind: "resume",
-      prompt: buildResumeContinuationPrompt({
-        packageRoot: env.packageRoot,
-        ...(env.engine === undefined ? {} : { engine: env.engine }),
-        ...(request.message === undefined ? {} : { message: request.message }),
-      }),
-    },
-  });
-
-  return await runPostAdmissionManualResume({
-    admitted,
-    env,
-    io,
-    request: turnRequest,
+    ),
+    buildTurnRequest: (admitted) =>
+      buildGleanerLeftTurnRequest(
+      admitted,
+      resumeTurnRequestProjectionOptions(admitted, request, env),
+    ),
     adapters: gleanerLeftAdapters(),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });