@akagilnc/pi-workflow-roles 0.1.4526 → 0.1.4586

package/src/public-cli/post-admission.ts

@@ -236,6 +236,12 @@ export type PostAdmissionEnv = {
   freshSummons?: true;
   /** Station child role run (#840): omit automatic navigator attendance. */
   stationChild?: boolean;
+  /**
+   * Ephemeral host-turn cwd for Reviewer fresh-copy execution (#946 统一新副本).
+   * Admission and durable projectRoot stay on the caller project; the host turn
+   * (initial and resume) runs in this sandbox when present.
+   */
+  executionCwd?: string;
 };
 
 /**
@@ -1352,6 +1358,16 @@ export async function runPostAdmissionSeatResume<
   afterAdmittedLoad?: (
     admitted: A,
   ) => Promise<AfterAdmittedLoadResult<A, T>>;
+  /**
+   * After the single pre-lease load (and optional afterAdmittedLoad), prepare
+   * call-local execution context. Reviewer fresh-copy (#946) mints an ephemeral
+   * worktree from the admitted projectRoot here — reuses this load, does not
+   * pre-load outside the coordinator. cleanup runs after dispatch settles.
+   */
+  afterAdmittedPrepare?: (admitted: A) => Promise<{
+    readonly env?: PostAdmissionEnv;
+    readonly cleanup?: () => Promise<void>;
+  }>;
   effectiveEngine?: string;
 }): Promise<{ exitCode: number; admitted?: A; terminal?: T }> {
   let request = input.request;
@@ -1382,6 +1398,10 @@ export async function runPostAdmissionSeatResume<
     adapters = prepared.adapters;
   }
 
