@akagilnc/pi-workflow-roles 0.1.3891 → 0.1.3900

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

@@ -39,8 +39,9 @@ import {
 } from "./turn-request.ts";
 import {
   presentControlledFailure,
-  runPostAdmissionManualResume,
+  resolveResumeMethodMaterialAdapters,
   runPostAdmissionResumable,
+  runPostAdmissionSeatResume,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
   resumeTurnRequestProjectionOptions,
@@ -82,10 +83,15 @@ function coderAdapters(
   methodProvenance?: PackagedMethodSkillProvenance,
 ): PostAdmissionAdapters<AdmittedCoderInvocation> {
   return {
-    trySettle: (admitted, authority) =>
-      trySettleCoderTerminalResult(admitted, authority, {
-        ...(methodProvenance === undefined ? {} : { methodProvenance }),
-      }),
+    trySettle: (admitted, authority, scope) =>
+      trySettleCoderTerminalResult(
+        admitted,
+        authority,
+        {
+          ...(methodProvenance === undefined ? {} : { methodProvenance }),
+        },
+        scope,
+      ),
   };
 }
 
@@ -216,55 +222,31 @@ export async function runPublicCoderResume(
   admitted?: AdmittedCoderInvocation;
   terminal?: TerminalResult;
 }> {
-  let loaded;
-  try {
-    loaded = await loadResumableCoderRun(env.home, request.runId, env.principalAuthority);
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  const { admitted } = loaded;
-
-  let methodProvenance: PackagedMethodSkillProvenance | undefined;
-  if (admitted.phase === "apply") {
-    try {
-      const material = await loadPackagedMethodSkillMaterial(
-        env.packageRoot,
-        "tdd",
-      );
-      methodProvenance = material.provenance;
-    } catch (error) {
-      return (await presentControlledFailure(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: error,
-          knownCause: "activation",
-        },
-        coderAdapters(),
-        env.principalAuthority,
-        io,
-      )) as { exitCode: number; admitted: AdmittedCoderInvocation; terminal: TerminalResult };
-    }
-  }
-
-  const turnRequest = buildCoderTurnRequest(
-    admitted,
-    resumeTurnRequestProjectionOptions(admitted, request, env),
-  );
-
-  return await runPostAdmissionManualResume({
-    admitted,
+  return await runPostAdmissionSeatResume({
+    request,
     env,
     io,
-    request: turnRequest,
-    adapters: coderAdapters(methodProvenance),
+    load: (effective) =>
+      loadResumableCoderRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) =>
+      buildCoderTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(admitted, effective, env),
+      ),
+    adapters: coderAdapters(),
+    // Apply-only method; plan resume keeps empty provenance (same as initial).
+    afterAdmittedLoad: (admitted) =>
+      resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        shouldLoad: admitted.phase === "apply",
+        loadMaterial: () =>
+          loadPackagedMethodSkillMaterial(env.packageRoot, "tdd"),
+        adaptersWith: (material) => coderAdapters(material.provenance),
+        emptyAdapters: coderAdapters(),
+        knownCause: "activation",
+      }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

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

@@ -126,7 +126,8 @@ export async function runPublicCollector(
 
 function collectorAdapters(): PostAdmissionAdapters<AdmittedCollectorInvocation> {
   return {
-    trySettle: (admitted, authority) => trySettleCollectorTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) =>
+      trySettleCollectorTerminalResult(admitted, authority, scope),
     shouldPresentSettled: () => true,
     resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
       const infrastructureFailure = await readCollectorInfrastructureFailure(sessionFile);

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

@@ -120,7 +120,8 @@ export async function runPublicDoctor(
 
 function doctorAdapters(): PostAdmissionAdapters<AdmittedDoctorInvocation> {
   return {
-    trySettle: (admitted, authority) => trySettleDoctorTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) =>
+      trySettleDoctorTerminalResult(admitted, authority, scope),
     shouldPresentSettled: (terminal) =>
       isLawfulTypedTerminalOutcome(terminal.roleOutcome),
   };

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

@@ -42,8 +42,9 @@ import {
 } from "./turn-request.ts";
 import {
   presentControlledFailure,
-  runPostAdmissionManualResume,
+  resolveResumeMethodMaterialAdapters,
   runPostAdmissionResumable,
+  runPostAdmissionSeatResume,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
   resumeTurnRequestProjectionOptions,
@@ -87,17 +88,22 @@ function fixerAdapters(
   methodMaterial?: PackagedMethodSkillMaterial,
 ): PostAdmissionAdapters<AdmittedFixerInvocation> {
   return {
-    trySettle: (admitted, authority) =>
+    trySettle: (admitted, authority, scope) =>
       methodMaterial === undefined
         ? Promise.resolve(undefined)
-        : trySettleFixerTerminalResult(admitted, authority, {
-            methodProvenance: methodMaterial.provenance,
-            methodSkillPath: methodMaterial.skillPath,
-            methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-              packageRoot,
-              "diagnosing-bugs",
-            ),
-          }),
+        : trySettleFixerTerminalResult(
+            admitted,
+            authority,
+            {
+              methodProvenance: methodMaterial.provenance,
+              methodSkillPath: methodMaterial.skillPath,
+              methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+                packageRoot,
+                "diagnosing-bugs",
+              ),
+            },
+            scope,
+          ),
   };
 }
 
@@ -231,48 +237,27 @@ export async function runPublicFixerResume(
   admitted?: AdmittedFixerInvocation;
   terminal?: TerminalResult;
 }> {
-  let loaded;
-  try {
-    loaded = await loadResumableFixerRun(env.home, request.runId, env.principalAuthority);
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  const { admitted } = loaded;
-
-  let methodMaterial: PackagedMethodSkillMaterial;
-  try {
-    methodMaterial = await loadFixerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return (await presentControlledFailure(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error,
-      },
-      fixerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io,
-    )) as { exitCode: number; admitted: AdmittedFixerInvocation; terminal: TerminalResult };
-  }
-
-  const turnRequest = buildFixerTurnRequest(
-    admitted,
-    resumeTurnRequestProjectionOptions(admitted, request, env),
-  );
-
-  return await runPostAdmissionManualResume({
-    admitted,
+  return await runPostAdmissionSeatResume({
+    request,
     env,
     io,
-    request: turnRequest,
-    adapters: fixerAdapters(env.packageRoot, methodMaterial),
+    load: (effective) =>
+      loadResumableFixerRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) =>
+      buildFixerTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(admitted, effective, env),
+      ),
+    adapters: fixerAdapters(env.packageRoot),
+    afterAdmittedLoad: (admitted) =>
+      resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        loadMaterial: () => loadFixerMethodMaterial(env.packageRoot),
+        adaptersWith: (material) => fixerAdapters(env.packageRoot, material),
+        emptyAdapters: fixerAdapters(env.packageRoot),
+      }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

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

@@ -54,7 +54,8 @@ export function buildJudgeTurnRequest(
 
 function judgeAdapters(): PostAdmissionAdapters<AdmittedJudgeInvocation> {
   return {
-    trySettle: (admitted, authority) => trySettleJudgeTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) =>
+      trySettleJudgeTerminalResult(admitted, authority, scope),
     resolveRunnerKnownFailure: async ({ result, sessionFile }) => {
       const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
       return (

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

@@ -40,8 +40,9 @@ import {
 } from "./turn-request.ts";
 import {
   presentControlledFailure,
-  runPostAdmissionManualResume,
+  resolveResumeMethodMaterialAdapters,
   runPostAdmissionResumable,
+  runPostAdmissionSeatResume,
   type PostAdmissionAdapters,
   type PostAdmissionEnv,
   resumeTurnRequestProjectionOptions,
@@ -83,17 +84,22 @@ function mergerAdapters(
   methodMaterial?: PackagedMethodSkillMaterial,
 ): PostAdmissionAdapters<AdmittedMergerInvocation> {
   return {
-    trySettle: (admitted, authority) =>
+    trySettle: (admitted, authority, scope) =>
       methodMaterial === undefined
         ? Promise.resolve(undefined)
-        : trySettleMergerTerminalResult(admitted, authority, {
-            methodProvenance: methodMaterial.provenance,
-            methodSkillPath: methodMaterial.skillPath,
-            methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-              packageRoot,
-              "resolving-merge-conflicts",
-            ),
-          }),
+        : trySettleMergerTerminalResult(
+            admitted,
+            authority,
+            {
+              methodProvenance: methodMaterial.provenance,
+              methodSkillPath: methodMaterial.skillPath,
+              methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+                packageRoot,
+                "resolving-merge-conflicts",
+              ),
+            },
+            scope,
+          ),
     shouldPresentSettled: (t) =>
       isLawfulTypedTerminalOutcome(t.roleOutcome) || t.roleOutcome.kind === "incomplete",
   };
@@ -258,49 +264,28 @@ export async function runPublicMergerResume(
   admitted?: AdmittedMergerInvocation;
   terminal?: TerminalResult;
 }> {
-  let loaded;
-  try {
-    loaded = await loadResumableMergerRun(env.home, request.runId, env.principalAuthority);
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-
-  const { admitted } = loaded;
-
-  let methodMaterial: PackagedMethodSkillMaterial;
-  try {
-    methodMaterial = await loadMergerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return (await presentControlledFailure(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error,
-        knownCause: "activation",
-      },
-      mergerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io,
-    )) as { exitCode: number; admitted: AdmittedMergerInvocation; terminal: TerminalResult };
-  }
-
-  const turnRequest = buildMergerTurnRequest(
-    admitted,
-    resumeTurnRequestProjectionOptions(admitted, request, env),
-  );
-
-  return await runPostAdmissionManualResume({
-    admitted,
+  return await runPostAdmissionSeatResume({
+    request,
     env,
     io,
-    request: turnRequest,
-    adapters: mergerAdapters(env.packageRoot, methodMaterial),
+    load: (effective) =>
+      loadResumableMergerRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) =>
+      buildMergerTurnRequest(
+        admitted,
+        resumeTurnRequestProjectionOptions(admitted, effective, env),
+      ),
+    adapters: mergerAdapters(env.packageRoot),
+    afterAdmittedLoad: (admitted) =>
+      resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        loadMaterial: () => loadMergerMethodMaterial(env.packageRoot),
+        adaptersWith: (material) => mergerAdapters(env.packageRoot, material),
+        emptyAdapters: mergerAdapters(env.packageRoot),
+        knownCause: "activation",
+      }),
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }