@akagilnc/pi-workflow-roles 0.1.3891 → 0.1.3898

package/dist/public-cli/main.js

@@ -23237,7 +23237,6 @@ async function readSealedSubmission(cwd, runId, homeOrScope) {
   const scoped = recordsForAttempt(owned, scope.attemptId);
   for (let index = scoped.length - 1; index >= 0; index -= 1) {
     const record4 = scoped[index];
-    if (record4?.kind === "post-seal-anomaly") return void 0;
     if (record4?.kind !== "sealed") continue;
     const payload = record4.payload;
     if (payload?.type === "sealed" && isAcceptedProjection(payload.projection)) return payload.projection;
@@ -25207,8 +25206,8 @@ async function readLawfulSettlementEntries(sessionFile) {
     throw error instanceof Error && error.knownCause === "session" ? error : sessionReadFailure(error, "session unreadable");
   }
 }
-async function readLawfulJudgeRoleOutcome(admitted, authority) {
-  const sealed = await sealedLedgerOutcome(admitted);
+async function readLawfulJudgeRoleOutcome(admitted, authority, scope) {
+  const sealed = await sealedLedgerOutcome(admitted, scope);
   if (sealed?.role === "judge") {
     const details = sealed.decisiveFacts;
     return {
@@ -25219,10 +25218,10 @@ async function readLawfulJudgeRoleOutcome(admitted, authority) {
       decisiveFacts: withAuditNoReceiptFacts(details)
     };
   }
-  return auditEscalationLedgerOutcome(admitted, "judge");
+  return auditEscalationLedgerOutcome(admitted, "judge", scope);
 }
-async function settleLawfulJudgeTerminalResult(admitted, authority) {
-  const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority);
+async function settleLawfulJudgeTerminalResult(admitted, authority, scope) {
+  const roleOutcome = await readLawfulJudgeRoleOutcome(admitted, authority, scope);
   if (roleOutcome === void 0) return void 0;
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const entries = await readLawfulSettlementEntries(coordinates.sessionFile) ?? [];
@@ -25242,11 +25241,11 @@ async function settleLawfulJudgeTerminalResult(admitted, authority) {
     coordinates.sessionDirectory
   );
 }
-async function trySettleJudgeTerminalResult(admitted, authority) {
-  return settleLawfulJudgeTerminalResult(admitted, authority);
+async function trySettleJudgeTerminalResult(admitted, authority, scope) {
+  return settleLawfulJudgeTerminalResult(admitted, authority, scope);
 }
-async function settleLawfulCoderTerminalResult(admitted, authority, options = {}) {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder");
+async function settleLawfulCoderTerminalResult(admitted, authority, options = {}, scope) {
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "coder", scope);
   if (ledgerOutcome === void 0) return void 0;
   const roleOutcome = ledgerOutcome;
   const output = ledgerOutcome.kind === "accepted" ? ledgerOutcome.decisiveFacts : void 0;
@@ -25356,8 +25355,8 @@ async function publishFixerArtifacts(admitted, roleOutcome, coordinates, options
     { kind: "evidence", path: evidencePath }
   ];
 }
-async function settleLawfulFixerTerminalResult(admitted, authority, options) {
-  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer");
+async function settleLawfulFixerTerminalResult(admitted, authority, options, scope) {
+  const ledgerOutcome = await closedLedgerOutcome(admitted, "fixer", scope);
   if (ledgerOutcome === void 0) return void 0;
   const roleOutcome = ledgerOutcome;
   const output = ledgerOutcome.kind === "accepted" ? ledgerOutcome.decisiveFacts : void 0;
@@ -25441,11 +25440,11 @@ async function publishCollectorArtifacts(admitted, roleOutcome, coordinates, opt
     { kind: "evidence", path: evidencePath }
   ];
 }
-async function settleLawfulCollectorTerminalResult(admitted, authority) {
+async function settleLawfulCollectorTerminalResult(admitted, authority, scope) {
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-  const roleOutcome = await sealedLedgerOutcome(admitted);
+  const roleOutcome = await sealedLedgerOutcome(admitted, scope);
   if (roleOutcome?.role !== "collector") {
     const scanStart = currentAttemptStartIndex(entries);
     for (let index = entries.length - 1; index >= scanStart; index -= 1) {
@@ -25496,8 +25495,8 @@ async function settleLawfulCollectorTerminalResult(admitted, authority) {
     sessionDirectory
   );
 }
-async function trySettleCollectorTerminalResult(admitted, authority) {
-  return settleLawfulCollectorTerminalResult(admitted, authority);
+async function trySettleCollectorTerminalResult(admitted, authority, scope) {
+  return settleLawfulCollectorTerminalResult(admitted, authority, scope);
 }
 async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, options = {}) {
   await appendRunAttemptHistory({ role: admitted.role, runId: admitted.runId, sessionFile: coordinates.sessionFile }, roleOutcome);
@@ -25549,13 +25548,13 @@ async function publishDoctorArtifacts(admitted, roleOutcome, coordinates, option
     { kind: "evidence", path: evidencePath }
   ];
 }
-async function settleLawfulDoctorTerminalResult(admitted, authority) {
-  const sealed = await sealedLedgerOutcome(admitted);
+async function settleLawfulDoctorTerminalResult(admitted, authority, scope) {
+  const sealed = await sealedLedgerOutcome(admitted, scope);
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
   if (sealed?.role !== "doctor") {
-    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor");
+    const escalation = await auditEscalationLedgerOutcome(admitted, "doctor", scope);
     if (escalation === void 0) return void 0;
     const artifacts2 = await publishDoctorArtifacts(admitted, escalation, coordinates);
     return withOptionalGateProjection(
@@ -25603,8 +25602,8 @@ async function settleLawfulDoctorTerminalResult(admitted, authority) {
     sessionDirectory
   );
 }
-async function trySettleDoctorTerminalResult(admitted, authority) {
-  return settleLawfulDoctorTerminalResult(admitted, authority);
+async function trySettleDoctorTerminalResult(admitted, authority, scope) {
+  return settleLawfulDoctorTerminalResult(admitted, authority, scope);
 }
 function currentAttemptStartIndex(entries) {
   for (let i = entries.length - 1; i >= 0; i -= 1) {
@@ -25738,11 +25737,11 @@ async function settleLawfulAuditorTerminalResult(admitted, authority, scope) {
 async function trySettleAuditorTerminalResult(admitted, authority, scope) {
   return settleLawfulAuditorTerminalResult(admitted, authority, scope);
 }
-async function trySettleCoderTerminalResult(admitted, authority, options = {}) {
-  return settleLawfulCoderTerminalResult(admitted, authority, options);
+async function trySettleCoderTerminalResult(admitted, authority, options = {}, scope) {
+  return settleLawfulCoderTerminalResult(admitted, authority, options, scope);
 }
-async function trySettleFixerTerminalResult(admitted, authority, options) {
-  return settleLawfulFixerTerminalResult(admitted, authority, options);
+async function trySettleFixerTerminalResult(admitted, authority, options, scope) {
+  return settleLawfulFixerTerminalResult(admitted, authority, options, scope);
 }
 function extractReviewerMethodInvocations(entries, options) {
   const observed = [];
@@ -25816,8 +25815,8 @@ async function publishReviewerArtifacts(admitted, roleOutcome, coordinates, opti
     { kind: "evidence", path: evidencePath }
   ];
 }
-async function settleLawfulReviewerTerminalResult(admitted, authority, options) {
-  const sealed = await sealedLedgerOutcome(admitted);
+async function settleLawfulReviewerTerminalResult(admitted, authority, options, scope) {
+  const sealed = await sealedLedgerOutcome(admitted, scope);
   if (sealed?.role !== "reviewer") return void 0;
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
@@ -25856,8 +25855,8 @@ async function settleLawfulReviewerTerminalResult(admitted, authority, options)
     sessionDirectory
   );
 }
-async function trySettleReviewerTerminalResult(admitted, authority, options) {
-  return settleLawfulReviewerTerminalResult(admitted, authority, options);
+async function trySettleReviewerTerminalResult(admitted, authority, options, scope) {
+  return settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
 }
 function extractMergerMethodInvocations(entries, options) {
   const observed = [];
@@ -25927,16 +25926,16 @@ async function publishMergerArtifacts(admitted, roleOutcome, coordinates, option
     { kind: "evidence", path: evidencePath }
   ];
 }
-async function settleLawfulMergerTerminalResult(admitted, authority, options) {
+async function settleLawfulMergerTerminalResult(admitted, authority, options, scope) {
   const coordinates = coordinatesFromAdmitted(authority, admitted);
   const { sessionDirectory, sessionFile } = coordinates;
   const entries = await readLawfulSettlementEntries(sessionFile) ?? [];
-  const roleOutcome = await sealedLedgerOutcome(admitted);
+  const roleOutcome = await sealedLedgerOutcome(admitted, scope);
   if (roleOutcome?.role !== "merger") {
     const latestOutcome = await readLatestSubmissionOutcome(
       admitted.projectRoot,
       admitted.runId,
-      sealedLedgerHome(admitted)
+      ledgerReadScope(admitted, scope)
     );
     if (latestOutcome?.outcome === "correctable-rejection" && latestOutcome.code === "non-sole-round") {
       return void 0;
@@ -25996,8 +25995,8 @@ async function settleLawfulMergerTerminalResult(admitted, authority, options) {
     sessionDirectory
   );
 }
-async function trySettleMergerTerminalResult(admitted, authority, options) {
-  return settleLawfulMergerTerminalResult(admitted, authority, options);
+async function trySettleMergerTerminalResult(admitted, authority, options, scope) {
+  return settleLawfulMergerTerminalResult(admitted, authority, options, scope);
 }
 function publicationAttemptFromError(path, error) {
   if (error instanceof Error) {
@@ -26386,7 +26385,8 @@ function projectRoleTurnRequest(admitted, roleDetails, options) {
     agentDir: options.agentDir,
     runDirectory: admitted.runDirectory,
     ...options.correlationId === void 0 || options.correlationId.trim() === "" ? {} : { correlationId: options.correlationId },
-    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+    ...options.courtAttemptId === void 0 || options.courtAttemptId.length === 0 ? {} : { courtAttemptId: options.courtAttemptId }
   };
 }
 var init_turn_request = __esm({
@@ -26936,6 +26936,30 @@ async function readInvocationHost(runDirectory) {
     throw error;
   }
 }
+async function resolveResumeMethodMaterialAdapters(input) {
+  if (input.shouldLoad === false) {
+    return { kind: "continue", adapters: input.emptyAdapters };
+  }
+  try {
+    const material = await input.loadMaterial();
+    return { kind: "continue", adapters: input.adaptersWith(material) };
+  } catch (error) {
+    const terminal = await presentControlledFailure2(
+      input.admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error,
+        ...input.knownCause === void 0 ? {} : { knownCause: input.knownCause }
+      },
+      input.emptyAdapters,
+      input.authority,
+      input.io
+    );
+    return { kind: "terminal", ...terminal };
+  }
+}
 async function presentControlledFailure2(admitted, failureInput, adapters, authority, io) {
   const hasThrown = Object.hasOwn(failureInput, "thrown");
   const resumeObservation = await resolveControlledFailureResumeObservation({
@@ -27187,7 +27211,8 @@ function resumeTurnRequestProjectionOptions(admitted, request, env, summonsPrepa
     continuation: {
       kind: "resume",
       prompt
-    }
+    },
+    ...request.message === void 0 ? {} : { courtAttemptId: randomUUID5() }
   };
 }
 function isAlreadyFrozenSummonsAttachment(runDirectory, attachmentPath) {
@@ -27222,14 +27247,25 @@ async function runPostAdmissionSeatResume(input) {
     }
     throw error;
   }
+  let adapters = input.adapters;
+  if (input.afterAdmittedLoad !== void 0) {
+    const prepared = await input.afterAdmittedLoad(loaded.admitted);
+    if (prepared.kind === "terminal") {
+      return {
+        exitCode: prepared.exitCode,
+        admitted: prepared.admitted,
+        terminal: prepared.terminal
+      };
+    }
+    adapters = prepared.adapters;
+  }
   try {
     return await runPostAdmissionManualResume({
       admitted: loaded.admitted,
       env: input.env,
       io: input.io,
-      adapters: input.adapters,
+      adapters,
       ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine },
-      forceContinuation: true,
       buildRequestAfterLease: async () => {
         let openCourtAttemptId;
         let admittedForBuild = loaded.admitted;
@@ -27281,7 +27317,7 @@ async function runPostAdmissionSeatResume(input) {
           }
         }
         let turnRequest = await input.buildTurnRequest(admittedForBuild, request);
-        if (openCourtAttemptId !== void 0 || request.summons !== void 0) {
+        if (openCourtAttemptId !== void 0 || request.summons !== void 0 || request.message !== void 0) {
           const courtAttemptId = openCourtAttemptId ?? (turnRequest.courtAttemptId !== void 0 && turnRequest.courtAttemptId.length > 0 ? turnRequest.courtAttemptId : randomUUID5());
           turnRequest = { ...turnRequest, courtAttemptId };
           if (openCourtAttemptId === void 0) {
@@ -27354,38 +27390,6 @@ async function runPostAdmissionResumable(input) {
     })
   });
 }
-async function presentSealedAcceptedManualResumeIfAny(input) {
-  const { admitted, env, io, adapters, shouldPresent } = input;
-  try {
-    const existing = await adapters.trySettle(admitted, env.principalAuthority);
-    if (existing !== void 0 && existing.roleOutcome.kind === "accepted" && shouldPresent(existing)) {
-      existing.autoResumeCount = 0;
-      io.stdout(formatTerminalResult(existing));
-      return {
-        exitCode: exitCodeForTerminalOutcome(existing.roleOutcome),
-        admitted,
-        terminal: existing
-      };
-    }
-  } catch (error) {
-    const disposition = await sealedAcceptanceRedispatchDisposition(admitted);
-    if (disposition.kind === "block") {
-      return await presentControlledFailure2(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: disposition.reason === "authority-failed" ? disposition.cause : error
-        },
-        adapters,
-        env.principalAuthority,
-        io
-      );
-    }
-  }
-  return void 0;
-}
 async function runPostAdmissionManualResume(input) {
   const {
     admitted,
@@ -27393,25 +27397,10 @@ async function runPostAdmissionManualResume(input) {
     io,
     adapters,
     effectiveEngine,
-    forceContinuation,
     buildRequestAfterLease
   } = input;
   let request = input.request;
   const effectiveModel = env.model;
-  const shouldPresent = adapters.shouldPresentSettled ?? ((terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome));
-  const sealedIdempotenceInput = {
-    admitted,
-    env,
-    io,
-    adapters,
-    shouldPresent
-  };
-  if (forceContinuation !== true && request !== void 0) {
-    const presented = await presentSealedAcceptedManualResumeIfAny(
-      sealedIdempotenceInput
-    );
-    if (presented !== void 0) return presented;
-  }
   let lease;
   let staleWriterLeaseReclaimed;
   try {
@@ -27438,17 +27427,6 @@ async function runPostAdmissionManualResume(input) {
         );
       }
       request = await buildRequestAfterLease();
-      if (request.courtAttemptId === void 0 || request.courtAttemptId.length === 0) {
-        const presented = await presentSealedAcceptedManualResumeIfAny(
-          sealedIdempotenceInput
-        );
-        if (presented !== void 0) {
-          return {
-            ...presented,
-            ...staleWriterLeaseReclaimed === true ? { staleWriterLeaseReclaimed: true } : {}
-          };
-        }
-      }
     }
     handedOffToDispatch = true;
     const result2 = await dispatchPostAdmissionTurn({
@@ -27516,9 +27494,14 @@ function buildCoderTurnRequest(admitted, options) {
 }
 function coderAdapters(methodProvenance) {
   return {
-    trySettle: (admitted, authority) => trySettleCoderTerminalResult(admitted, authority, {
-      ...methodProvenance === void 0 ? {} : { methodProvenance }
-    })
+    trySettle: (admitted, authority, scope) => trySettleCoderTerminalResult(
+      admitted,
+      authority,
+      {
+        ...methodProvenance === void 0 ? {} : { methodProvenance }
+      },
+      scope
+    )
   };
 }
 async function runPublicCoder(argv, env, io, parseCoderArgv2) {
@@ -27612,51 +27595,27 @@ async function runPublicCoder(argv, env, io, parseCoderArgv2) {
   });
 }
 async function runPublicCoderResume(request, env, io) {
-  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;
-  if (admitted.phase === "apply") {
-    try {
-      const material = await loadPackagedMethodSkillMaterial(
-        env.packageRoot,
-        "tdd"
-      );
-      methodProvenance = material.provenance;
-    } catch (error) {
-      return await presentControlledFailure2(
-        admitted,
-        {
-          timedOut: false,
-          code: null,
-          stderr: "",
-          thrown: error,
-          knownCause: "activation"
-        },
-        coderAdapters(),
-        env.principalAuthority,
-        io
-      );
-    }
-  }
-  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 === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
@@ -28037,7 +27996,7 @@ async function runPublicCollector(argv, env, io, parseCollectorArgv2) {
 }
 function collectorAdapters() {
   return {
-    trySettle: (admitted, authority) => trySettleCollectorTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) => trySettleCollectorTerminalResult(admitted, authority, scope),
     shouldPresentSettled: () => true,
     resolveRunnerKnownFailure: async ({ result: result2, sessionFile }) => {
       const infrastructureFailure = await readCollectorInfrastructureFailure(sessionFile);
@@ -28697,7 +28656,7 @@ async function runPublicDoctor(argv, env, io, parseDoctorArgv2) {
 }
 function doctorAdapters() {
   return {
-    trySettle: (admitted, authority) => trySettleDoctorTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) => trySettleDoctorTerminalResult(admitted, authority, scope),
     shouldPresentSettled: (terminal) => isLawfulTypedTerminalOutcome(terminal.roleOutcome)
   };
 }
@@ -28757,14 +28716,19 @@ function buildFixerTurnRequest(admitted, options) {
 }
 function fixerAdapters(packageRoot2, methodMaterial) {
   return {
-    trySettle: (admitted, authority) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleFixerTerminalResult(admitted, authority, {
-      methodProvenance: methodMaterial.provenance,
-      methodSkillPath: methodMaterial.skillPath,
-      methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-        packageRoot2,
-        "diagnosing-bugs"
-      )
-    })
+    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleFixerTerminalResult(
+      admitted,
+      authority,
+      {
+        methodProvenance: methodMaterial.provenance,
+        methodSkillPath: methodMaterial.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+          packageRoot2,
+          "diagnosing-bugs"
+        )
+      },
+      scope
+    )
   };
 }
 async function loadFixerMethodMaterial(packageRoot2) {
@@ -28855,44 +28819,24 @@ async function runPublicFixer(argv, env, io, parseFixerArgv2) {
   });
 }
 async function runPublicFixerResume(request, env, io) {
-  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;
-  try {
-    methodMaterial = await loadFixerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return await presentControlledFailure2(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error
-      },
-      fixerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io
-    );
-  }
-  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 === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
@@ -29258,7 +29202,7 @@ function buildJudgeTurnRequest(admitted, options) {
 }
 function judgeAdapters() {
   return {
-    trySettle: (admitted, authority) => trySettleJudgeTerminalResult(admitted, authority),
+    trySettle: (admitted, authority, scope) => trySettleJudgeTerminalResult(admitted, authority, scope),
     resolveRunnerKnownFailure: async ({ result: result2, sessionFile }) => {
       const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
       return result2.knownFailure ?? (infrastructureFailure === void 0 ? void 0 : {
@@ -29385,14 +29329,19 @@ function buildMergerTurnRequest(admitted, options) {
 }
 function mergerAdapters(packageRoot2, methodMaterial) {
   return {
-    trySettle: (admitted, authority) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleMergerTerminalResult(admitted, authority, {
-      methodProvenance: methodMaterial.provenance,
-      methodSkillPath: methodMaterial.skillPath,
-      methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-        packageRoot2,
-        "resolving-merge-conflicts"
-      )
-    }),
+    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleMergerTerminalResult(
+      admitted,
+      authority,
+      {
+        methodProvenance: methodMaterial.provenance,
+        methodSkillPath: methodMaterial.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+          packageRoot2,
+          "resolving-merge-conflicts"
+        )
+      },
+      scope
+    ),
     shouldPresentSettled: (t) => isLawfulTypedTerminalOutcome(t.roleOutcome) || t.roleOutcome.kind === "incomplete"
   };
 }
@@ -29500,45 +29449,25 @@ async function runPublicMerger(argv, env, io, parseMergerArgv2) {
   });
 }
 async function runPublicMergerResume(request, env, io) {
-  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;
-  try {
-    methodMaterial = await loadMergerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return await presentControlledFailure2(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error,
-        knownCause: "activation"
-      },
-      mergerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io
-    );
-  }
-  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 === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
@@ -29578,14 +29507,19 @@ function buildReviewerTurnRequest(admitted, options) {
 function reviewerAdapters(packageRoot2, methodMaterial) {
   return {
     beforeDispatch: (admitted) => clearReviewerDispatchRejection(admitted.runDirectory),
-    trySettle: (admitted, authority) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleReviewerTerminalResult(admitted, authority, {
-      methodProvenance: methodMaterial.provenance,
-      methodSkillPath: methodMaterial.skillPath,
-      methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-        packageRoot2,
-        "code-review"
-      )
-    }),
+    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleReviewerTerminalResult(
+      admitted,
+      authority,
+      {
+        methodProvenance: methodMaterial.provenance,
+        methodSkillPath: methodMaterial.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+          packageRoot2,
+          "code-review"
+        )
+      },
+      scope
+    ),
     resolveRunnerKnownFailure: async ({ result: result2, sessionFile }) => {
       const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
       return infrastructureFailure === void 0 ? result2.knownFailure : {
@@ -29684,45 +29618,25 @@ async function runPublicReviewer(argv, env, io, parseReviewerArgv2) {
   });
 }
 async function runPublicReviewerResume(request, env, io) {
-  let loaded;
-  try {
-    loaded = await loadResumableReviewerRun(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;
-  try {
-    methodMaterial = await loadReviewerMethodMaterial(env.packageRoot);
-  } catch (error) {
-    return await presentControlledFailure2(
-      admitted,
-      {
-        timedOut: false,
-        code: null,
-        stderr: "",
-        thrown: error
-      },
-      reviewerAdapters(env.packageRoot),
-      env.principalAuthority,
-      io
-    );
-  }
-  const turnRequest = buildReviewerTurnRequest(
-    admitted,
-    resumeTurnRequestProjectionOptions(admitted, request, env)
-  );
-  return await runPostAdmissionManualResume({
-    admitted,
+  return await runPostAdmissionSeatResume({
+    request,
     env,
     io,
-    request: turnRequest,
-    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine },
-    adapters: reviewerAdapters(env.packageRoot, methodMaterial)
+    load: (effective) => loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) => buildReviewerTurnRequest(
+      admitted,
+      resumeTurnRequestProjectionOptions(admitted, effective, env)
+    ),
+    adapters: reviewerAdapters(env.packageRoot),
+    afterAdmittedLoad: (admitted) => resolveResumeMethodMaterialAdapters({
+      admitted,
+      authority: env.principalAuthority,
+      io,
+      loadMaterial: () => loadReviewerMethodMaterial(env.packageRoot),
+      adaptersWith: (material) => reviewerAdapters(env.packageRoot, material),
+      emptyAdapters: reviewerAdapters(env.packageRoot)
+    }),
+    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
   });
 }
 var init_reviewer_run = __esm({