+  // Call-local execution env; afterAdmittedPrepare may replace it (Reviewer fresh-copy).
+  let env = input.env;
+  let preparedCleanup: (() => Promise<void>) | undefined;
+
   const buildRequestAfterLease = async (): Promise<RoleTurnRequest> => {
         let openCourtAttemptId: string | undefined;
         // Build uses the admitted judged under this lease (rehydrated when open
@@ -1464,8 +1484,14 @@ export async function runPostAdmissionSeatResume<
   // Court recovery / open under lease, then dispatch.
   // Station-child same-ticket/same-parent resume is call-local auto-resume
   // (#840 / #416). Public `ak-role resume` stays one-shot (ADR 0080).
+  // afterAdmittedPrepare runs inside this try so mint failure and cleanup share one finally.
   try {
-    if (input.env.stationChild === true) {
+    if (input.afterAdmittedPrepare !== undefined) {
+      const prepared = await input.afterAdmittedPrepare(loaded.admitted);
+      if (prepared.env !== undefined) env = prepared.env;
+      preparedCleanup = prepared.cleanup;
+    }
+    if (env.stationChild === true) {
       let firstTurn: RoleTurnRequest | undefined;
       const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
       type StationChildAttempt = { readonly resumeTurn: boolean };
@@ -1477,14 +1503,14 @@ export async function runPostAdmissionSeatResume<
       });
       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: (): StationChildAttempt => ({ resumeTurn: false }),
         buildResumePayload: (): StationChildAttempt => ({ resumeTurn: true }),
         // Same as public manual resume: prior-court sealed acceptance is not a
@@ -1522,7 +1548,7 @@ export async function runPostAdmissionSeatResume<
             dispatch: async (turnRequest) => {
               const result = await dispatchPostAdmissionTurn({
                 admitted: loaded.admitted,
-                env: input.env,
+                env,
                 io: attemptIo,
                 request: turnRequest,
                 lease,
@@ -1534,7 +1560,7 @@ export async function runPostAdmissionSeatResume<
               });
               return settleDeferredPersist(
                 loaded.admitted,
-                input.env.principalAuthority,
+                env.principalAuthority,
                 stationAdapters,
                 attemptIo,
                 result,
@@ -1545,7 +1571,7 @@ export async function runPostAdmissionSeatResume<
     }
     return await runPostAdmissionManualResume({
       admitted: loaded.admitted,
-      env: input.env,
+      env,
       io: input.io,
       adapters,
       ...(input.effectiveEngine === undefined
@@ -1561,6 +1587,10 @@ export async function runPostAdmissionSeatResume<
       return { exitCode: 2 };
     }
     throw error;
+  } finally {
+    if (preparedCleanup !== undefined) {
+      await preparedCleanup();
+    }
   }
 }
 

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

@@ -4,6 +4,8 @@
  * extra packets. Controlled-failure settlement reuses #107.
  * #526: execution via RoleTurnHost; argv is Pi adapter internal.
  */
+import { resolve } from "node:path";
+
 import type {
   DurablePrincipalAuthority,
   MethodBinding,
@@ -40,7 +42,11 @@ import {
   trySettleReviewerTerminalResult,
 } from "./settlement.ts";
 import type { CliIo } from "./cli-io.ts";
-import type { TerminalResult } from "./terminal.ts";
+import {
+  formatTerminalResult,
+  isLawfulTypedTerminalOutcome,
+  type TerminalResult,
+} from "./terminal.ts";
 import {
   projectRoleTurnRequest,
   type RoleTurnRequestProjectionOptions,
@@ -59,10 +65,42 @@ export type ReviewerRunEnv = PostAdmissionEnv & {
   createRunId?: () => string;
 };
 
+type ReviewerRunResult = {
+  exitCode: number;
+  admitted?: AdmittedReviewerInvocation;
+  terminal?: TerminalResult;
+};
+
 function reviewerMethods(packageRoot: string): readonly MethodBinding[] {
   return [{ kind: "skill", path: resolvePackagedMethodSkillPath(packageRoot, "ak-cross-m-review") }];
 }
 
+/**
+ * All Reviewer turns (explicit --lens, dual-lens child, resume) execute in a
+ * fresh worktree of the source tree's current HEAD (#946 统一新副本). Dual-lens
+ * summon already injects executionCwd; only mint when absent. Cleanup failure
+ * is diagnostic only and does not flip the exit code. Mint failure propagates
+ * so the caller can settle a controlled failure against the admitted run.
+ */
+async function runReviewerTurnInFreshCopy(
+  env: ReviewerRunEnv,
+  projectRoot: string,
+  io: CliIo,
+  body: (sandboxedEnv: ReviewerRunEnv) => Promise<ReviewerRunResult>,
+): Promise<ReviewerRunResult> {
+  if (env.executionCwd !== undefined) {
+    return body(env);
+  }
+  const { withEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+  return await withEphemeralReviewerWorktree({
+    projectRoot,
+    onCleanupDiagnostic: (diagnostic) => {
+      io.stderr(`${diagnostic}\n`);
+    },
+    run: (executionCwd) => body({ ...env, executionCwd }),
+  });
+}
+
 /** Project admitted Reviewer invocation onto the host-neutral turn request. */
 export function buildReviewerTurnRequest(
   admitted: AdmittedReviewerInvocation,
@@ -149,7 +187,7 @@ export async function runPublicReviewer(
     instruction: string;
     attachmentPaths: string[];
     baseRevision: string;
-    lens: ReviewerLens;
+    lens?: ReviewerLens;
     authorityRefs: string[];
     project?: string;
   },
@@ -158,9 +196,100 @@ export async function runPublicReviewer(
   admitted?: AdmittedReviewerInvocation;
   terminal?: TerminalResult;
 }> {
+  let parsed: ReturnType<typeof parseReviewerArgv>;
+  try {
+    parsed = parseReviewerArgv(argv);
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    throw error;
+  }
+
+  // Omitted public lens is the parallel two-axis branch mark; never admitted as a parent run.
+  // Each leg reuses this call's public argv and only adds --lens (#946 / 10a).
+  if (parsed.lens === undefined) {
+    const { summonParallelReviewerLenses } = await import("../public-role-summons.ts");
+    const children = await summonParallelReviewerLenses({
+      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: resolve(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 === undefined ? {} : { credentials: env.credentials }),
+      ...(env.model === undefined ? {} : { model: env.model }),
+      ...(env.host === undefined ? {} : { host: env.host }),
+      ...(env.engine === undefined ? {} : { engine: env.engine }),
+      ...(env.engineModel === undefined ? {} : { engineModel: env.engineModel }),
+      packageRoot: env.packageRoot,
+      ...(env.signal === undefined ? {} : { signal: env.signal }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
+      roleTurnHost: env.roleTurnHost,
+      ...(env.hostAdapters === undefined ? {} : { hostAdapters: env.hostAdapters }),
+      principalAuthority: env.principalAuthority,
+      ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
+    });
+    const childResults = [children.completeness, children.correctness] as const;
+    const terminals = childResults
+      .map((child) => child.terminal)
+      .filter((terminal): terminal is TerminalResult => terminal !== undefined);
+    // ADR 0052 / terminal.ts: lawful typed child terminals (accepted / no_receipt /
+    // audit_escalation) are not batch failures. Child exitCode remains the live
+    // surface for seal/infrastructure overlays that keep the original Terminal.
+    // failedChildren counts only non-lawful/missing child Terminals; seal overlays
+    // that flip exitCode while keeping lawful Terminals are a separate identity.
+    const failedChildren = childResults.filter((child) =>
+      child.terminal === undefined
+      || !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): text is string => typeof text === "string" && text !== ""),
+    )];
+    const terminal: TerminalResult = {
+      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 === undefined ? {} : { completeness: children.completeness.terminal }),
+        ...(children.correctness.terminal === undefined ? {} : { correctness: children.correctness.terminal }),
+      },
+      reviewerChildOutcomes: {
+        completeness: { exitCode: children.completeness.exitCode, ...(children.completeness.stderr === undefined ? {} : { stderr: children.completeness.stderr }) },
+        correctness: { exitCode: children.correctness.exitCode, ...(children.correctness.stderr === undefined ? {} : { 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: AdmittedReviewerInvocation;
   try {
-    const parsed = parseReviewerArgv(argv);
     admitted = await admitReviewerInvocation({
       home: env.home,
       principalAuthority: env.principalAuthority,
@@ -172,6 +301,7 @@ export async function runPublicReviewer(
       authorityRefs: parsed.authorityRefs,
       ...(parsed.project === undefined ? {} : { project: parsed.project }),
       ...(env.createRunId === undefined ? {} : { createRunId: env.createRunId }),
+      ...(env.correlationId === undefined ? {} : { correlationId: env.correlationId }),
       ...(env.model === undefined ? {} : { model: env.model }),
     });
   } catch (error) {
@@ -202,56 +332,82 @@ export async function runPublicReviewer(
     )) as { exitCode: number; admitted: AdmittedReviewerInvocation; terminal: TerminalResult };
   }
 
-  return await runPostAdmissionResumable({
-    admitted,
-    env,
-    io,
-    buildInitialRequest: () =>
-      buildReviewerTurnRequest(admitted, {
-        packageRoot: env.packageRoot,
-        home: env.home,
-        agentDir: env.agentDir,
-        ...(env.model === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { 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 === undefined ? {} : { model: env.model }),
-        ...pickEngineAxis(env),
-        ...(env.timeoutMs === undefined ? {} : { timeoutMs: env.timeoutMs }),
-        ...(admitted.correlationId === undefined && env.correlationId === undefined
-          ? {}
-          : { correlationId: admitted.correlationId ?? env.correlationId }),
-        continuation: {
-          kind: "resume",
-          prompt: reviewerResumePrompt(env),
-        },
-      }),
-    adapters: reviewerAdapters(env.packageRoot, methodMaterial),
-    ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
-  });
+  // Fresh copy for this call (explicit --lens or dual-lens child with pre-set cwd).
+  // Durable projectRoot stays the caller project; only the host turn uses the sandbox.
+  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 === undefined ? {} : { model: sandboxedEnv.model }),
+            ...pickEngineAxis(sandboxedEnv),
+            ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
+            ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
+              ? {}
+              : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
+            // Ephemeral worktree cwd; durable projectRoot stays on admitted caller project.
+            ...(sandboxedEnv.executionCwd === undefined ? {} : { 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 === undefined ? {} : { model: sandboxedEnv.model }),
+            ...pickEngineAxis(sandboxedEnv),
+            ...(sandboxedEnv.timeoutMs === undefined ? {} : { timeoutMs: sandboxedEnv.timeoutMs }),
+            ...(admitted.correlationId === undefined && sandboxedEnv.correlationId === undefined
+              ? {}
+              : { correlationId: admitted.correlationId ?? sandboxedEnv.correlationId }),
+            // In-batch auto-resume keeps the same call's sandbox (dual-lens or single).
+            ...(sandboxedEnv.executionCwd === undefined ? {} : { cwd: sandboxedEnv.executionCwd }),
+            continuation: {
+              kind: "resume",
+              prompt: reviewerResumePrompt(sandboxedEnv),
+            },
+          }),
+        adapters: reviewerAdapters(sandboxedEnv.packageRoot, methodMaterial),
+        ...(sandboxedEnv.engine === undefined ? {} : { effectiveEngine: sandboxedEnv.engine }),
+      }));
+  } catch (error) {
+    return (await presentControlledFailure(
+      admitted,
+      {
+        timedOut: false,
+        code: null,
+        stderr: "",
+        thrown: error,
+      },
+      reviewerAdapters(env.packageRoot, methodMaterial),
+      env.principalAuthority,
+      io,
+    )) as ReviewerRunResult;
+  }
 }
 
 /**
  * Resume a previously admitted Reviewer Role run after a typed HTTP 429.
  * Restores task/base/session identity; model override is temporary.
+ * Execution always uses a fresh worktree of the source tree at resume time
+ * (#946 统一新副本 / 10a) — no old worktree, no ownership record.
+ * Fresh-copy mint reuses the coordinator's single pre-lease load via
+ * afterAdmittedPrepare; does not pre-load outside the coordinator.
  */
 export async function runPublicReviewerResume(
   request: PublicResumeRequest,
@@ -262,6 +418,11 @@ export async function runPublicReviewerResume(
   admitted?: AdmittedReviewerInvocation;
   terminal?: TerminalResult;
 }> {
+  // Call-local cell: afterAdmittedPrepare writes executionCwd; buildTurnRequest reads it.
+  // Keeps the single-load coordinator contract — no preliminary load outside.
+  const sandbox: { executionCwd?: string } = {
+    ...(env.executionCwd === undefined ? {} : { executionCwd: env.executionCwd }),
+  };
   return await runPostAdmissionSeatResume({
     request,
     env,
@@ -269,25 +430,49 @@ export async function runPublicReviewerResume(
     load: (effective) =>
       loadResumableReviewerRun(env.home, effective.runId, env.principalAuthority),
     buildTurnRequest: (admitted, effective) => {
-      const base = resumeTurnRequestProjectionOptions(admitted, effective, env);
+      const activeEnv: ReviewerRunEnv = sandbox.executionCwd === undefined
+        ? 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 === undefined ? {} : { cwd: sandbox.executionCwd }),
         continuation: {
           kind: "resume",
-          prompt: reviewerResumePrompt(env, effective.message),
+          prompt: reviewerResumePrompt(activeEnv, effective.message),
         },
       });
     },
     adapters: reviewerAdapters(env.packageRoot),
-    afterAdmittedLoad: (admitted) =>
-      resolveResumeMethodMaterialAdapters({
+    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) => {
+      // Already sandboxed (in-batch auto-resume path) — nothing to mint.
+      if (sandbox.executionCwd !== undefined) {
+        return { env: { ...env, executionCwd: sandbox.executionCwd } };
+      }
+      const { openEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
+      const opened = await openEphemeralReviewerWorktree({
+        projectRoot: admitted.projectRoot,
+        onCleanupDiagnostic: (diagnostic) => {
+          io.stderr(`${diagnostic}\n`);
+        },
+      });
+      sandbox.executionCwd = opened.executionCwd;
+      return {
+        env: { ...env, executionCwd: opened.executionCwd },
+        cleanup: opened.close,
+      };
+    },
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

package/src/public-cli/settlement.ts

@@ -3634,7 +3634,6 @@ export async function trySettleReviewerTerminalResult(
   return settleLawfulReviewerTerminalResult(admitted, authority, options, scope);
 }
 
-
 /**
  * Observe forced Merger resolving-merge-conflicts Skill expansions from the session.
  * Expansion evidence is package-path only; ambient home locations never count.

package/src/public-cli/terminal.ts

@@ -182,6 +182,16 @@ export function roleResultPayloads(outcome: TerminalRoleOutcome): readonly unkno
 
 export type TerminalResult = {
   roleOutcome: TerminalRoleOutcome;
+  /** Default Reviewer parent: original child Terminals, keyed by frozen axis. */
+  reviewerChildren?: Readonly<{
+    completeness?: TerminalResult;
+    correctness?: TerminalResult;
+  }>;
+  /** Per-axis summons facts retained even when no child Terminal exists. */
+  reviewerChildOutcomes?: Readonly<{
+    completeness: { exitCode: number; stderr?: string };
+    correctness: { exitCode: number; stderr?: string };
+  }>;
   navigator: TerminalNavigatorFact;
   artifacts: readonly TerminalArtifactRef[];
   /**
@@ -201,10 +211,18 @@ export type TerminalResult = {
       /** Resumable failure: run ID appears only inside resume.command. */
       resume: TerminalResume;
       runId?: undefined;
+      batch?: undefined;
     }
   | {
       runId: string;
       resume?: undefined;
+      batch?: undefined;
+    }
+  | {
+      /** Deterministic public batch projection; no parent Role run exists. */
+      batch: "reviewer";
+      runId?: undefined;
+      resume?: undefined;
     }
 );
 
@@ -303,6 +321,15 @@ export function formatTerminalResult(result: TerminalResult): string {
       );
     }
   }
+  if (result.reviewerChildOutcomes !== undefined) {
+    for (const axis of ["completeness", "correctness"] as const) {
+      const child = result.reviewerChildOutcomes[axis];
+      lines.push(`reviewer-child\t${axis}\t${child.exitCode}`);
+      if (child.stderr !== undefined && child.stderr !== "") {
+        lines.push(`reviewer-child-diagnostic\t${axis}\t${encodeTerminalField(child.stderr)}`);
+      }
+    }
+  }
   if (result.resume !== undefined) {
     // Resumable failure: run ID is revealed only inside the complete resume command.
     lines.push(`resume\t${encodeTerminalField(result.resume.command)}`);

package/src/public-cli/turn-request.ts

@@ -38,6 +38,12 @@ export type RoleTurnRequestProjectionOptions = {
   invocationScopeId?: string;
   /** Station child role run (#840): omit automatic navigator attendance. */
   stationChild?: boolean;
+  /**
+   * Optional host-turn cwd override. Durable admitted projectRoot stays the
+   * identity source; Reviewer fresh-copy sandboxes (explicit --lens, dual-lens
+   * legs, resume) inject the ephemeral worktree here (#946 统一新副本).
+   */
+  cwd?: string;
 };
 
 export type AdmittedTurnInvocation = {
@@ -58,7 +64,7 @@ export function projectRoleTurnRequest(
   },
   options: RoleTurnRequestProjectionOptions,
 ): RoleTurnRequest {
-  const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
+  const cwd = options.cwd ?? admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
   if (cwd === undefined) throw new Error("admitted invocation missing working directory");
   if (admitted.principal === undefined) throw new Error("admitted invocation missing principal");
   // #617 DK-3: turn model is the live seat/env model only — never the admitted