@akagilnc/pi-workflow-roles 0.1.4526 → 0.1.4586

package/dist/public-cli/main.js

@@ -17694,7 +17694,7 @@ async function listPullRequestNumbersByCommit(runner, input) {
 function createGhApiRunner(options = {}) {
   const spawnImpl = options.spawnImpl ?? spawn2;
   return async (args, runOptions = {}) => {
-    return await new Promise((resolve10, reject) => {
+    return await new Promise((resolve11, reject) => {
       const signal = runOptions.signal;
       if (signal?.aborted) {
         reject(signal.reason ?? new Error("aborted"));
@@ -17767,11 +17767,11 @@ function createGhApiRunner(options = {}) {
               const value = line2.slice(idx + 1).trim();
               headers[name] = value;
             }
-            resolve10({ status, headers, bodyText });
+            resolve11({ status, headers, bodyText });
             return;
           }
           if (code === 0) {
-            resolve10({ status: 200, headers: {}, bodyText: stdout });
+            resolve11({ status: 200, headers: {}, bodyText: stdout });
             return;
           }
           const failure = new Error(
@@ -20096,12 +20096,12 @@ var init_option_definitions = __esm({
         canonical: "--lens",
         aliases: [],
         valueMetavar: "completeness|correctness",
-        required: true,
+        required: false,
         repeatable: false,
         form: "option",
         description: {
-          en: "Required single review lens: completeness or correctness (no default).",
-          zh: "\u5FC5\u586B\u5355 lens\uFF1Acompleteness \u6216 correctness\uFF08\u65E0\u9ED8\u8BA4\u503C\uFF09\u3002"
+          en: "Optional single-lens override: completeness or correctness; omitted runs both in parallel.",
+          zh: "\u53EF\u9009\u5355 lens \u8986\u76D6\uFF1Acompleteness \u6216 correctness\uFF1B\u7701\u7565\u65F6\u5E76\u884C\u8FD0\u884C\u4E24\u8F74\u3002"
         }
       },
       {
@@ -20459,9 +20459,9 @@ var init_option_definitions = __esm({
       },
       reviewer: {
         command: "reviewer",
-        summary: "Fixed-target single-lens review (completeness or correctness).",
+        summary: "Fixed-target parallel two-lens review, with an optional single-lens override.",
         usage: [
-          "ak-role reviewer --base <revision> --lens completeness|correctness --authority-ref <ref> [options] <instruction>"
+          "ak-role reviewer --base <revision> [--lens completeness|correctness] --authority-ref <ref> [options] <instruction>"
         ],
         examples: [
           'ak-role reviewer --base main --lens completeness --authority-ref docs/adr/0001.md "Review the branch."',
@@ -22594,7 +22594,7 @@ function parseReviewerArgv(args) {
     instruction: positional.join(" "),
     attachmentPaths,
     baseRevision,
-    lens,
+    ...lens === void 0 ? {} : { lens },
     authorityRefs,
     ...project === void 0 ? {} : { project }
   };
@@ -22643,6 +22643,7 @@ async function admitReviewerInvocation(options) {
     baseRevision,
     lens,
     authorityRefs: [...authorityRefs],
+    ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId },
     attachments: attachments.map((a) => ({
       provenancePath: a.provenancePath,
       frozenPath: a.frozenPath,
@@ -22670,7 +22671,8 @@ async function admitReviewerInvocation(options) {
     admittedRequestPath,
     baseRevision,
     lens,
-    authorityRefs
+    authorityRefs,
+    ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId }
   };
 }
 function buildReviewerSkillArgProjection(admitted) {
@@ -22887,11 +22889,11 @@ function parseAnalystCohortIssueToken(raw, flag) {
       `${flag} requires a comma-separated list of N or book:N`
     );
   }
-  const sep5 = trimmed.lastIndexOf(":");
-  if (sep5 > 0) {
-    const rhs = trimmed.slice(sep5 + 1);
+  const sep6 = trimmed.lastIndexOf(":");
+  if (sep6 > 0) {
+    const rhs = trimmed.slice(sep6 + 1);
     if (ANALYST_TICKET_NUMBER_PATTERN.test(rhs)) {
-      const bookKey = trimmed.slice(0, sep5);
+      const bookKey = trimmed.slice(0, sep6);
       if (bookKey.trim() === "") {
         throw new CliUsageError(
           `${flag} book:N requires a non-empty book key, got ${raw}`
@@ -24108,8 +24110,8 @@ async function readRunTerminalArtifact(runDirectory) {
     const read = await readTerminalArtifactAtPath(path, file);
     if (read !== void 0) return read;
   }
-  for (const relative3 of RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS) {
-    const path = join20(runDirectory, relative3);
+  for (const relative4 of RUN_TERMINAL_ERROR_FALLBACK_RELATIVE_PATHS) {
+    const path = join20(runDirectory, relative4);
     const read = await readTerminalArtifactAtPath(path, "error.json");
     if (read !== void 0) return read;
   }
@@ -24990,6 +24992,15 @@ function formatTerminalResult(result2) {
       );
     }
   }
+  if (result2.reviewerChildOutcomes !== void 0) {
+    for (const axis of ["completeness", "correctness"]) {
+      const child = result2.reviewerChildOutcomes[axis];
+      lines.push(`reviewer-child	${axis}	${child.exitCode}`);
+      if (child.stderr !== void 0 && child.stderr !== "") {
+        lines.push(`reviewer-child-diagnostic	${axis}	${encodeTerminalField(child.stderr)}`);
+      }
+    }
+  }
   if (result2.resume !== void 0) {
     lines.push(`resume	${encodeTerminalField(result2.resume.command)}`);
   } else if (result2.runId !== void 0) {
@@ -27450,10 +27461,10 @@ function presentFailureTerminal(terminal, io) {
 }
 function defaultNavigatorGraceSleep() {
   let timer;
-  const sleep2 = ((ms) => new Promise((resolve10) => {
+  const sleep2 = ((ms) => new Promise((resolve11) => {
     timer = setTimeout(() => {
       timer = void 0;
-      resolve10();
+      resolve11();
     }, ms);
   }));
   sleep2.cancel = () => {
@@ -27465,7 +27476,7 @@ function defaultNavigatorGraceSleep() {
   return sleep2;
 }
 function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep2 = defaultNavigatorGraceSleep()) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     let settled = false;
     const finish = (action) => {
       if (settled) return;
@@ -27474,11 +27485,11 @@ function raceNavigatorGrace(work, graceMs = NAVIGATOR_POST_ROLE_GRACE_MS, sleep2
       action();
     };
     void work.then(
-      (value) => finish(() => resolve10({ status: "done", value })),
+      (value) => finish(() => resolve11({ status: "done", value })),
       (error) => finish(() => reject(error))
     );
     void sleep2(graceMs).then(() => {
-      finish(() => resolve10({ status: "timeout" }));
+      finish(() => resolve11({ status: "timeout" }));
     });
   });
 }
@@ -27547,7 +27558,7 @@ var init_settlement = __esm({
 
 // src/public-cli/turn-request.ts
 function projectRoleTurnRequest(admitted, roleDetails, options) {
-  const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
+  const cwd = options.cwd ?? admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
   if (cwd === void 0) throw new Error("admitted invocation missing working directory");
   if (admitted.principal === void 0) throw new Error("admitted invocation missing principal");
   return {
@@ -28838,6 +28849,8 @@ async function runPostAdmissionSeatResume(input) {
     }
     adapters = prepared.adapters;
   }
+  let env = input.env;
+  let preparedCleanup;
   const buildRequestAfterLease = async () => {
     let openCourtAttemptId;
     let admittedForBuild = loaded.admitted;
@@ -28888,7 +28901,12 @@ async function runPostAdmissionSeatResume(input) {
     return turnRequest;
   };
   try {
-    if (input.env.stationChild === true) {
+    if (input.afterAdmittedPrepare !== void 0) {
+      const prepared = await input.afterAdmittedPrepare(loaded.admitted);
+      if (prepared.env !== void 0) env = prepared.env;
+      preparedCleanup = prepared.cleanup;
+    }
+    if (env.stationChild === true) {
       let firstTurn;
       const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
       const invocationScopeId = mintEngineDetourInvocationScope({
@@ -28896,14 +28914,14 @@ async function runPostAdmissionSeatResume(input) {
       });
       return await runWithAutoResumeLoop({
         admitted: loaded.admitted,
-        principalAuthority: input.env.principalAuthority,
+        principalAuthority: env.principalAuthority,
         isPrincipalAvailable: resolveHostAwareSessionAvailability(
-          input.env.host,
-          input.env.principalAuthority
+          env.host,
+          env.principalAuthority
         ),
         io: input.io,
-        sessionAppender: input.env.sessionAppender,
-        autoResumeLimit: input.env.autoResumeLimit,
+        sessionAppender: env.sessionAppender,
+        autoResumeLimit: env.autoResumeLimit,
         buildInitialPayload: () => ({ resumeTurn: false }),
         buildResumePayload: () => ({ resumeTurn: true }),
         // Same as public manual resume: prior-court sealed acceptance is not a
@@ -28930,7 +28948,7 @@ async function runPostAdmissionSeatResume(input) {
           dispatch: async (turnRequest) => {
             const result2 = await dispatchPostAdmissionTurn({
               admitted: loaded.admitted,
-              env: input.env,
+              env,
               io: attemptIo,
               request: turnRequest,
               lease,
@@ -28940,7 +28958,7 @@ async function runPostAdmissionSeatResume(input) {
             });
             return settleDeferredPersist(
               loaded.admitted,
-              input.env.principalAuthority,
+              env.principalAuthority,
               stationAdapters,
               attemptIo,
               result2
@@ -28951,7 +28969,7 @@ async function runPostAdmissionSeatResume(input) {
     }
     return await runPostAdmissionManualResume({
       admitted: loaded.admitted,
-      env: input.env,
+      env,
       io: input.io,
       adapters,
       ...input.effectiveEngine === void 0 ? {} : { effectiveEngine: input.effectiveEngine },
@@ -28963,6 +28981,10 @@ async function runPostAdmissionSeatResume(input) {
       return { exitCode: 2 };
     }
     throw error;
+  } finally {
+    if (preparedCleanup !== void 0) {
+      await preparedCleanup();
+    }
   }
 }
 async function runPostAdmissionOneShot(input) {
@@ -30423,16 +30445,346 @@ var init_diarist_run = __esm({
   }
 });
 
+// src/public-cli/reviewer-run.ts
+var reviewer_run_exports = {};
+__export(reviewer_run_exports, {
+  buildReviewerTurnRequest: () => buildReviewerTurnRequest,
+  runPublicReviewer: () => runPublicReviewer,
+  runPublicReviewerResume: () => runPublicReviewerResume
+});
+import { resolve as resolve9 } from "node:path";
+function reviewerMethods(packageRoot2) {
+  return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot2, "ak-cross-m-review") }];
+}
+async function runReviewerTurnInFreshCopy(env, projectRoot, io, body) {
+  if (env.executionCwd !== void 0) {
+    return body(env);
+  }
+  const { withEphemeralReviewerWorktree: withEphemeralReviewerWorktree2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+  return await withEphemeralReviewerWorktree2({
+    projectRoot,
+    onCleanupDiagnostic: (diagnostic) => {
+      io.stderr(`${diagnostic}
+`);
+    },
+    run: (executionCwd) => body({ ...env, executionCwd })
+  });
+}
+function buildReviewerTurnRequest(admitted, options) {
+  return projectRoleTurnRequest(
+    admitted,
+    {
+      activation: {
+        role: "reviewer",
+        baseRevision: admitted.baseRevision,
+        lens: admitted.lens,
+        authorityRefs: admitted.authorityRefs,
+        ...admitted.ticketNumber === void 0 ? {} : { ticketNumber: admitted.ticketNumber }
+      },
+      methods: reviewerMethods(options.packageRoot)
+    },
+    options
+  );
+}
+function reviewerAdapters(packageRoot2, methodMaterial) {
+  return {
+    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleReviewerTerminalResult(
+      admitted,
+      authority,
+      {
+        methodProvenance: methodMaterial.provenance,
+        methodSkillPath: methodMaterial.skillPath,
+        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
+          packageRoot2,
+          "ak-cross-m-review"
+        )
+      },
+      scope
+    ),
+    resolveRunnerKnownFailure: async ({ result: result2, sessionFile }) => {
+      const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
+      return infrastructureFailure === void 0 ? result2.knownFailure : {
+        ...infrastructureFailure.cause === void 0 ? {} : { cause: infrastructureFailure.cause },
+        diagnostic: infrastructureFailure.diagnostic,
+        ...infrastructureFailure.identity === void 0 ? {} : { identity: infrastructureFailure.identity }
+      };
+    }
+  };
+}
+async function loadReviewerMethodMaterial(packageRoot2) {
+  return await loadPackagedMethodSkillMaterial(packageRoot2, "ak-cross-m-review");
+}
+function reviewerResumePrompt(env, message) {
+  const lines = [RESUME_TRANSPORT_ENVELOPE];
+  if (message !== void 0) lines.push("", message);
+  return appendEngineSessionMaterial(
+    lines,
+    engineSessionMaterialFromOptions({
+      ...pickEngineAxis(env),
+      packageRoot: env.packageRoot
+    })
+  ).join("\n");
+}
+async function runPublicReviewer(argv, env, io, parseReviewerArgv2) {
+  let parsed;
+  try {
+    parsed = parseReviewerArgv2(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+  if (parsed.lens === void 0) {
+    const { summonParallelReviewerLenses: summonParallelReviewerLenses2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+    const children = await summonParallelReviewerLenses2({
+      argv,
+      // Replay argv under the same cwd the single-axis entry would see (10a).
+      // Do not substitute the resolved project path — relative --project must
+      // not be re-resolved against a shifted cwd.
+      cwd: env.cwd,
+      projectRoot: resolve9(parsed.project ?? env.cwd),
+      // Typed base from the public parse — precheck only; child argv stays verbatim.
+      baseRevision: parsed.baseRevision,
+      home: env.home,
+      agentDir: env.agentDir,
+      ...env.credentials === void 0 ? {} : { credentials: env.credentials },
+      ...env.model === void 0 ? {} : { model: env.model },
+      ...env.host === void 0 ? {} : { host: env.host },
+      ...env.engine === void 0 ? {} : { engine: env.engine },
+      ...env.engineModel === void 0 ? {} : { engineModel: env.engineModel },
+      packageRoot: env.packageRoot,
+      ...env.signal === void 0 ? {} : { signal: env.signal },
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      roleTurnHost: env.roleTurnHost,
+      ...env.hostAdapters === void 0 ? {} : { hostAdapters: env.hostAdapters },
+      principalAuthority: env.principalAuthority,
+      ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs }
+    });
+    const childResults = [children.completeness, children.correctness];
+    const terminals = childResults.map((child) => child.terminal).filter((terminal2) => terminal2 !== void 0);
+    const failedChildren = childResults.filter((child) => child.terminal === void 0 || !isLawfulTypedTerminalOutcome(child.terminal.roleOutcome)).length;
+    const overlayExit = childResults.some((child) => child.exitCode !== 0);
+    const failed = failedChildren > 0 || overlayExit;
+    const overlayDiagnostics = [...new Set(
+      childResults.map((child) => child.stderr).filter((text) => typeof text === "string" && text !== "")
+    )];
+    const terminal = {
+      batch: "reviewer",
+      roleOutcome: failed ? {
+        kind: "failure",
+        role: "reviewer",
+        diagnostic: failedChildren > 0 ? "Reviewer batch child failure" : overlayDiagnostics[0] ?? "Reviewer batch infrastructure failure",
+        decisiveFacts: { failedChildren },
+        payloads: terminals
+      } : { kind: "accepted", role: "reviewer", payloads: terminals },
+      reviewerChildren: {
+        ...children.completeness.terminal === void 0 ? {} : { completeness: children.completeness.terminal },
+        ...children.correctness.terminal === void 0 ? {} : { correctness: children.correctness.terminal }
+      },
+      reviewerChildOutcomes: {
+        completeness: { exitCode: children.completeness.exitCode, ...children.completeness.stderr === void 0 ? {} : { stderr: children.completeness.stderr } },
+        correctness: { exitCode: children.correctness.exitCode, ...children.correctness.stderr === void 0 ? {} : { stderr: children.correctness.stderr } }
+      },
+      // Batch has no parent run and no own attendance; no-advice is affirmative
+      // only (navigator-attendance.ts). Children carry their own navigator facts.
+      navigator: {
+        disposition: "unavailable",
+        source: "unknown",
+        reason: "Reviewer batch has no parent-run Navigator attendance"
+      },
+      artifacts: terminals.flatMap((item) => item.artifacts)
+    };
+    io.stdout(formatTerminalResult(terminal));
+    return { exitCode: failed ? 1 : 0, terminal };
+  }
+  let admitted;
+  try {
+    admitted = await admitReviewerInvocation({
+      home: env.home,
+      principalAuthority: env.principalAuthority,
+      cwd: env.cwd,
+      instruction: parsed.instruction,
+      attachmentPaths: parsed.attachmentPaths,
+      baseRevision: parsed.baseRevision,
+      lens: parsed.lens,
+      authorityRefs: parsed.authorityRefs,
+      ...parsed.project === void 0 ? {} : { project: parsed.project },
+      ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
+      ...env.correlationId === void 0 ? {} : { correlationId: env.correlationId },
+      ...env.model === void 0 ? {} : { model: env.model }
+    });
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+  await markRunAdmitted(admitted, env.principalAuthority);
+  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
+    );
+  }
+  try {
+    return await runReviewerTurnInFreshCopy(env, admitted.projectRoot, io, async (sandboxedEnv) => await runPostAdmissionResumable({
+      admitted,
+      env: sandboxedEnv,
+      io,
+      buildInitialRequest: () => buildReviewerTurnRequest(admitted, {
+        packageRoot: sandboxedEnv.packageRoot,
+        home: sandboxedEnv.home,
+        agentDir: sandboxedEnv.agentDir,
+        ...sandboxedEnv.model === void 0 ? {} : { model: sandboxedEnv.model },
+        ...pickEngineAxis(sandboxedEnv),
+        ...sandboxedEnv.timeoutMs === void 0 ? {} : { timeoutMs: sandboxedEnv.timeoutMs },
+        ...admitted.correlationId === void 0 && sandboxedEnv.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId },
+        // Ephemeral worktree cwd; durable projectRoot stays on admitted caller project.
+        ...sandboxedEnv.executionCwd === void 0 ? {} : { cwd: sandboxedEnv.executionCwd },
+        continuation: {
+          kind: "initial",
+          prompt: buildReviewerTransportPrompt(
+            admitted,
+            engineSessionMaterialFromOptions({
+              ...pickEngineAxis(sandboxedEnv),
+              packageRoot: sandboxedEnv.packageRoot
+            })
+          )
+        }
+      }),
+      buildResumeRequest: () => buildReviewerTurnRequest(admitted, {
+        packageRoot: sandboxedEnv.packageRoot,
+        home: sandboxedEnv.home,
+        agentDir: sandboxedEnv.agentDir,
+        ...sandboxedEnv.model === void 0 ? {} : { model: sandboxedEnv.model },
+        ...pickEngineAxis(sandboxedEnv),
+        ...sandboxedEnv.timeoutMs === void 0 ? {} : { timeoutMs: sandboxedEnv.timeoutMs },
+        ...admitted.correlationId === void 0 && sandboxedEnv.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId },
+        // In-batch auto-resume keeps the same call's sandbox (dual-lens or single).
+        ...sandboxedEnv.executionCwd === void 0 ? {} : { cwd: sandboxedEnv.executionCwd },
+        continuation: {
+          kind: "resume",
+          prompt: reviewerResumePrompt(sandboxedEnv)
+        }
+      }),
+      adapters: reviewerAdapters(sandboxedEnv.packageRoot, methodMaterial),
+      ...sandboxedEnv.engine === void 0 ? {} : { effectiveEngine: sandboxedEnv.engine }
+    }));
+  } catch (error) {
+    return await presentControlledFailure2(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error
+      },
+      reviewerAdapters(env.packageRoot, methodMaterial),
+      env.principalAuthority,
+      io
+    );
+  }
+}
+async function runPublicReviewerResume(request, env, io) {
+  const sandbox = {
+    ...env.executionCwd === void 0 ? {} : { executionCwd: env.executionCwd }
+  };
+  return await runPostAdmissionSeatResume({
+    request,
+    env,
+    io,
+    load: (effective) => loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
+    buildTurnRequest: (admitted, effective) => {
+      const activeEnv = sandbox.executionCwd === void 0 ? env : { ...env, executionCwd: sandbox.executionCwd };
+      const base = resumeTurnRequestProjectionOptions(admitted, effective, activeEnv);
+      return buildReviewerTurnRequest(admitted, {
+        ...base,
+        // Fresh copy at resume time; durable projectRoot unchanged.
+        ...sandbox.executionCwd === void 0 ? {} : { cwd: sandbox.executionCwd },
+        continuation: {
+          kind: "resume",
+          prompt: reviewerResumePrompt(activeEnv, effective.message)
+        }
+      });
+    },
+    adapters: reviewerAdapters(env.packageRoot),
+    afterAdmittedLoad: async (admitted) => {
+      return resolveResumeMethodMaterialAdapters({
+        admitted,
+        authority: env.principalAuthority,
+        io,
+        loadMaterial: () => loadReviewerMethodMaterial(env.packageRoot),
+        adaptersWith: (material) => reviewerAdapters(env.packageRoot, material),
+        emptyAdapters: reviewerAdapters(env.packageRoot)
+      });
+    },
+    afterAdmittedPrepare: async (admitted) => {
+      if (sandbox.executionCwd !== void 0) {
+        return { env: { ...env, executionCwd: sandbox.executionCwd } };
+      }
+      const { openEphemeralReviewerWorktree: openEphemeralReviewerWorktree2 } = await Promise.resolve().then(() => (init_public_role_summons(), public_role_summons_exports));
+      const opened = await openEphemeralReviewerWorktree2({
+        projectRoot: admitted.projectRoot,
+        onCleanupDiagnostic: (diagnostic) => {
+          io.stderr(`${diagnostic}
+`);
+        }
+      });
+      sandbox.executionCwd = opened.executionCwd;
+      return {
+        env: { ...env, executionCwd: opened.executionCwd },
+        cleanup: opened.close
+      };
+    },
+    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
+  });
+}
+var init_reviewer_run = __esm({
+  "src/public-cli/reviewer-run.ts"() {
+    "use strict";
+    init_engine_material();
+    init_method_skill();
+    init_cli_errors();
+    init_invocation();
+    init_run_lifecycle();
+    init_settlement();
+    init_terminal();
+    init_turn_request();
+    init_post_admission();
+  }
+});
+
 // src/public-role-summons.ts
 var public_role_summons_exports = {};
 __export(public_role_summons_exports, {
   AK_ROLE_PACKAGE_ROOT_ENV: () => AK_ROLE_PACKAGE_ROOT_ENV,
+  openEphemeralReviewerWorktree: () => openEphemeralReviewerWorktree,
   resolveSummonsPackageRoot: () => resolveSummonsPackageRoot,
   summonGateOfficer: () => summonGateOfficer,
-  summonPublicRole: () => summonPublicRole
+  summonParallelReviewerLenses: () => summonParallelReviewerLenses,
+  summonPublicRole: () => summonPublicRole,
+  withEphemeralReviewerWorktree: () => withEphemeralReviewerWorktree
 });
+import { execFile as execFile3 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join30 } from "node:path";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, realpath as realpath6, rm as rm3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join30, relative as relative3, sep as sep5 } from "node:path";
+import { promisify as promisify3 } from "node:util";
 function createCapturingIo() {
   const chunks = [];
   return {
@@ -30520,13 +30872,14 @@ async function createSummonEnv(options, afterHost) {
     Promise.resolve().then(() => (init_role_turn_host_resolution(), role_turn_host_resolution_exports)),
     Promise.resolve().then(() => (init_config2(), config_exports))
   ]);
-  const principalAuthority = piDurablePrincipalAuthority2;
+  const principalAuthority = options.principalAuthority ?? piDurablePrincipalAuthority2;
   const roleTurnHost = resolveRoleTurnHost2(
     {
       packageRoot: options.packageRoot,
       ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
       ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
-      ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs }
+      ...options.extraPiArgs === void 0 || options.extraPiArgs.length === 0 ? {} : { extraPiArgs: options.extraPiArgs },
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     },
     { role: options.role, seat: options.seat, principalAuthority }
   );
@@ -30539,13 +30892,16 @@ async function createSummonEnv(options, afterHost) {
     };
   }
   const hostName = seatWithModel.host ?? "pi";
-  const { loadHostProvidersTable: loadHostProvidersTable2, projectHostFacingProvider: projectHostFacingProvider2 } = await Promise.resolve().then(() => (init_host_providers(), host_providers_exports));
-  const hostFacingSelection = projectHostFacingProvider2(
-    seatWithModel.selection,
-    hostName,
-    loadHostProvidersTable2(options.home),
-    options.home
-  );
+  let hostFacingSelection = options.hostFacingModel;
+  if (hostFacingSelection === void 0) {
+    const { loadHostProvidersTable: loadHostProvidersTable2, projectHostFacingProvider: projectHostFacingProvider2 } = await Promise.resolve().then(() => (init_host_providers(), host_providers_exports));
+    hostFacingSelection = projectHostFacingProvider2(
+      seatWithModel.selection,
+      hostName,
+      loadHostProvidersTable2(options.home),
+      options.home
+    );
+  }
   return {
     ok: true,
     env: {
@@ -30559,7 +30915,8 @@ async function createSummonEnv(options, afterHost) {
       credentials: options.credentials,
       ...hostFacingSelection === void 0 ? {} : { model: hostFacingSelection },
       ...projectSeatEngine(seatWithModel),
-      ...projectSeatHost(seatWithModel)
+      ...projectSeatHost(seatWithModel),
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
     }
   };
 }
@@ -30574,7 +30931,19 @@ async function summonPublicRole(options) {
   } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const credentials = options.credentials ?? await loadCredentialProviders2(agentDir);
   const config = await loadPublicCliConfig2(home);
-  const seat = resolveEffectiveSeat2(config, options.role, credentials);
+  const resolvedSeat = resolveEffectiveSeat2(config, options.role, credentials);
+  const inheritedSelection = options.model === void 0 ? void 0 : {
+    provider: options.model.provider,
+    model: options.model.model,
+    ...options.model.thinking === void 0 ? {} : { thinking: options.model.thinking }
+  };
+  const seat = {
+    ...resolvedSeat,
+    ...inheritedSelection === void 0 ? {} : { selection: inheritedSelection, source: "invocation" },
+    ...options.host === void 0 ? {} : { host: options.host, hostSource: "invocation" },
+    ...options.engine === void 0 ? {} : { engine: options.engine, engineSource: "invocation" },
+    ...options.engineModel === void 0 ? {} : { engineModel: options.engineModel }
+  };
   const captured = options.io === void 0 ? createCapturingIo() : void 0;
   const io = options.io ?? captured.io;
   const summonEnvInput = {
@@ -30587,7 +30956,11 @@ async function summonPublicRole(options) {
     seat,
     ...options.extraPiArgs === void 0 ? {} : { extraPiArgs: options.extraPiArgs },
     ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
-    ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters }
+    ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
+    ...options.principalAuthority === void 0 ? {} : { principalAuthority: options.principalAuthority },
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+    // Parent model is already host-facing; child must not project again.
+    ...options.model === void 0 ? {} : { hostFacingModel: options.model }
   };
   async function prepareSummonEnv(afterHost) {
     try {
@@ -30599,7 +30972,9 @@ async function summonPublicRole(options) {
         ok: true,
         env: {
           ...built.env,
-          stationChild: true,
+          // Nested court stations keep station-child semantics; dual-lens
+          // ordinary Reviewer axes opt out (#946 / ADR 0082).
+          ...options.stationChild === false ? {} : { stationChild: true },
           // Forward composition-root adapters so nested court stations (e.g.
           // countersign → diarist) select the same faux/production table (#924).
           ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
@@ -30609,7 +30984,8 @@ async function summonPublicRole(options) {
           ...options.gateReviewInstruction === void 0 ? {} : { gateReviewInstruction: options.gateReviewInstruction },
           ...options.boundTicketNumber === void 0 ? {} : { boundTicketNumber: options.boundTicketNumber },
           ...options.correlationId === void 0 || options.correlationId.trim() === "" ? {} : { correlationId: options.correlationId },
-          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
+          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId },
+          ...options.executionCwd === void 0 ? {} : { executionCwd: options.executionCwd }
         }
       };
     } catch (error) {
@@ -30721,6 +31097,16 @@ async function summonPublicRole(options) {
       result2 = stepped.ok;
       break;
     }
+    case "reviewer": {
+      const [{ runPublicReviewer: runPublicReviewer2 }, { parseReviewerArgv: parseReviewerArgv2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_reviewer_run(), reviewer_run_exports)),
+        Promise.resolve().then(() => (init_invocation(), invocation_exports))
+      ]);
+      const stepped = await runPrepared(parseReviewerArgv2, (env, once) => runPublicReviewer2(options.argv, env, io, once));
+      if ("fail" in stepped) return stepped.fail;
+      result2 = stepped.ok;
+      break;
+    }
   }
   const stderr = captured?.stderrText();
   const runDirectory = result2.admitted?.runDirectory;
@@ -30732,6 +31118,296 @@ async function summonPublicRole(options) {
     ...stderr === void 0 || stderr === "" ? {} : { stderr }
   };
 }
+function withReviewerLens(argv, lens) {
+  const separator = argv.indexOf("--");
+  if (separator === -1) return [...argv, "--lens", lens];
+  return [...argv.slice(0, separator), "--lens", lens, ...argv.slice(separator)];
+}
+async function resolveReviewerWorktreeRoots(projectRoot) {
+  const callerProjectRoot = await realpath6(projectRoot);
+  const sourceProjectRoot = await realpath6((await execFileAsync3(
+    "git",
+    ["rev-parse", "--show-toplevel"],
+    { cwd: callerProjectRoot }
+  )).stdout.trim());
+  const callerRelative = relative3(sourceProjectRoot, callerProjectRoot);
+  const projectRelative = callerRelative === "" || callerRelative === "." || callerRelative.startsWith(`..${sep5}`) || callerRelative === ".." ? "" : callerRelative;
+  return { callerProjectRoot, sourceProjectRoot, projectRelative };
+}
+function reviewerSandboxPath(worktreeAxis, projectRelative) {
+  return projectRelative === "" ? worktreeAxis : join30(worktreeAxis, projectRelative);
+}
+async function openEphemeralReviewerWorktree(options) {
+  const { sourceProjectRoot, projectRelative } = await resolveReviewerWorktreeRoots(
+    options.projectRoot
+  );
+  const { stdout: headStdout } = await execFileAsync3(
+    "git",
+    ["rev-parse", "--verify", "HEAD^{commit}"],
+    { cwd: sourceProjectRoot }
+  );
+  const targetCommit = headStdout.trim();
+  const root = await mkdtemp3(join30(tmpdir3(), "ak-reviewer-sandbox-"));
+  const worktreeRoot = join30(root, "work");
+  let registered = false;
+  const rollback = async (cause) => {
+    const cleanupErrors = [];
+    if (registered) {
+      try {
+        await execFileAsync3("git", ["worktree", "remove", "--force", worktreeRoot], {
+          cwd: sourceProjectRoot
+        });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+    }
+    try {
+      await rm3(root, { recursive: true, force: true });
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+    if (cleanupErrors.length > 0) {
+      options.onCleanupDiagnostic?.([
+        "reviewer worktree cleanup failed",
+        ...cleanupErrors.map((error) => error instanceof Error ? error.message : String(error))
+      ].join("\n"));
+    }
+    throw cause;
+  };
+  try {
+    await execFileAsync3("git", ["worktree", "add", "--detach", worktreeRoot, targetCommit], {
+      cwd: sourceProjectRoot
+    });
+    registered = true;
+    if (projectRelative !== "") {
+      await mkdir5(reviewerSandboxPath(worktreeRoot, projectRelative), { recursive: true });
+    }
+  } catch (error) {
+    await rollback(error);
+  }
+  let closed = false;
+  return {
+    executionCwd: reviewerSandboxPath(worktreeRoot, projectRelative),
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      const cleanupErrors = [];
+      try {
+        await execFileAsync3("git", ["worktree", "remove", worktreeRoot], {
+          cwd: sourceProjectRoot
+        });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      try {
+        await rm3(root, { recursive: true, force: true });
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+      if (cleanupErrors.length > 0) {
+        options.onCleanupDiagnostic?.([
+          "reviewer worktree cleanup failed",
+          ...cleanupErrors.map((error) => error instanceof Error ? error.message : String(error))
+        ].join("\n"));
+      }
+    }
+  };
+}
+async function withEphemeralReviewerWorktree(options) {
+  const sandbox = await openEphemeralReviewerWorktree({
+    projectRoot: options.projectRoot,
+    ...options.onCleanupDiagnostic === void 0 ? {} : { onCleanupDiagnostic: options.onCleanupDiagnostic }
+  });
+  try {
+    return await options.run(sandbox.executionCwd);
+  } finally {
+    await sandbox.close();
+  }
+}
+async function summonParallelReviewerLenses(options) {
+  const describeFailure = (error) => {
+    if (error instanceof AggregateError) {
+      return [error.message, ...error.errors.map(describeFailure)].join("\n");
+    }
+    return error instanceof Error ? error.message : String(error);
+  };
+  const failedResult = (error) => ({
+    exitCode: 1,
+    stderr: describeFailure(error)
+  });
+  const dualFailure = (error) => {
+    const failure = failedResult(error);
+    return { completeness: failure, correctness: failure };
+  };
+  let sourceProjectRoot;
+  let projectRelative;
+  let targetCommit;
+  const statusArgs = [
+    "status",
+    "--porcelain=v1",
+    "--untracked-files=all",
+    "--",
+    ":/",
+    ":(top,exclude).claude/worktrees/**"
+  ];
+  try {
+    const roots = await resolveReviewerWorktreeRoots(options.projectRoot);
+    sourceProjectRoot = roots.sourceProjectRoot;
+    projectRelative = roots.projectRelative;
+    const { stdout: statusStdout } = await execFileAsync3("git", statusArgs, {
+      cwd: sourceProjectRoot
+    });
+    if (statusStdout !== "") {
+      const diagnostic = [
+        "Reviewer target status gate failed:",
+        "git status --porcelain=v1 --untracked-files=all -- :/ ':(top,exclude).claude/worktrees/**'",
+        statusStdout
+      ].join("\n");
+      return dualFailure(new Error(diagnostic));
+    }
+    const { stdout: targetStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    targetCommit = targetStdout.trim();
+    await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", `${options.baseRevision}^{commit}`],
+      { cwd: sourceProjectRoot }
+    );
+  } catch (error) {
+    return dualFailure(error);
+  }
+  const root = await mkdtemp3(join30(tmpdir3(), "ak-reviewer-lenses-"));
+  const completenessRoot = join30(root, "completeness");
+  const correctnessRoot = join30(root, "correctness");
+  const worktrees = [completenessRoot, correctnessRoot];
+  const created = /* @__PURE__ */ new Set();
+  let results;
+  const creation = await Promise.allSettled(
+    worktrees.map(async (path) => {
+      await execFileAsync3("git", ["worktree", "add", "--detach", path, targetCommit], {
+        cwd: sourceProjectRoot
+      });
+      created.add(path);
+      if (projectRelative !== "") {
+        await mkdir5(reviewerSandboxPath(path, projectRelative), { recursive: true });
+      }
+    })
+  );
+  const creationFailures = creation.flatMap((result2) => result2.status === "rejected" ? [result2.reason] : []);
+  if (creationFailures.length > 0) {
+    const failure = failedResult(new AggregateError(
+      creationFailures,
+      "parallel reviewer worktree creation failed"
+    ));
+    results = { completeness: failure, correctness: failure };
+  } else {
+    const summon = (lens, worktreeAxis) => {
+      const sandbox = reviewerSandboxPath(worktreeAxis, projectRelative);
+      return summonPublicRole({
+        role: "reviewer",
+        argv: withReviewerLens(options.argv, lens),
+        cwd: options.cwd,
+        executionCwd: sandbox,
+        // Ordinary single-axis public semantics — not a nested court station.
+        stationChild: false,
+        home: options.home,
+        ...options.agentDir === void 0 ? {} : { agentDir: options.agentDir },
+        ...options.credentials === void 0 ? {} : { credentials: options.credentials },
+        ...options.model === void 0 ? {} : { model: options.model },
+        ...options.host === void 0 ? {} : { host: options.host },
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineModel === void 0 ? {} : { engineModel: options.engineModel },
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        ...options.correlationId === void 0 ? {} : { correlationId: options.correlationId },
+        ...options.packageRoot === void 0 ? {} : { packageRoot: options.packageRoot },
+        ...options.roleTurnHost === void 0 ? {} : { roleTurnHost: options.roleTurnHost },
+        ...options.hostAdapters === void 0 ? {} : { hostAdapters: options.hostAdapters },
+        ...options.principalAuthority === void 0 ? {} : { principalAuthority: options.principalAuthority },
+        ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+      });
+    };
+    const settled = await Promise.allSettled([
+      summon("completeness", completenessRoot),
+      summon("correctness", correctnessRoot)
+    ]);
+    results = {
+      completeness: settled[0].status === "fulfilled" ? settled[0].value : failedResult(settled[0].reason),
+      correctness: settled[1].status === "fulfilled" ? settled[1].value : failedResult(settled[1].reason)
+    };
+  }
+  let sealDiagnostic;
+  try {
+    const { stdout: headBeforeStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    const { stdout: sealedStatusStdout } = await execFileAsync3("git", statusArgs, {
+      cwd: sourceProjectRoot
+    });
+    const { stdout: headAfterStdout } = await execFileAsync3(
+      "git",
+      ["rev-parse", "--verify", "HEAD^{commit}"],
+      { cwd: sourceProjectRoot }
+    );
+    const headBefore = headBeforeStdout.trim();
+    const headAfter = headAfterStdout.trim();
+    if (headBefore !== targetCommit || headAfter !== targetCommit || sealedStatusStdout !== "") {
+      sealDiagnostic = [
+        "Reviewer target final seal failed:",
+        `HEAD before status => ${headBefore}`,
+        `HEAD after status => ${headAfter}`,
+        `expected PRE_HEAD ${targetCommit}`,
+        "git status --porcelain=v1 --untracked-files=all -- :/ ':(top,exclude).claude/worktrees/**'",
+        sealedStatusStdout
+      ].join("\n");
+    }
+  } catch (error) {
+    sealDiagnostic = `Reviewer target final seal failed:
+${describeFailure(error)}`;
+  }
+  if (sealDiagnostic !== void 0) {
+    const withSealFailure = (result2) => ({
+      ...result2,
+      exitCode: 1,
+      stderr: [result2.stderr, sealDiagnostic].filter(
+        (text) => typeof text === "string" && text !== ""
+      ).join("\n")
+    });
+    results = {
+      completeness: withSealFailure(results.completeness),
+      correctness: withSealFailure(results.correctness)
+    };
+  }
+  const cleanup = await Promise.allSettled(
+    [...created].map((path) => execFileAsync3("git", ["worktree", "remove", path], { cwd: sourceProjectRoot }))
+  );
+  const cleanupFailures = cleanup.flatMap((result2) => result2.status === "rejected" ? [result2.reason] : []);
+  if (cleanupFailures.length === 0) {
+    const rootCleanup = await Promise.allSettled([rm3(root, { recursive: true, force: true })]);
+    cleanupFailures.push(...rootCleanup.flatMap((result2) => result2.status === "rejected" ? [result2.reason] : []));
+  }
+  if (cleanupFailures.length > 0) {
+    const diagnostic = [
+      "parallel reviewer worktree cleanup failed",
+      ...cleanupFailures.map((failure) => failure instanceof Error ? failure.message : String(failure))
+    ].join("\n");
+    const withCleanupDiagnostic = (result2) => ({
+      ...result2,
+      stderr: [result2.stderr, diagnostic].filter(
+        (text) => typeof text === "string" && text !== ""
+      ).join("\n")
+    });
+    results = {
+      completeness: withCleanupDiagnostic(results.completeness),
+      correctness: withCleanupDiagnostic(results.correctness)
+    };
+  }
+  return results;
+}
 async function summonGateOfficer(options) {
   let home = options.home;
   if (home === void 0) {
@@ -30781,12 +31457,13 @@ async function summonGateOfficer(options) {
     ...common
   });
 }
-var AK_ROLE_PACKAGE_ROOT_ENV;
+var AK_ROLE_PACKAGE_ROOT_ENV, execFileAsync3;
 var init_public_role_summons = __esm({
   "src/public-role-summons.ts"() {
     "use strict";
     init_engine_material();
     AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT";
+    execFileAsync3 = promisify3(execFile3);
   }
 });
 
@@ -31889,189 +32566,6 @@ var init_merger_run = __esm({
   }
 });
 
-// src/public-cli/reviewer-run.ts
-function reviewerMethods(packageRoot2) {
-  return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot2, "ak-cross-m-review") }];
-}
-function buildReviewerTurnRequest(admitted, options) {
-  return projectRoleTurnRequest(
-    admitted,
-    {
-      activation: {
-        role: "reviewer",
-        baseRevision: admitted.baseRevision,
-        lens: admitted.lens,
-        authorityRefs: admitted.authorityRefs,
-        ...admitted.ticketNumber === void 0 ? {} : { ticketNumber: admitted.ticketNumber }
-      },
-      methods: reviewerMethods(options.packageRoot)
-    },
-    options
-  );
-}
-function reviewerAdapters(packageRoot2, methodMaterial) {
-  return {
-    trySettle: (admitted, authority, scope) => methodMaterial === void 0 ? Promise.resolve(void 0) : trySettleReviewerTerminalResult(
-      admitted,
-      authority,
-      {
-        methodProvenance: methodMaterial.provenance,
-        methodSkillPath: methodMaterial.skillPath,
-        methodSkillConfiguredPath: resolvePackagedMethodSkillPath(
-          packageRoot2,
-          "ak-cross-m-review"
-        )
-      },
-      scope
-    ),
-    resolveRunnerKnownFailure: async ({ result: result2, sessionFile }) => {
-      const infrastructureFailure = await readEngineDetourInfrastructureFailure(sessionFile);
-      return infrastructureFailure === void 0 ? result2.knownFailure : {
-        ...infrastructureFailure.cause === void 0 ? {} : { cause: infrastructureFailure.cause },
-        diagnostic: infrastructureFailure.diagnostic,
-        ...infrastructureFailure.identity === void 0 ? {} : { identity: infrastructureFailure.identity }
-      };
-    }
-  };
-}
-async function loadReviewerMethodMaterial(packageRoot2) {
-  return await loadPackagedMethodSkillMaterial(packageRoot2, "ak-cross-m-review");
-}
-function reviewerResumePrompt(env, message) {
-  const lines = [RESUME_TRANSPORT_ENVELOPE];
-  if (message !== void 0) lines.push("", message);
-  return appendEngineSessionMaterial(
-    lines,
-    engineSessionMaterialFromOptions({
-      ...pickEngineAxis(env),
-      packageRoot: env.packageRoot
-    })
-  ).join("\n");
-}
-async function runPublicReviewer(argv, env, io, parseReviewerArgv2) {
-  let admitted;
-  try {
-    const parsed = parseReviewerArgv2(argv);
-    admitted = await admitReviewerInvocation({
-      home: env.home,
-      principalAuthority: env.principalAuthority,
-      cwd: env.cwd,
-      instruction: parsed.instruction,
-      attachmentPaths: parsed.attachmentPaths,
-      baseRevision: parsed.baseRevision,
-      lens: parsed.lens,
-      authorityRefs: parsed.authorityRefs,
-      ...parsed.project === void 0 ? {} : { project: parsed.project },
-      ...env.createRunId === void 0 ? {} : { createRunId: env.createRunId },
-      ...env.model === void 0 ? {} : { model: env.model }
-    });
-  } catch (error) {
-    if (error instanceof CliUsageError) {
-      presentStructuralRejection(error, io);
-      return { exitCode: 2 };
-    }
-    throw error;
-  }
-  await markRunAdmitted(admitted, env.principalAuthority);
-  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
-    );
-  }
-  return await runPostAdmissionResumable({
-    admitted,
-    env,
-    io,
-    buildInitialRequest: () => buildReviewerTurnRequest(admitted, {
-      packageRoot: env.packageRoot,
-      home: env.home,
-      agentDir: env.agentDir,
-      ...env.model === void 0 ? {} : { model: env.model },
-      ...pickEngineAxis(env),
-      ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs },
-      ...admitted.correlationId === void 0 && env.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? env.correlationId },
-      continuation: {
-        kind: "initial",
-        prompt: buildReviewerTransportPrompt(
-          admitted,
-          engineSessionMaterialFromOptions({
-            ...pickEngineAxis(env),
-            packageRoot: env.packageRoot
-          })
-        )
-      }
-    }),
-    buildResumeRequest: () => buildReviewerTurnRequest(admitted, {
-      packageRoot: env.packageRoot,
-      home: env.home,
-      agentDir: env.agentDir,
-      ...env.model === void 0 ? {} : { model: env.model },
-      ...pickEngineAxis(env),
-      ...env.timeoutMs === void 0 ? {} : { timeoutMs: env.timeoutMs },
-      ...admitted.correlationId === void 0 && env.correlationId === void 0 ? {} : { correlationId: admitted.correlationId ?? env.correlationId },
-      continuation: {
-        kind: "resume",
-        prompt: reviewerResumePrompt(env)
-      }
-    }),
-    adapters: reviewerAdapters(env.packageRoot, methodMaterial),
-    ...env.engine === void 0 ? {} : { effectiveEngine: env.engine }
-  });
-}
-async function runPublicReviewerResume(request, env, io) {
-  return await runPostAdmissionSeatResume({
-    request,
-    env,
-    io,
-    load: (effective) => loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
-    buildTurnRequest: (admitted, effective) => {
-      const base = resumeTurnRequestProjectionOptions(admitted, effective, env);
-      return buildReviewerTurnRequest(admitted, {
-        ...base,
-        continuation: {
-          kind: "resume",
-          prompt: reviewerResumePrompt(env, effective.message)
-        }
-      });
-    },
-    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({
-  "src/public-cli/reviewer-run.ts"() {
-    "use strict";
-    init_engine_material();
-    init_method_skill();
-    init_cli_errors();
-    init_invocation();
-    init_run_lifecycle();
-    init_settlement();
-    init_turn_request();
-    init_post_admission();
-  }
-});
-
 // src/analyst-book-key.ts
 import { statSync as statSync2 } from "node:fs";
 import { isAbsolute as isAbsolute9 } from "node:path";
@@ -32108,7 +32602,7 @@ var init_analyst_book_key = __esm({
 
 // src/atomic-write.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { rename as rename3, rm as rm3, writeFile as writeFile10 } from "node:fs/promises";
+import { rename as rename3, rm as rm4, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname16, join as join31 } from "node:path";
 async function writeFileAtomically(destination, contents) {
   const parent = dirname16(destination);
@@ -32117,7 +32611,7 @@ async function writeFileAtomically(destination, contents) {
     await writeFile10(temporary, contents);
     await rename3(temporary, destination);
   } catch (error) {
-    await rm3(temporary, { force: true }).catch(() => void 0);
+    await rm4(temporary, { force: true }).catch(() => void 0);
     throw error;
   }
 }
@@ -32131,8 +32625,8 @@ var init_atomic_write = __esm({
 import { open as open3, readFile as readFile19, unlink as unlink3 } from "node:fs/promises";
 import { dirname as dirname17, join as join32 } from "node:path";
 function sleep(ms) {
-  return new Promise((resolve10) => {
-    setTimeout(resolve10, ms);
+  return new Promise((resolve11) => {
+    setTimeout(resolve11, ms);
   });
 }
 async function withAnalystLibraryIndexLock(ledgerHome, fn) {
@@ -34025,7 +34519,7 @@ var init_analyst_entry = __esm({
 
 // src/public-cli/analyst-run.ts
 import { readFile as readFile22 } from "node:fs/promises";
-import { isAbsolute as isAbsolute10, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve10 } from "node:path";
 function resolveAnalystIssueBookKeyFromCwd(cwd = process.cwd()) {
   try {
     return resolveBookKeyFromGit(cwd);
@@ -34074,7 +34568,7 @@ async function buildAnalystSweepModeInputFromAttachmentPaths(attachmentPaths) {
     );
   }
   const sourcePath = attachmentPaths[0];
-  const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve9(sourcePath);
+  const absolute = isAbsolute10(sourcePath) ? sourcePath : resolve10(sourcePath);
   let bytes;
   try {
     bytes = await readFile22(absolute);
@@ -34196,7 +34690,7 @@ __export(cli_exports, {
   resolveInternalRoleEntrypoint: () => resolveInternalRoleEntrypoint,
   runAkRole: () => runAkRole
 });
-import { realpath as realpath6 } from "node:fs/promises";
+import { realpath as realpath7 } from "node:fs/promises";
 import { join as join35 } from "node:path";
 function takePublicGlobalFlag(argv, index, options) {
   const tokens = argv.slice(index);
@@ -34850,7 +35344,7 @@ async function runAkRole(argv, env) {
   try {
     env = {
       ...env,
-      packageRoot: await realpath6(env.packageRoot),
+      packageRoot: await realpath7(env.packageRoot),
       principalAuthority: env.principalAuthority ?? piDurablePrincipalAuthority
     };
     let parsed = parseArgv(argv);