@akagilnc/pi-workflow-roles 0.1.4889 → 0.1.4911

package/dist/public-cli/post-admission.js

@@ -876,7 +876,7 @@ export function resumeTurnRequestProjectionOptions(admitted, request, env, summo
     };
 }
 /** Shared new-turn and in-call auto-resume projection. Seat code supplies prompt and activation. */
-export function roleTurnOptions(env, admitted, continuation, extra) {
+export function roleTurnOptions(env, admitted, continuation) {
     const correlationId = admitted.correlationId ?? env.correlationId;
     return {
         packageRoot: env.packageRoot,
@@ -889,7 +889,6 @@ export function roleTurnOptions(env, admitted, continuation, extra) {
             ? {}
             : { correlationId }),
         continuation,
-        ...(extra?.cwd === undefined ? {} : { cwd: extra.cwd }),
         ...(env.stationChild === undefined ? {} : { stationChild: env.stationChild }),
     };
 }
@@ -982,9 +981,7 @@ export async function runPostAdmissionSeatResume(input) {
         }
         adapters = prepared.adapters;
     }
-    // Call-local execution env; afterAdmittedPrepare may replace it (Reviewer fresh-copy).
-    let env = input.env;
-    let preparedCleanup;
+    const env = input.env;
     const buildRequestAfterLease = async () => {
         let openCourtAttemptId;
         // Settlement identity stays on the outer admitted.
@@ -1049,14 +1046,7 @@ export async function runPostAdmissionSeatResume(input) {
     // auto-resume both pass through to the host CLI without a package writer-lease
     // pre-gate (#987 / ADR 0080). Station-child same-ticket/same-parent resume is
     // still call-local auto-resume (#840 / #416).
-    // afterAdmittedPrepare runs inside this try so mint failure and cleanup share one finally.
     try {
-        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;
             const stationAdapters = withOnceSuccessfulBeforeDispatch(adapters);
@@ -1133,18 +1123,13 @@ export async function runPostAdmissionSeatResume(input) {
         });
     }
     catch (error) {
-        // Seat preparation may still surface structural rejection.
+        // Turn construction may still surface structural rejection.
         if (error instanceof CliUsageError) {
             presentStructuralRejection(error, input.io);
             return { exitCode: 2 };
         }
         throw error;
     }
-    finally {
-        if (preparedCleanup !== undefined) {
-            await preparedCleanup();
-        }
-    }
 }
 /**
  * Shared post-admission one-shot path: folds into runPostAdmissionResumable (#840 / #416).

package/dist/public-cli/turn-request.js

@@ -3,7 +3,7 @@ import { resolvePackagedMethodSkillPath, } from "../package-resources/method-ski
 import { packagedRoleActivationFlags, packagedRoleMetadata, } from "../packaged-role-registry.js";
 import { parentRunPathFromGatePointerInstruction } from "./run-lifecycle.js";
 export function projectRoleTurnRequest(admitted, roleDetails, options) {
-    const cwd = options.cwd ?? admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
+    const cwd = admitted.projectRoot ?? admitted.repoRoot ?? admitted.cwd;
     if (cwd === undefined)
         throw new Error("admitted invocation missing working directory");
     if (admitted.principal === undefined)

package/dist/public-role-summons.js

@@ -1,8 +1,7 @@
 import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, mkdtemp, realpath, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, relative, sep } from "node:path";
+import { realpath } from "node:fs/promises";
+import { join } from "node:path";
 import { promisify } from "node:util";
 import { pickEngineAxis } from "./package-resources/engine-material.js";
 const AK_ROLE_PACKAGE_ROOT_ENV = "AK_ROLE_PACKAGE_ROOT";
@@ -207,8 +206,7 @@ async function summonPublicRole(options) {
           ...options.boundTicketNumber === void 0 ? {} : { boundTicketNumber: options.boundTicketNumber },
           ...options.parentRunPath === void 0 || options.parentRunPath.trim() === "" ? {} : { parentRunPath: options.parentRunPath },
           ...options.correlationId === void 0 || options.correlationId.trim() === "" ? {} : { correlationId: options.correlationId },
-          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId },
-          ...options.executionCwd === void 0 ? {} : { executionCwd: options.executionCwd }
+          ...options.createRunId === void 0 ? {} : { createRunId: options.createRunId }
         }
       };
     } catch (error) {
@@ -288,106 +286,13 @@ function withReviewerLens(argv, lens) {
   if (separator === -1) return [...argv, "--lens", lens];
   return [...argv.slice(0, separator), "--lens", lens, ...argv.slice(separator)];
 }
-async function resolveReviewerWorktreeRoots(projectRoot) {
+async function resolveReviewerGitToplevel(projectRoot) {
   const callerProjectRoot = await realpath(projectRoot);
-  const sourceProjectRoot = await realpath((await execFileAsync(
+  return await realpath((await execFileAsync(
     "git",
     ["rev-parse", "--show-toplevel"],
     { cwd: callerProjectRoot }
   )).stdout.trim());
-  const callerRelative = relative(sourceProjectRoot, callerProjectRoot);
-  const projectRelative = callerRelative === "" || callerRelative === "." || callerRelative.startsWith(`..${sep}`) || callerRelative === ".." ? "" : callerRelative;
-  return { callerProjectRoot, sourceProjectRoot, projectRelative };
-}
-function reviewerSandboxPath(worktreeAxis, projectRelative) {
-  return projectRelative === "" ? worktreeAxis : join(worktreeAxis, projectRelative);
-}
-async function openEphemeralReviewerWorktree(options) {
-  const { sourceProjectRoot, projectRelative } = await resolveReviewerWorktreeRoots(
-    options.projectRoot
-  );
-  const { stdout: headStdout } = await execFileAsync(
-    "git",
-    ["rev-parse", "--verify", "HEAD^{commit}"],
-    { cwd: sourceProjectRoot }
-  );
-  const targetCommit = headStdout.trim();
-  const root = await mkdtemp(join(tmpdir(), "ak-reviewer-sandbox-"));
-  const worktreeRoot = join(root, "work");
-  let registered = false;
-  const rollback = async (cause) => {
-    const cleanupErrors = [];
-    if (registered) {
-      try {
-        await execFileAsync("git", ["worktree", "remove", "--force", worktreeRoot], {
-          cwd: sourceProjectRoot
-        });
-      } catch (error) {
-        cleanupErrors.push(error);
-      }
-    }
-    try {
-      await rm(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 execFileAsync("git", ["worktree", "add", "--detach", worktreeRoot, targetCommit], {
-      cwd: sourceProjectRoot
-    });
-    registered = true;
-    if (projectRelative !== "") {
-      await mkdir(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 execFileAsync("git", ["worktree", "remove", worktreeRoot], {
-          cwd: sourceProjectRoot
-        });
-      } catch (error) {
-        cleanupErrors.push(error);
-      }
-      try {
-        await rm(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) => {
@@ -405,7 +310,6 @@ async function summonParallelReviewerLenses(options) {
     return { completeness: failure, correctness: failure };
   };
   let sourceProjectRoot;
-  let projectRelative;
   let targetCommit;
   const statusArgs = [
     "status",
@@ -416,9 +320,7 @@ async function summonParallelReviewerLenses(options) {
     ":(top,exclude).claude/worktrees/**"
   ];
   try {
-    const roots = await resolveReviewerWorktreeRoots(options.projectRoot);
-    sourceProjectRoot = roots.sourceProjectRoot;
-    projectRelative = roots.projectRelative;
+    sourceProjectRoot = await resolveReviewerGitToplevel(options.projectRoot);
     const { stdout: statusStdout } = await execFileAsync("git", statusArgs, {
       cwd: sourceProjectRoot
     });
@@ -444,65 +346,37 @@ async function summonParallelReviewerLenses(options) {
   } catch (error) {
     return dualFailure(error);
   }
-  const root = await mkdtemp(join(tmpdir(), "ak-reviewer-lenses-"));
-  const completenessRoot = join(root, "completeness");
-  const correctnessRoot = join(root, "correctness");
-  const worktrees = [completenessRoot, correctnessRoot];
-  const created = /* @__PURE__ */ new Set();
-  let results;
-  const creation = await Promise.allSettled(
-    worktrees.map(async (path) => {
-      await execFileAsync("git", ["worktree", "add", "--detach", path, targetCommit], {
-        cwd: sourceProjectRoot
-      });
-      created.add(path);
-      if (projectRelative !== "") {
-        await mkdir(reviewerSandboxPath(path, projectRelative), { recursive: true });
-      }
-    })
-  );
-  const creationFailures = creation.flatMap((result) => result.status === "rejected" ? [result.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)
-    };
-  }
+  const summon = (lens) => {
+    return summonPublicRole({
+      role: "reviewer",
+      argv: withReviewerLens(options.argv, lens),
+      cwd: options.cwd,
+      // 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"),
+    summon("correctness")
+  ]);
+  let 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 execFileAsync(
@@ -547,30 +421,6 @@ ${describeFailure(error)}`;
       correctness: withSealFailure(results.correctness)
     };
   }
-  const cleanup = await Promise.allSettled(
-    [...created].map((path) => execFileAsync("git", ["worktree", "remove", path], { cwd: sourceProjectRoot }))
-  );
-  const cleanupFailures = cleanup.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-  if (cleanupFailures.length === 0) {
-    const rootCleanup = await Promise.allSettled([rm(root, { recursive: true, force: true })]);
-    cleanupFailures.push(...rootCleanup.flatMap((result) => result.status === "rejected" ? [result.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 = (result) => ({
-      ...result,
-      stderr: [result.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) {
@@ -646,10 +496,8 @@ async function summonGateOfficer(options) {
 }
 export {
   AK_ROLE_PACKAGE_ROOT_ENV,
-  openEphemeralReviewerWorktree,
   resolveSummonsPackageRoot,
   summonGateOfficer,
   summonParallelReviewerLenses,
-  summonPublicRole,
-  withEphemeralReviewerWorktree
+  summonPublicRole
 };

package/dist/role-run-relocation.js

@@ -155,8 +155,11 @@ async function rewriteOfficerPointerFile(path, rewrites) {
     // Only the typed direct-officer pointer shape — never arbitrary .pointer.json.
     if (page.kind !== "direct-officer-run-pointer")
         return;
+    const before = JSON.stringify(page);
     rewriteRunDirectoryPathFieldsAgainstRewrites(page, OFFICER_POINTER_FIELDS, rewrites);
-    await writeFile(path, `${JSON.stringify(page)}\n`, "utf8");
+    if (JSON.stringify(page) !== before) {
+        await writeFile(path, `${JSON.stringify(page)}\n`, "utf8");
+    }
 }
 async function rewriteSitianRecordsJsonl(path, rewrites) {
     if (!existsSync(path))
@@ -320,18 +323,25 @@ export async function rewriteRoleRunDurablePages(input) {
     const admittedPath = join(pagesDirectory, "admitted-request.json");
     if (existsSync(admittedPath)) {
         const page = JSON.parse(await readFile(admittedPath, "utf8"));
+        const before = JSON.stringify(page);
         rewriteAdmittedRoleRunPage(page, rewrites);
-        await writeFile(admittedPath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        if (JSON.stringify(page) !== before) {
+            await writeFile(admittedPath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        }
     }
     const invocationPath = join(pagesDirectory, "invocation.json");
     if (existsSync(invocationPath)) {
         const page = JSON.parse(await readFile(invocationPath, "utf8"));
+        const before = JSON.stringify(page);
         rewriteRunDirectoryPathFieldsAgainstRewrites(page, INVOCATION_PAGE_FIELDS, rewrites);
-        await writeFile(invocationPath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        if (JSON.stringify(page) !== before) {
+            await writeFile(invocationPath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        }
     }
     const statePath = join(pagesDirectory, "run-state.json");
     if (existsSync(statePath)) {
         const page = JSON.parse(await readFile(statePath, "utf8"));
+        const before = JSON.stringify(page);
         rewriteRunDirectoryPathFieldsAgainstRewrites(page, RUN_STATE_PAGE_FIELDS, rewrites);
         if (isPlainObject(page.principal)) {
             rewriteRunDirectoryPathFieldsAgainstRewrites(page.principal, ["sessionDirectory", "sessionFile"], rewrites);
@@ -340,7 +350,9 @@ export async function rewriteRoleRunDurablePages(input) {
         if (isPlainObject(page.currentCourt)) {
             rewriteSummonsMaterials(page.currentCourt.summons, rewrites);
         }
-        await writeFile(statePath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        if (JSON.stringify(page) !== before) {
+            await writeFile(statePath, `${JSON.stringify(page, null, 2)}\n`, "utf8");
+        }
     }
     await rewriteNestedMachinePathPages(pagesDirectory, rewrites);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.4889",
+  "version": "0.1.4911",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/book-topology-runs-migrator.ts

@@ -17,7 +17,6 @@ import {
   resolveMigratingRunTicket,
 } from "./book-topology-migration-placement.ts";
 import {
-  assertBookTopologyMigrationPrerequisites,
   reconcileMigrationPartition,
   type BookTopologyMigrationContext,
   type BookTopologyPartitionMigrator,
@@ -378,13 +377,11 @@ export async function relocateBoardBoundUnboundRunsInBook(
 
 /**
  * Walk every book under `booksDirectory` and relocate board-bound unbound
- * runs in place. Requires zero live writer locks (same gate as topology migrate).
+ * runs in place without the whole-books topology migration's in-flight gate.
  */
 export async function relocateBoardBoundUnboundRunsInBooks(
   booksDirectory: string,
-  env: NodeJS.ProcessEnv = process.env,
 ): Promise<readonly BoardBoundUnboundRelocation[]> {
-  await assertBookTopologyMigrationPrerequisites(booksDirectory, env);
   const relocated: BoardBoundUnboundRelocation[] = [];
   for (const bookKey of await listMigrationBookKeys(booksDirectory)) {
     const batch = await relocateBoardBoundUnboundRunsInBook(

package/src/packaged-role-registry.ts

@@ -192,8 +192,6 @@ export const PUBLIC_ROLE_RECORDS = [
     settleMethod: "ak-cross-m-review",
     /** Omitted public lens starts two ordinary single-axis runs (ADR 0052). */
     parallelLenses: true,
-    /** Every turn runs in a fresh worktree; durable projectRoot stays the caller project (#946). */
-    freshExecutionCopy: true,
     phases: [null],
     bareCommand: false,
     outputTool: REVIEWER_OUTPUT_TOOL_NAME,

package/src/public-cli/instruction-seat-run.ts

@@ -132,15 +132,6 @@ function initialPrompt(
   );
 }
 
-function hostTurnCwd(env: InstructionSeatRunEnv): { readonly cwd: string } | undefined {
-  return env.executionCwd === undefined ? undefined : { cwd: env.executionCwd };
-}
-
-function wantsFreshExecutionCopy(role: PackagedRole): boolean {
-  const record = roleRecord(role);
-  return "freshExecutionCopy" in record && record.freshExecutionCopy === true;
-}
-
 function infraFailure(role: PackagedRole) {
   const resolveRunnerKnownFailure = seatKnownFailureResolver(role);
   return resolveRunnerKnownFailure === undefined ? {} : { resolveRunnerKnownFailure };
@@ -260,7 +251,6 @@ async function dispatchAdmitted(
   const adapters = seatAdapters(admitted, env, material);
   const execute = async (activeEnv: InstructionSeatRunEnv): Promise<SeatRunResult> => {
     const auto = "inCallAutoResume" in record && record.inCallAutoResume === true;
-    const cwd = hostTurnCwd(activeEnv);
     if (auto) {
       return await runPostAdmissionResumable({
         admitted,
@@ -268,7 +258,7 @@ async function dispatchAdmitted(
         io,
         buildInitialRequest: () => buildInstructionSeatTurnRequest(
           admitted,
-          roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }, cwd),
+          roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
         ),
         buildResumeRequest: () => buildInstructionSeatTurnRequest(
           admitted,
@@ -278,7 +268,7 @@ async function dispatchAdmitted(
               packageRoot: activeEnv.packageRoot,
               ...pickEngineAxis(activeEnv),
             }),
-          }, cwd),
+          }),
         ),
         adapters,
         ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
@@ -290,31 +280,13 @@ async function dispatchAdmitted(
       io,
       request: buildInstructionSeatTurnRequest(
         admitted,
-        roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }, cwd),
+        roleTurnOptions(activeEnv, admitted, { kind: "initial", prompt: initialPrompt(admitted, activeEnv) }),
       ),
       adapters,
       ...(activeEnv.engine === undefined ? {} : { effectiveEngine: activeEnv.engine }),
     });
   };
-  if (!wantsFreshExecutionCopy(admitted.role)) return execute(env);
-  try {
-    if (env.executionCwd !== undefined) return await execute(env);
-    const { withEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
-    return await withEphemeralReviewerWorktree({
-      projectRoot: admitted.projectRoot,
-      onCleanupDiagnostic: (diagnostic) => {
-        io.stderr(`${diagnostic}\n`);
-      },
-      run: (executionCwd) => execute({ ...env, executionCwd }),
-    });
-  } catch (error) {
-    return await presentControlledFailure(admitted, {
-      timedOut: false,
-      code: null,
-      stderr: "",
-      thrown: error,
-    }, adapters, env.principalAuthority, io) as SeatRunResult;
-  }
+  return execute(env);
 }
 
 /**
@@ -809,9 +781,6 @@ export async function runPublicInstructionSeatResume(
   env: InstructionSeatRunEnv,
   io: CliIo,
 ): Promise<SeatRunResult> {
-  const execution: { cwd?: string } = {
-    ...(env.executionCwd === undefined ? {} : { cwd: env.executionCwd }),
-  };
   return runPostAdmissionSeatResume<AdmittedRoleInvocation>({
     request,
     env,
@@ -835,13 +804,11 @@ export async function runPublicInstructionSeatResume(
       return loaded;
     },
     buildTurnRequest: async (admitted, effective) => {
-      const activeEnv = execution.cwd === undefined ? env : { ...env, executionCwd: execution.cwd };
       const summonsPrepared = await prepareSummonsResumeMaterials(admitted.runDirectory, effective.summons);
       return buildInstructionSeatTurnRequest(
         admitted,
         {
-          ...resumeTurnRequestProjectionOptions(admitted, effective, activeEnv, summonsPrepared),
-          ...(execution.cwd === undefined ? {} : { cwd: execution.cwd }),
+          ...resumeTurnRequestProjectionOptions(admitted, effective, env, summonsPrepared),
         },
       );
     },
@@ -864,24 +831,6 @@ export async function runPublicInstructionSeatResume(
         ...(knownCause === undefined ? {} : { knownCause }),
       });
     },
-    afterAdmittedPrepare: async (admitted) => {
-      if (!wantsFreshExecutionCopy(admitted.role)) return {};
-      if (execution.cwd !== undefined) {
-        return { env: { ...env, executionCwd: execution.cwd } };
-      }
-      const { openEphemeralReviewerWorktree } = await import("../public-role-summons.ts");
-      const opened = await openEphemeralReviewerWorktree({
-        projectRoot: admitted.projectRoot,
-        onCleanupDiagnostic: (diagnostic) => {
-          io.stderr(`${diagnostic}\n`);
-        },
-      });
-      execution.cwd = opened.executionCwd;
-      return {
-        env: { ...env, executionCwd: opened.executionCwd },
-        cleanup: opened.close,
-      };
-    },
     ...(env.engine === undefined ? {} : { effectiveEngine: env.engine }),
   });
 }

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

@@ -330,12 +330,6 @@ export type PostAdmissionEnv = {
   boundTicketNumber?: number;
   /** 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;
 };
 
 /**
@@ -1390,7 +1384,6 @@ export function roleTurnOptions(
   env: PostAdmissionEnv,
   admitted: { readonly correlationId?: string },
   continuation: RoleTurnRequest["continuation"],
-  extra?: { readonly cwd?: string },
 ): RoleTurnRequestProjectionOptions {
   const correlationId = admitted.correlationId ?? env.correlationId;
   return {
@@ -1404,7 +1397,6 @@ export function roleTurnOptions(
       ? {}
       : { correlationId }),
     continuation,
-    ...(extra?.cwd === undefined ? {} : { cwd: extra.cwd }),
     ...(env.stationChild === undefined ? {} : { stationChild: env.stationChild }),
   };
 }
@@ -1514,16 +1506,6 @@ 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;
@@ -1556,9 +1538,7 @@ 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 env = input.env;
 
   const buildRequestAfterLease = async (): Promise<RoleTurnRequest> => {
         let openCourtAttemptId: string | undefined;
@@ -1645,13 +1625,7 @@ export async function runPostAdmissionSeatResume<
   // auto-resume both pass through to the host CLI without a package writer-lease
   // pre-gate (#987 / ADR 0080). Station-child same-ticket/same-parent resume is
   // still call-local auto-resume (#840 / #416).
-  // afterAdmittedPrepare runs inside this try so mint failure and cleanup share one finally.
   try {
-    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);
@@ -1741,16 +1715,12 @@ export async function runPostAdmissionSeatResume<
       buildRequestAfterLease,
     });
   } catch (error) {
-    // Seat preparation may still surface structural rejection.
+    // Turn construction may still surface structural rejection.
     if (error instanceof CliUsageError) {
       presentStructuralRejection(error, input.io);
       return { exitCode: 2 };
     }
     throw error;
-  } finally {
-    if (preparedCleanup !== undefined) {
-      await preparedCleanup();
-    }
   }
 }