@snappedly-tools/shipyard 0.5.0 → 0.7.0-staging.36081473933

package/dist/index.js

@@ -1,36 +1,25 @@
-import { CODEX_MODELS, resolveEnv, formatErrorMessage, buildLogDirectoryName } from './chunk-56TDSWFU.js';
-export { CODEX_MODELS, CODEX_REASONING_EFFORTS } from './chunk-56TDSWFU.js';
-import { CwdError, resolveCwd, getCurrentBranch, generateTempBranchName, assertNoSymlinkComponents, FileDisplay, ClackDisplay, WorktreeDockerSandboxFactory, SandboxConfig, Display, CLI_NAME, PRODUCT_NAME, pruneStale, create, copyToWorktree, runHostHooks, startSandbox, resolveGitMounts, patchGitMountsForWindows, SANDBOX_REPO_DIR, remove, makeSandboxFromHandle, syncOut, withSandboxLifecycle, hasUncommittedChanges, registerShutdown, SandboxFactory, PromptError, CONFIG_DIR, LOGS_DIR, AgentError, SessionCaptureError, PromptExpansionTimeoutError, SilentDisplay, AgentIdleTimeoutError } from './chunk-FDYOTN55.js';
-import { shellQuote, toSessionTransferHandle } from './chunk-KMGNFXKN.js';
-export { createBindMountSandboxProvider, createIsolatedSandboxProvider } from './chunk-KMGNFXKN.js';
-import { noSandbox } from './chunk-SOJTAJTF.js';
-import './chunk-ACD46ZM4.js';
+import { CODEX_MODELS, resolveEnv, formatErrorMessage, buildLogDirectoryName } from './chunk-JI3HDDMS.js';
+export { CODEX_MODELS, CODEX_REASONING_EFFORTS } from './chunk-JI3HDDMS.js';
+import { CwdError, resolveCwd, getCurrentBranch, generateTempBranchName, assertNoSymlinkComponents, FileDisplay, ClackDisplay, WorktreeDockerSandboxFactory, SandboxConfig, Display, CLI_NAME, PRODUCT_NAME, pruneStale, create, runHostHooks, startSandbox, remove, makeSandboxFromHandle, withSandboxLifecycle, hasUncommittedChanges, shellQuote, registerShutdown, toSessionTransferHandle, SandboxFactory, syncOut, PromptError, CONFIG_DIR, LOGS_DIR, AgentError, SessionCaptureError, PromptExpansionTimeoutError, assertExcludesRepositoryRunner, resolveSafeRelativePath, CopyToWorktreeError, withTimeout, CopyToWorktreeTimeoutError, SilentDisplay, AgentIdleTimeoutError } from './chunk-L6PX5QTU.js';
+export { createIsolatedSandboxProvider } from './chunk-L6PX5QTU.js';
 import { NodeContext, NodeFileSystem } from '@effect/platform-node';
-import { mkdirSync, chmodSync, appendFileSync, constants } from 'fs';
+import { existsSync, mkdirSync, chmodSync, appendFileSync, constants } from 'fs';
 import path, { join, posix, dirname, relative } from 'path';
 import { styleText } from 'util';
 import { Context, Effect, Layer, Clock, Duration, Option, Deferred, Ref, Fiber } from 'effect';
 import { FileSystem } from '@effect/platform';
 import * as clack from '@clack/prompts';
+import { execFile } from 'child_process';
 import { readdir, access, readFile, mkdir, mkdtemp, writeFile, rm, lstat, open, chmod } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
 import { createHmac, timingSafeEqual, createHash, randomUUID } from 'crypto';
 
 // src/resumePrecheck.ts
 var assertResumeSessionExists = async (params) => {
-  const { provider, sandboxTag, hostRepoDir, resumeSession } = params;
+  const { provider, hostRepoDir, resumeSession } = params;
   if (!provider.sessionStorage) {
     throw new Error(`${provider.name} does not support resumeSession`);
   }
-  if (sandboxTag === "none") {
-    const found = await provider.sessionStorage.findByIdOnHost(resumeSession);
-    if (!found.path) {
-      throw new Error(
-        `resumeSession "${resumeSession}" not found under ${found.searchedRoot}`
-      );
-    }
-    return;
-  }
   const exists = await provider.sessionStorage.existsOnHost(
     hostRepoDir,
     resumeSession
@@ -424,7 +413,12 @@ var orchestrate = (options) => {
       yield* checkAbort();
       yield* display.status(label(`Iteration ${i}/${iterations}`), "info");
       const sandboxResult = yield* factory.withSandbox(
-        ({ hostWorktreePath, sandboxRepoPath, applyToHost, bindMountHandle }, sandbox) => withSandboxLifecycle(
+        ({
+          hostWorktreePath,
+          sandboxRepoPath,
+          applyToHost,
+          sessionTransferHandle
+        }, sandbox) => withSandboxLifecycle(
           {
             hostRepoDir,
             sandboxRepoDir: sandboxRepoPath,
@@ -440,14 +434,14 @@ var orchestrate = (options) => {
           (ctx) => Effect.gen(function* () {
             const iterationResumeSession = i === 1 ? options.resumeSession : void 0;
             const iterationForkSession = i === 1 ? options.forkSession : void 0;
-            if (iterationResumeSession && bindMountHandle && provider.sessionStorage) {
+            if (iterationResumeSession && sessionTransferHandle && provider.sessionStorage) {
               yield* display.status(label("Resuming session"), "info");
               yield* Effect.tryPromise({
                 try: () => provider.sessionStorage.resumeIntoSandbox({
                   hostCwd: hostRepoDir,
                   sandboxCwd: ctx.sandboxRepoDir,
                   sessionId: iterationResumeSession,
-                  handle: bindMountHandle
+                  handle: sessionTransferHandle
                 }),
                 catch: (e) => new SessionCaptureError({
                   message: `Session resume failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -539,14 +533,14 @@ var orchestrate = (options) => {
             yield* display.status(label("Agent stopped"), "info");
             let sessionFilePath;
             let usage = streamUsage;
-            if (provider.captureSessions && provider.sessionStorage && sessionId && bindMountHandle) {
+            if (provider.captureSessions && provider.sessionStorage && sessionId && sessionTransferHandle) {
               yield* display.status(label("Capturing session"), "info");
               yield* Effect.tryPromise({
                 try: () => provider.sessionStorage.captureToHost({
                   hostCwd: hostRepoDir,
                   sandboxCwd: ctx.sandboxRepoDir,
                   sessionId,
-                  handle: bindMountHandle
+                  handle: sessionTransferHandle
                 }),
                 catch: (e) => new SessionCaptureError({
                   message: `Session capture failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1019,18 +1013,9 @@ async function run(options) {
     agent: provider
   } = options;
   validateMaxIterations(maxIterations);
-  const branchStrategy = options.branchStrategy ?? (options.sandbox.tag === "isolated" ? { type: "merge-to-head" } : { type: "head" });
-  const effectiveBranchType = branchStrategy.type;
-  if (effectiveBranchType === "head" && options.sandbox.tag === "isolated") {
-    throw new Error(
-      "head branch strategy is not supported with isolated providers"
-    );
-  }
-  if (effectiveBranchType === "head" && options.copyToWorktree && options.copyToWorktree.length > 0) {
-    throw new Error(
-      "copyToWorktree is not supported with head branch strategy. In head mode the host working directory is bind-mounted directly."
-    );
-  }
+  const branchStrategy = options.branchStrategy ?? {
+    type: "merge-to-head"
+  };
   if (options.resumeSession && maxIterations > 1) {
     throw new Error(
       "resumeSession cannot be combined with maxIterations > 1. Resume applies to iteration 1 only; multi-iteration resume semantics are not supported."
@@ -1064,7 +1049,6 @@ async function run(options) {
   if (options.resumeSession) {
     await assertResumeSessionExists({
       provider,
-      sandboxTag: options.sandbox.tag,
       hostRepoDir,
       resumeSession: options.resumeSession
     });
@@ -1096,8 +1080,8 @@ async function run(options) {
   const currentHostBranch = await Effect.runPromise(
     getCurrentBranch(hostRepoDir)
   );
-  const resolvedBranch = effectiveBranchType === "head" ? currentHostBranch : branch ?? generateTempBranchName(options.name);
-  const targetBranch = effectiveBranchType === "merge-to-head" ? currentHostBranch : void 0;
+  const resolvedBranch = branch ?? generateTempBranchName(options.name);
+  const targetBranch = branchStrategy.type === "merge-to-head" ? currentHostBranch : void 0;
   const resolvedLogging = options.logging ?? {
     type: "file",
     path: buildDefaultLogPath(
@@ -1182,7 +1166,7 @@ async function run(options) {
         builtInArgKeysSet
       );
     }
-    const orchestrateBranch = effectiveBranchType === "head" ? currentHostBranch : branch;
+    const orchestrateBranch = branch;
     const orchestrateResult = yield* orchestrate({
       hostRepoDir,
       iterations: maxIterations,
@@ -1333,25 +1317,16 @@ var raceAbortSignal = (effect, signal) => {
 var interactive = async (options) => {
   options.signal?.throwIfAborted();
   const { prompt, promptFile, hooks, agent: provider } = options;
-  const resolvedSandbox = options.sandbox ?? noSandbox();
-  const branchStrategy = options.branchStrategy ?? (resolvedSandbox.tag === "isolated" ? { type: "merge-to-head" } : { type: "head" });
-  if (branchStrategy.type === "head" && resolvedSandbox.tag === "isolated") {
-    throw new Error(
-      "head branch strategy is not supported with isolated providers"
-    );
-  }
-  if (branchStrategy.type === "head" && options.copyToWorktree && options.copyToWorktree.length > 0) {
-    throw new Error(
-      "copyToWorktree is not supported with head branch strategy. In head mode the host working directory is bind-mounted directly."
-    );
-  }
+  const resolvedSandbox = options.sandbox;
+  const branchStrategy = options.branchStrategy ?? {
+    type: "merge-to-head"
+  };
   if (!provider.buildInteractiveArgs) {
     throw new Error(
       `Agent provider "${provider.name}" does not support buildInteractiveArgs, required for interactive sessions.`
     );
   }
   const branch = branchStrategy.type === "branch" ? branchStrategy.branch : void 0;
-  const isHeadMode = branchStrategy.type === "head";
   const sandboxProvider = resolvedSandbox;
   const inner = Effect.gen(function* () {
     const hostRepoDir = yield* resolveCwd(options.cwd);
@@ -1368,7 +1343,7 @@ var interactive = async (options) => {
     });
     const effectiveEnv = { ...env, ...options.env ?? {} };
     const currentHostBranch = yield* getCurrentBranch(hostRepoDir);
-    const resolvedBranch = branchStrategy.type === "head" ? currentHostBranch : branch ?? generateTempBranchName(options.name);
+    const resolvedBranch = branch ?? generateTempBranchName(options.name);
     let substitutedPrompt = rawPrompt;
     if (hasPromptSource && !isInlinePrompt) {
       const userArgs = options.promptArgs ?? {};
@@ -1408,86 +1383,38 @@ var interactive = async (options) => {
       const userArgs = options.promptArgs ?? {};
       yield* validateNoArgsWithInlinePrompt(userArgs);
     }
-    const lifecycleBranch = isHeadMode ? currentHostBranch : branch;
+    const lifecycleBranch = branch;
     yield* d.intro(options.name ?? `${CLI_NAME} interactive`);
     yield* d.summary("Interactive Session", {
       Agent: options.name ?? provider.name,
       Sandbox: sandboxProvider.name,
       Branch: resolvedBranch
     });
-    let worktreeInfo;
-    if (!isHeadMode) {
-      worktreeInfo = yield* d.taskLog(
-        "Creating worktree",
-        () => pruneStale(hostRepoDir).pipe(
-          Effect.catchAll(() => Effect.void),
-          Effect.andThen(
-            branch ? create(hostRepoDir, { branch }) : create(hostRepoDir, { name: options.name })
-          )
+    const worktreeInfo = yield* d.taskLog(
+      "Creating worktree",
+      () => pruneStale(hostRepoDir).pipe(
+        Effect.catchAll(() => Effect.void),
+        Effect.andThen(
+          branch ? create(hostRepoDir, { branch }) : create(hostRepoDir, { name: options.name })
         )
-      );
-    }
+      )
+    );
     const handle = yield* Effect.gen(function* () {
-      if (!isHeadMode) {
-        if ((sandboxProvider.tag === "bind-mount" || sandboxProvider.tag === "none") && options.copyToWorktree && options.copyToWorktree.length > 0) {
-          yield* d.taskLog(
-            "Copying files to worktree",
-            () => copyToWorktree(
-              options.copyToWorktree,
-              hostRepoDir,
-              worktreeInfo.path,
-              options.timeouts?.copyToWorktreeMs
-            )
-          );
-        }
-        if (hooks?.host?.onWorktreeReady?.length) {
-          yield* runHostHooks(hooks.host.onWorktreeReady, worktreeInfo.path);
-        }
-      } else if (hooks?.host?.onWorktreeReady?.length) {
-        yield* runHostHooks(hooks.host.onWorktreeReady, hostRepoDir);
-      }
-      if (sandboxProvider.tag === "none") {
-        const worktreePath = isHeadMode ? hostRepoDir : worktreeInfo.path;
-        return yield* Effect.promise(
-          () => sandboxProvider.create({
-            worktreePath,
-            env: effectiveEnv
-          })
-        );
-      } else if (sandboxProvider.tag === "isolated") {
-        const startResult = yield* d.taskLog(
-          "Starting sandbox",
-          () => startSandbox({
-            provider: sandboxProvider,
-            hostRepoDir: worktreeInfo.path,
-            sourceRepoDir: hostRepoDir,
-            env: effectiveEnv,
-            copyPaths: options.copyToWorktree
-          })
-        );
-        return startResult.handle;
-      } else {
-        const gitPath = join(hostRepoDir, ".git");
-        const rawGitMounts = yield* resolveGitMounts(gitPath);
-        const worktreeOrRepoPath = isHeadMode ? hostRepoDir : worktreeInfo.path;
-        const gitMounts = yield* patchGitMountsForWindows(
-          rawGitMounts,
-          worktreeOrRepoPath,
-          SANDBOX_REPO_DIR
-        );
-        const startResult = yield* d.taskLog(
-          "Starting sandbox",
-          () => startSandbox({
-            provider: sandboxProvider,
-            hostRepoDir,
-            env: effectiveEnv,
-            worktreeOrRepoPath,
-            gitMounts,
-            repoDir: SANDBOX_REPO_DIR
-          })
-        );
-        return startResult.handle;
+      if (hooks?.host?.onWorktreeReady?.length) {
+        yield* runHostHooks(hooks.host.onWorktreeReady, worktreeInfo.path);
       }
+      const startResult = yield* d.taskLog(
+        "Starting sandbox",
+        () => startSandbox({
+          provider: sandboxProvider,
+          hostRepoDir: worktreeInfo.path,
+          sourceRepoDir: hostRepoDir,
+          env: effectiveEnv,
+          copyPaths: options.copyToWorktree,
+          copyTimeoutMs: options.timeouts?.copyToWorktreeMs
+        })
+      );
+      return startResult.handle;
     }).pipe(
       Effect.tapError(
         () => worktreeInfo ? remove(worktreeInfo.path).pipe(
@@ -1504,14 +1431,14 @@ var interactive = async (options) => {
       const interactiveExecFn = handle.interactiveExec.bind(handle);
       const sandbox = makeSandboxFromHandle(handle);
       const worktreePath = handle.worktreePath;
-      const applyToHost = sandboxProvider.tag === "isolated" && worktreeInfo ? () => syncOut(worktreeInfo.path, handle) : () => Effect.void;
+      const applyToHost = () => syncOut(worktreeInfo.path, handle);
       const lifecycleEffect = withSandboxLifecycle(
         {
           hostRepoDir,
           sandboxRepoDir: worktreePath,
           hooks,
           branch: lifecycleBranch,
-          hostWorktreePath: isHeadMode ? hostRepoDir : worktreeInfo?.path,
+          hostWorktreePath: worktreeInfo.path,
           applyToHost,
           timeouts: options.timeouts
         },
@@ -1524,7 +1451,7 @@ var interactive = async (options) => {
           );
           const interactiveArgs = provider.buildInteractiveArgs({
             prompt: fullPrompt,
-            dangerouslySkipPermissions: sandboxProvider.tag !== "none"
+            dangerouslySkipPermissions: true
           });
           const result4 = yield* raceAbortSignal(
             Effect.promise(
@@ -1596,6 +1523,15 @@ var interactive = async (options) => {
   }
   return result3;
 };
+var runRequiredSandboxHook = (sandbox, command, cwd, sudo) => Effect.flatMap(
+  sandbox.exec(command, { cwd, sudo }),
+  (result3) => result3.exitCode === 0 ? Effect.succeed(result3) : Effect.fail(
+    new Error(
+      `Sandbox setup failed (exit ${result3.exitCode}): ${command}
+${result3.stderr}`
+    )
+  )
+);
 var buildSandboxHandle = (ctx, close) => {
   const {
     branch,
@@ -1604,7 +1540,7 @@ var buildSandboxHandle = (ctx, close) => {
     sandboxRepoDir,
     sandbox,
     providerHandle,
-    bindMountHandle,
+    sessionTransferHandle,
     applyToHost,
     timeouts,
     branchStrategy
@@ -1635,7 +1571,6 @@ var buildSandboxHandle = (ctx, close) => {
       if (runOptions.resumeSession) {
         await assertResumeSessionExists({
           provider,
-          sandboxTag: ctx.providerTag,
           hostRepoDir,
           resumeSession: runOptions.resumeSession
         });
@@ -1706,7 +1641,7 @@ var buildSandboxHandle = (ctx, close) => {
             hostWorktreePath: worktreePath,
             sandboxRepoPath: sandboxRepoDir,
             applyToHost,
-            bindMountHandle
+            sessionTransferHandle
           },
           sandbox
         ).pipe(
@@ -1926,24 +1861,13 @@ var buildSandboxHandle = (ctx, close) => {
 var createSandboxFromWorktree = async (options) => {
   const { branch, worktreePath, hostRepoDir } = options;
   const isTestMode = !!options._test?.buildSandbox;
-  if (options.copyToWorktree && options.copyToWorktree.length > 0 && options.sandbox.tag !== "isolated") {
-    await Effect.runPromise(
-      copyToWorktree(
-        options.copyToWorktree,
-        hostRepoDir,
-        worktreePath,
-        options.timeouts?.copyToWorktreeMs
-      )
-    );
-  }
   let providerHandle;
   let sandbox;
   let sandboxRepoDir;
-  const isIsolated = options.sandbox.tag === "isolated";
   if (isTestMode) {
     sandbox = options._test.buildSandbox(worktreePath);
     sandboxRepoDir = worktreePath;
-    providerHandle = options._test.bindMountHandle;
+    providerHandle = options._test.sessionTransferHandle;
   } else {
     const resolvedEnv = await Effect.runPromise(
       resolveEnv(hostRepoDir).pipe(Effect.provide(NodeContext.layer))
@@ -1954,42 +1878,15 @@ var createSandboxFromWorktree = async (options) => {
       sandboxProviderEnv: options.sandbox.env
     });
     const provider = options.sandbox;
-    let startEffect;
-    if (provider.tag === "isolated") {
-      startEffect = startSandbox({
-        provider,
-        hostRepoDir: worktreePath,
-        sourceRepoDir: hostRepoDir,
-        env,
-        copyPaths: options.copyToWorktree
-      });
-    } else if (provider.tag === "none") {
-      startEffect = startSandbox({
-        provider,
-        hostRepoDir,
-        env,
-        worktreeOrRepoPath: worktreePath
-      });
-    } else {
-      startEffect = resolveGitMounts(join(hostRepoDir, ".git")).pipe(
-        Effect.provide(NodeFileSystem.layer),
-        Effect.catchAll(() => Effect.succeed([])),
-        // Patch git mounts for Windows worktree compatibility (ADR-0006)
-        Effect.flatMap(
-          (gitMounts) => patchGitMountsForWindows(gitMounts, worktreePath, SANDBOX_REPO_DIR)
-        ),
-        Effect.flatMap(
-          (gitMounts) => startSandbox({
-            provider,
-            hostRepoDir,
-            env,
-            worktreeOrRepoPath: worktreePath,
-            gitMounts,
-            repoDir: SANDBOX_REPO_DIR
-          })
-        )
-      );
-    }
+    const startEffect = startSandbox({
+      provider,
+      hostRepoDir: worktreePath,
+      sourceRepoDir: hostRepoDir,
+      copySourceDir: worktreePath,
+      env,
+      copyPaths: options.copyToWorktree,
+      copyTimeoutMs: options.timeouts?.copyToWorktreeMs
+    });
     const startResult = await Effect.runPromise(startEffect);
     providerHandle = startResult.handle;
     sandbox = startResult.sandbox;
@@ -2004,10 +1901,12 @@ var createSandboxFromWorktree = async (options) => {
           `git config --global --add safe.directory ${shellQuote(sandboxRepoDir)}`
         );
         const sandboxEffects = (sandboxOnReady ?? []).map(
-          (hook) => sandbox.exec(hook.command, {
-            cwd: sandboxRepoDir,
-            sudo: hook.sudo
-          })
+          (hook) => runRequiredSandboxHook(
+            sandbox,
+            hook.command,
+            sandboxRepoDir,
+            hook.sudo
+          )
         );
         const allEffects = [...sandboxEffects];
         if (hostOnReady?.length) {
@@ -2016,12 +1915,17 @@ var createSandboxFromWorktree = async (options) => {
         yield* Effect.all(allEffects, {
           concurrency: "unbounded"
         });
-      })
+      }).pipe(
+        Effect.onError(
+          () => providerHandle ? Effect.promise(() => providerHandle.close().catch(() => {
+          })) : Effect.void
+        )
+      )
     );
   }
-  const applyToHost = isIsolated && providerHandle ? () => syncOut(worktreePath, providerHandle) : () => Effect.void;
+  const applyToHost = providerHandle ? () => syncOut(worktreePath, providerHandle) : () => Effect.void;
   let closed = false;
-  const bindMountHandle = toSessionTransferHandle(providerHandle);
+  const sessionTransferHandle = toSessionTransferHandle(providerHandle);
   return buildSandboxHandle(
     {
       branch,
@@ -2030,8 +1934,7 @@ var createSandboxFromWorktree = async (options) => {
       sandboxRepoDir,
       sandbox,
       providerHandle,
-      bindMountHandle,
-      providerTag: options.sandbox.tag,
+      sessionTransferHandle,
       applyToHost,
       timeouts: options.timeouts,
       branchStrategy: options.branchStrategy
@@ -2047,7 +1950,6 @@ var createSandboxFromWorktree = async (options) => {
 var createSandbox = async (options) => {
   const { branch } = options;
   const isTestMode = !!options._test?.buildSandbox;
-  const isIsolated = options.sandbox.tag === "isolated";
   const { hostRepoDir, worktreePath, providerHandle, sandbox, sandboxRepoDir } = await Effect.runPromise(
     Effect.gen(function* () {
       const hostRepoDir2 = yield* resolveCwd(options.cwd);
@@ -2059,14 +1961,6 @@ var createSandbox = async (options) => {
         { branch, baseBranch: options.baseBranch }
       );
       const prepared = yield* Effect.gen(function* () {
-        if (options.copyToWorktree && options.copyToWorktree.length > 0 && options.sandbox.tag !== "isolated") {
-          yield* copyToWorktree(
-            options.copyToWorktree,
-            hostRepoDir2,
-            worktreePath2,
-            options.timeouts?.copyToWorktreeMs
-          );
-        }
         if (options.hooks?.host?.onWorktreeReady?.length) {
           yield* runHostHooks(
             options.hooks.host.onWorktreeReady,
@@ -2079,7 +1973,7 @@ var createSandbox = async (options) => {
         if (isTestMode) {
           sandbox2 = options._test.buildSandbox(worktreePath2);
           sandboxRepoDir2 = worktreePath2;
-          providerHandle2 = options._test.bindMountHandle;
+          providerHandle2 = options._test.sessionTransferHandle;
         } else {
           const resolvedEnv = yield* resolveEnv(hostRepoDir2);
           const env = mergeProviderEnv({
@@ -2088,39 +1982,14 @@ var createSandbox = async (options) => {
             sandboxProviderEnv: options.sandbox.env
           });
           const provider = options.sandbox;
-          const startResult = yield* provider.tag === "isolated" ? startSandbox({
+          const startResult = yield* startSandbox({
             provider,
             hostRepoDir: worktreePath2,
             sourceRepoDir: hostRepoDir2,
             env,
-            copyPaths: options.copyToWorktree
-          }) : provider.tag === "none" ? startSandbox({
-            provider,
-            hostRepoDir: hostRepoDir2,
-            env,
-            worktreeOrRepoPath: worktreePath2
-          }) : resolveGitMounts(join(hostRepoDir2, ".git")).pipe(
-            Effect.provide(NodeFileSystem.layer),
-            Effect.catchAll(() => Effect.succeed([])),
-            // Patch git mounts for Windows worktree compatibility (ADR-0006)
-            Effect.flatMap(
-              (gitMounts) => patchGitMountsForWindows(
-                gitMounts,
-                worktreePath2,
-                SANDBOX_REPO_DIR
-              )
-            ),
-            Effect.flatMap(
-              (gitMounts) => startSandbox({
-                provider,
-                hostRepoDir: hostRepoDir2,
-                env,
-                worktreeOrRepoPath: worktreePath2,
-                gitMounts,
-                repoDir: SANDBOX_REPO_DIR
-              })
-            )
-          );
+            copyPaths: options.copyToWorktree,
+            copyTimeoutMs: options.timeouts?.copyToWorktreeMs
+          });
           providerHandle2 = startResult.handle;
           sandbox2 = startResult.sandbox;
           sandboxRepoDir2 = startResult.worktreePath;
@@ -2133,10 +2002,12 @@ var createSandbox = async (options) => {
               `git config --global --add safe.directory ${shellQuote(sandboxRepoDir2)}`
             );
             const sandboxEffects = (sandboxOnReady ?? []).map(
-              (hook) => sandbox2.exec(hook.command, {
-                cwd: sandboxRepoDir2,
-                sudo: hook.sudo
-              })
+              (hook) => runRequiredSandboxHook(
+                sandbox2,
+                hook.command,
+                sandboxRepoDir2,
+                hook.sudo
+              )
             );
             const allEffects = [...sandboxEffects];
             if (hostOnReady?.length) {
@@ -2163,7 +2034,7 @@ var createSandbox = async (options) => {
       return { hostRepoDir: hostRepoDir2, worktreePath: worktreePath2, ...prepared };
     }).pipe(Effect.provide(NodeContext.layer))
   );
-  const applyToHost = isIsolated && providerHandle ? () => syncOut(worktreePath, providerHandle) : () => Effect.void;
+  const applyToHost = providerHandle ? () => syncOut(worktreePath, providerHandle) : () => Effect.void;
   let closed = false;
   const forceCleanup = () => {
     console.error(`
@@ -2193,7 +2064,7 @@ Worktree preserved at ${worktreePath}`);
       })
     );
   };
-  const bindMountHandle = toSessionTransferHandle(providerHandle);
+  const sessionTransferHandle = toSessionTransferHandle(providerHandle);
   return buildSandboxHandle(
     {
       branch,
@@ -2202,8 +2073,7 @@ Worktree preserved at ${worktreePath}`);
       sandboxRepoDir,
       sandbox,
       providerHandle,
-      bindMountHandle,
-      providerTag: options.sandbox.tag,
+      sessionTransferHandle,
       applyToHost,
       timeouts: options.timeouts
     },
@@ -2213,6 +2083,82 @@ Worktree preserved at ${worktreePath}`);
     }
   );
 };
+var COPY_TO_WORKTREE_TIMEOUT_MS = 6e4;
+var getCopyOnWriteFlags = (platform) => platform === "darwin" ? ["-cR"] : ["-R", "--reflink=auto"];
+var copyToWorktree = (paths, hostRepoDir, worktreePath, timeoutMs) => {
+  const effectiveTimeout = timeoutMs ?? COPY_TO_WORKTREE_TIMEOUT_MS;
+  return Effect.gen(function* () {
+    const cowFlags = getCopyOnWriteFlags(process.platform);
+    for (const relativePath of paths) {
+      let src;
+      let dest;
+      try {
+        assertExcludesRepositoryRunner(relativePath);
+        src = resolveSafeRelativePath(hostRepoDir, relativePath, "copy path");
+        dest = resolveSafeRelativePath(worktreePath, relativePath, "copy path");
+      } catch (error) {
+        return yield* Effect.fail(
+          new CopyToWorktreeError({
+            message: `Refusing unsafe copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
+            path: relativePath,
+            stderr: error instanceof Error ? error.message : String(error),
+            exitCode: null
+          })
+        );
+      }
+      if (!existsSync(src)) {
+        continue;
+      }
+      yield* Effect.tryPromise({
+        try: async () => {
+          await assertNoSymlinkComponents(hostRepoDir, src, "copy source");
+          await assertNoSymlinkComponents(worktreePath, dest, "copy target");
+        },
+        catch: (error) => new CopyToWorktreeError({
+          message: `Refusing symlinked copy path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`,
+          path: relativePath,
+          stderr: error instanceof Error ? error.message : String(error),
+          exitCode: null
+        })
+      });
+      yield* Effect.async((resume) => {
+        execFile("cp", [...cowFlags, src, dest], (error) => {
+          if (error) {
+            execFile("cp", ["-R", src, dest], (fallbackError, _, stderr) => {
+              if (fallbackError) {
+                resume(
+                  Effect.fail(
+                    new CopyToWorktreeError({
+                      message: `Failed to copy ${relativePath} to worktree: ${stderr || fallbackError.message}`,
+                      path: relativePath,
+                      stderr: stderr || fallbackError.message,
+                      exitCode: typeof fallbackError.code === "number" ? fallbackError.code : null
+                    })
+                  )
+                );
+              } else {
+                resume(Effect.succeed(void 0));
+              }
+            });
+          } else {
+            resume(Effect.succeed(void 0));
+          }
+        });
+      });
+    }
+  }).pipe(
+    withTimeout(
+      effectiveTimeout,
+      () => new CopyToWorktreeTimeoutError({
+        message: `Copying files to worktree timed out after ${effectiveTimeout}ms`,
+        timeoutMs: effectiveTimeout,
+        paths
+      })
+    )
+  );
+};
+
+// src/createWorktree.ts
 var createWorktree = async (options) => {
   const branch = options.branchStrategy.type === "branch" ? options.branchStrategy.branch : void 0;
   const baseBranch = options.branchStrategy.type === "branch" ? options.branchStrategy.baseBranch : void 0;
@@ -2259,7 +2205,7 @@ var createWorktree = async (options) => {
   const worktreeInteractive = async (opts) => {
     opts.signal?.throwIfAborted();
     const { prompt, promptFile, hooks, agent: provider } = opts;
-    const resolvedSandbox = opts.sandbox ?? noSandbox();
+    const resolvedSandbox = opts.sandbox;
     if (!provider.buildInteractiveArgs) {
       throw new Error(
         `Agent provider "${provider.name}" does not support buildInteractiveArgs, required for interactive sessions.`
@@ -2302,46 +2248,19 @@ var createWorktree = async (options) => {
         Sandbox: resolvedSandbox.name,
         Branch: worktreeInfo.branch
       });
-      let handle;
-      if (resolvedSandbox.tag === "none") {
-        handle = yield* Effect.promise(
-          () => resolvedSandbox.create({
-            worktreePath: worktreeInfo.path,
-            env: effectiveEnv
-          })
-        );
-      } else if (resolvedSandbox.tag === "isolated") {
-        const startResult = yield* d.taskLog(
-          "Starting sandbox",
-          () => startSandbox({
-            provider: resolvedSandbox,
-            hostRepoDir: worktreeInfo.path,
-            sourceRepoDir: hostRepoDir,
-            env: effectiveEnv
-          })
-        );
-        handle = startResult.handle;
-      } else {
-        const gitPath = join(hostRepoDir, ".git");
-        const rawGitMounts = yield* resolveGitMounts(gitPath);
-        const gitMounts = yield* patchGitMountsForWindows(
-          rawGitMounts,
-          worktreeInfo.path,
-          SANDBOX_REPO_DIR
-        );
-        const startResult = yield* d.taskLog(
-          "Starting sandbox",
-          () => startSandbox({
-            provider: resolvedSandbox,
-            hostRepoDir,
-            env: effectiveEnv,
-            worktreeOrRepoPath: worktreeInfo.path,
-            gitMounts,
-            repoDir: SANDBOX_REPO_DIR
-          })
-        );
-        handle = startResult.handle;
-      }
+      const startResult = yield* d.taskLog(
+        "Starting sandbox",
+        () => startSandbox({
+          provider: resolvedSandbox,
+          hostRepoDir: worktreeInfo.path,
+          sourceRepoDir: hostRepoDir,
+          copySourceDir: worktreeInfo.path,
+          env: effectiveEnv,
+          copyPaths: options.copyToWorktree,
+          copyTimeoutMs: options.timeouts?.copyToWorktreeMs
+        })
+      );
+      const handle = startResult.handle;
       return yield* Effect.gen(function* () {
         if (!handle.interactiveExec) {
           throw new Error(
@@ -2351,7 +2270,7 @@ var createWorktree = async (options) => {
         const interactiveExecFn = handle.interactiveExec.bind(handle);
         const sandbox = makeSandboxFromHandle(handle);
         const worktreePath = handle.worktreePath;
-        const applyToHost = resolvedSandbox.tag === "isolated" ? () => syncOut(worktreeInfo.path, handle) : () => Effect.void;
+        const applyToHost = () => syncOut(worktreeInfo.path, handle);
         const lifecycleEffect = withSandboxLifecycle(
           {
             hostRepoDir,
@@ -2375,7 +2294,7 @@ var createWorktree = async (options) => {
             );
             const interactiveArgs = provider.buildInteractiveArgs({
               prompt: fullPrompt,
-              dangerouslySkipPermissions: resolvedSandbox.tag !== "none"
+              dangerouslySkipPermissions: true
             });
             const result3 = yield* raceAbortSignal(
               Effect.promise(
@@ -2438,7 +2357,6 @@ var createWorktree = async (options) => {
     if (opts.resumeSession) {
       await assertResumeSessionExists({
         provider,
-        sandboxTag: sandboxProvider.tag,
         hostRepoDir,
         resumeSession: opts.resumeSession
       });
@@ -2473,47 +2391,19 @@ var createWorktree = async (options) => {
           builtInArgKeysSet
         );
       }
-      let handle;
-      let sandboxRepoDir;
-      if (sandboxProvider.tag === "isolated") {
-        const startResult = yield* startSandbox({
-          provider: sandboxProvider,
-          hostRepoDir: worktreeInfo.path,
-          sourceRepoDir: hostRepoDir,
-          env: effectiveEnv
-        });
-        handle = startResult.handle;
-        sandboxRepoDir = startResult.worktreePath;
-      } else if (sandboxProvider.tag === "none") {
-        const startResult = yield* startSandbox({
-          provider: sandboxProvider,
-          hostRepoDir,
-          env: effectiveEnv,
-          worktreeOrRepoPath: worktreeInfo.path
-        });
-        handle = startResult.handle;
-        sandboxRepoDir = startResult.worktreePath;
-      } else {
-        const gitPath = join(hostRepoDir, ".git");
-        const rawGitMounts = yield* resolveGitMounts(gitPath);
-        const gitMounts = yield* patchGitMountsForWindows(
-          rawGitMounts,
-          worktreeInfo.path,
-          SANDBOX_REPO_DIR
-        );
-        const startResult = yield* startSandbox({
-          provider: sandboxProvider,
-          hostRepoDir,
-          env: effectiveEnv,
-          worktreeOrRepoPath: worktreeInfo.path,
-          gitMounts,
-          repoDir: SANDBOX_REPO_DIR
-        });
-        handle = startResult.handle;
-        sandboxRepoDir = startResult.worktreePath;
-      }
+      const startResult = yield* startSandbox({
+        provider: sandboxProvider,
+        hostRepoDir: worktreeInfo.path,
+        sourceRepoDir: hostRepoDir,
+        copySourceDir: worktreeInfo.path,
+        env: effectiveEnv,
+        copyPaths: options.copyToWorktree,
+        copyTimeoutMs: options.timeouts?.copyToWorktreeMs
+      });
+      const handle = startResult.handle;
+      const sandboxRepoDir = startResult.worktreePath;
       const sandbox = makeSandboxFromHandle(handle);
-      const applyToHost = sandboxProvider.tag === "isolated" ? () => syncOut(worktreeInfo.path, handle) : () => Effect.void;
+      const applyToHost = () => syncOut(worktreeInfo.path, handle);
       const resolvedLogging = opts.logging ?? {
         type: "file",
         path: buildDefaultLogPath(
@@ -2546,14 +2436,14 @@ var createWorktree = async (options) => {
           NodeFileSystem.layer
         );
       })() : ClackDisplay.layer;
-      const bindMountHandle = toSessionTransferHandle(handle);
+      const sessionTransferHandle = toSessionTransferHandle(handle);
       const reuseFactoryLayer = Layer.succeed(SandboxFactory, {
         withSandbox: (makeEffect) => makeEffect(
           {
             hostWorktreePath: worktreeInfo.path,
             sandboxRepoPath: sandboxRepoDir,
             applyToHost,
-            bindMountHandle
+            sessionTransferHandle
           },
           sandbox
         ).pipe(
@@ -2634,13 +2524,28 @@ var createWorktree = async (options) => {
     }
   };
   const worktreeCreateSandbox = async (opts) => {
+    if (opts.copyToWorktree?.length) {
+      await Effect.runPromise(
+        copyToWorktree(
+          opts.copyToWorktree,
+          hostRepoDir,
+          worktreeInfo.path,
+          opts.timeouts?.copyToWorktreeMs ?? options.timeouts?.copyToWorktreeMs
+        )
+      );
+    }
     return createSandboxFromWorktree({
       branch: worktreeInfo.branch,
       worktreePath: worktreeInfo.path,
       hostRepoDir,
       sandbox: opts.sandbox,
       hooks: opts.hooks,
-      copyToWorktree: opts.copyToWorktree,
+      copyToWorktree: [
+        .../* @__PURE__ */ new Set([
+          ...options.copyToWorktree ?? [],
+          ...opts.copyToWorktree ?? []
+        ])
+      ],
       timeouts: opts.timeouts,
       branchStrategy: options.branchStrategy,
       _test: opts._test
@@ -3009,8 +2914,7 @@ var makeClaudeSessionStorage = (options) => {
         sandboxProjectsDir
       );
       await writeSandboxFile(handle, sandboxPath, rewritten, "claude-res");
-    },
-    findByIdOnHost: (id) => findClaudeSessionOnHost(id, hostProjectsDir)
+    }
   };
 };
 var makeCodexSessionStorage = (options) => {
@@ -3048,8 +2952,7 @@ var makeCodexSessionStorage = (options) => {
       const rewritten = transferCodexSession(jsonl, hostCwd, sandboxCwd);
       const target = posix.join(sandboxSessionsDir, located.relativePath);
       await writeSandboxFile(handle, target, rewritten, "codex-res");
-    },
-    findByIdOnHost: (id) => findCodexSessionOnHost(id, hostSessionsDir)
+    }
   };
 };
 var parseCodexUsage = (usage) => {
@@ -3096,7 +2999,7 @@ var parseCodexStreamLine = (line) => {
 };
 var codex = (model, options) => {
   const modelId = typeof model === "string" ? model : model.model;
-  const effort = options?.effort ?? (typeof model === "string" ? CONFIGURED_CODEX_MODEL_EFFORTS.get(modelId) : model.effort);
+  const effort = options?.effort === null ? void 0 : options?.effort ?? (typeof model === "string" ? CONFIGURED_CODEX_MODEL_EFFORTS.get(modelId) : model.effort);
   return {
     name: "codex",
     env: options?.env ?? {},
@@ -3357,7 +3260,18 @@ var createWorkBrief = (input) => {
       "acceptanceCriteria"
     ),
     exclusions: stringArray(input.exclusions, "exclusions"),
-    risk: enumValue(input.risk, ["low", "medium", "high", "critical"], "risk"),
+    risk: enumValue(
+      input.risk,
+      ["low", "medium", "high", "critical", "unknown"],
+      "risk"
+    ),
+    ...input.scope === void 0 ? {} : {
+      scope: enumValue(
+        input.scope,
+        ["small", "substantial", "unknown"],
+        "scope"
+      )
+    },
     verification: parseVerification(input.verification),
     unresolvedQuestions: stringArray(
       input.unresolvedQuestions,
@@ -3397,7 +3311,18 @@ var parseWorkBrief = (value) => {
       "acceptanceCriteria"
     ),
     exclusions: stringArray(value.exclusions, "exclusions"),
-    risk: enumValue(value.risk, ["low", "medium", "high", "critical"], "risk"),
+    risk: enumValue(
+      value.risk,
+      ["low", "medium", "high", "critical", "unknown"],
+      "risk"
+    ),
+    ...value.scope === void 0 ? {} : {
+      scope: enumValue(
+        value.scope,
+        ["small", "substantial", "unknown"],
+        "scope"
+      )
+    },
     verification: parseVerification(value.verification),
     unresolvedQuestions: stringArray(
       value.unresolvedQuestions,
@@ -3453,6 +3378,28 @@ var parseRepositoryPolicy = (value) => {
   if (!isRecord(value.worker)) {
     throw new ContractValidationError("policy.worker must be an object");
   }
+  const workerModels = value.worker.models === void 0 ? void 0 : (() => {
+    if (value.worker.model !== void 0) {
+      throw new ContractValidationError(
+        "policy.worker.model cannot be combined with policy.worker.models"
+      );
+    }
+    if (!isRecord(value.worker.models)) {
+      throw new ContractValidationError(
+        "policy.worker.models must be an object"
+      );
+    }
+    return {
+      routine: nonEmptyString(
+        value.worker.models.routine,
+        "policy.worker.models.routine"
+      ),
+      strong: nonEmptyString(
+        value.worker.models.strong,
+        "policy.worker.models.strong"
+      )
+    };
+  })();
   if (!Array.isArray(value.checks)) {
     throw new ContractValidationError("policy.checks must be an array");
   }
@@ -3546,7 +3493,7 @@ var parseRepositoryPolicy = (value) => {
     authorization: { required, allowedActors, autoStartRisk },
     worker: {
       provider: nonEmptyString(value.worker.provider, "policy.worker.provider"),
-      model: nonEmptyString(value.worker.model, "policy.worker.model"),
+      ...workerModels === void 0 ? { model: nonEmptyString(value.worker.model, "policy.worker.model") } : { models: workerModels },
       sandbox: nonEmptyString(value.worker.sandbox, "policy.worker.sandbox"),
       skillRevision: nonEmptyString(
         value.worker.skillRevision,
@@ -3562,6 +3509,16 @@ var createRepositoryPolicy = (input) => parseRepositoryPolicy({
   contractVersion: WORKFLOW_CONTRACT_VERSION,
   ...input
 });
+var resolveAgentSelection = (policy, phase2, risk, scope) => {
+  const role = phase2 === "review" && !(risk === "low" && scope === "small") ? "strong" : "routine";
+  const worker = policy.worker;
+  const modelPath = worker.models ? `policy.worker.models.${role}` : "policy.worker.model";
+  return Object.freeze({
+    provider: nonEmptyString(worker.provider, "policy.worker.provider"),
+    model: nonEmptyString(worker.models?.[role] ?? worker.model, modelPath),
+    role
+  });
+};
 var parseCheckEvidence = (value) => {
   if (!isRecord(value)) {
     throw new ContractValidationError("check evidence must be an object");
@@ -3700,6 +3657,12 @@ var createAssignment = (input) => {
     briefHash: brief.hash,
     policyRevision: input.policy.revision,
     skillRevision: brief.skillRevision,
+    agentSelection: resolveAgentSelection(
+      input.policy,
+      input.phase,
+      brief.risk,
+      brief.scope
+    ),
     base: brief.base,
     head: input.head,
     createdAt: nonEmptyString(input.createdAt, "assignment.createdAt")
@@ -4069,6 +4032,25 @@ var parseAssignment = (value) => {
     throw new Error("Stored assignment base must be an object");
   }
   const head = candidate.head;
+  const agentSelection = candidate.agentSelection;
+  let parsedAgentSelection;
+  if (agentSelection !== void 0) {
+    if (typeof agentSelection !== "object" || agentSelection === null || Array.isArray(agentSelection)) {
+      throw new Error("Stored assignment agent selection must be an object");
+    }
+    const selection = agentSelection;
+    if (selection.role !== "routine" && selection.role !== "strong") {
+      throw new Error("Stored assignment agent selection role is invalid");
+    }
+    parsedAgentSelection = {
+      provider: requiredString(
+        selection.provider,
+        "assignment.agentSelection.provider"
+      ),
+      model: requiredString(selection.model, "assignment.agentSelection.model"),
+      role: selection.role
+    };
+  }
   const revision = (value2, path2) => {
     if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) {
       throw new Error(`${path2} must be an object`);
@@ -4112,6 +4094,7 @@ var parseAssignment = (value) => {
       candidate.skillRevision,
       "assignment.skillRevision"
     ),
+    ...parsedAgentSelection === void 0 ? {} : { agentSelection: parsedAgentSelection },
     base: revision(base, "assignment.base"),
     head: head === void 0 ? void 0 : revision(head, "assignment.head"),
     createdAt: requiredString(candidate.createdAt, "assignment.createdAt")
@@ -4301,9 +4284,6 @@ var PostgresTransaction = class {
   async one(text2, values, path2) {
     return row(await this.client.query(text2, values), path2);
   }
-  async optional(text2, values) {
-    return optionalRow(await this.client.query(text2, values));
-  }
   async insertEventIfAbsent(event) {
     const inserted = await this.client.query(
       `INSERT INTO shipyard_events (
@@ -6031,11 +6011,23 @@ var cancelledResult = (assignment, response, artifacts, message, kind) => ({
     evidence: response.report.evidence
   })
 });
+var sameAgentSelection = (left, right) => left.provider === right.provider && left.model === right.model && left.role === right.role;
 var executePhase = async (options) => {
   const assignment = deepFreeze(structuredClone(options.assignment));
   const trusted = deepFreeze(structuredClone(options.trusted));
   const untrusted = deepFreeze(structuredClone(options.untrusted));
   const controls = deepFreeze(structuredClone(options.controls));
+  const resolvedSelection = resolveAgentSelection(
+    trusted.policy,
+    assignment.phase,
+    trusted.brief.risk,
+    trusted.brief.scope
+  );
+  const persistedSelection = assignment.agentSelection;
+  if (persistedSelection !== void 0 && !sameAgentSelection(persistedSelection, resolvedSelection)) {
+    throw new Error("Assignment agent selection does not match trusted policy");
+  }
+  const agentSelection = persistedSelection ?? resolvedSelection;
   const secretValues = /* @__PURE__ */ new Set();
   const controller = new AbortController();
   let timedOut = false;
@@ -6049,6 +6041,7 @@ var executePhase = async (options) => {
   }, options.controls.timeoutSeconds * 1e3);
   const request = {
     assignment,
+    agentSelection,
     trusted,
     untrusted,
     controls,
@@ -6293,6 +6286,23 @@ var executePhase = async (options) => {
     })
   };
 };
+var resolvePhaseAgent = (options, request) => {
+  if (options.resolveAgent === void 0 && request.trusted.policy.worker.models !== void 0) {
+    throw new Error(
+      "An agent resolver is required when repository policy defines worker models"
+    );
+  }
+  const agent = options.resolveAgent === void 0 ? options.agent : options.resolveAgent(request.agentSelection);
+  if (agent === void 0) {
+    throw new Error("The phase engine has no agent for the selected model");
+  }
+  if (agent.name !== request.agentSelection.provider) {
+    throw new Error(
+      `Resolved agent provider "${agent.name}" does not match repository policy provider "${request.agentSelection.provider}"`
+    );
+  }
+  return agent;
+};
 var runResultToResponse = (result3, branch) => {
   const commits = result3.commits.map((commit) => commit.sha);
   const headSha = commits.at(-1) ?? "";
@@ -6317,11 +6327,12 @@ var runResultToResponse = (result3, branch) => {
 };
 var createRunPhaseEngineAdapter = (options) => ({
   execute: async (request) => {
-    assertToolAllowlistSupport(options.agent);
+    const agent = resolvePhaseAgent(options, request);
+    assertToolAllowlistSupport(agent);
     const branch = request.checkout.branch;
     const baseBranch = request.checkout.immutable ? request.checkout.candidate?.sha ?? request.assignment.base.sha : request.assignment.base.sha;
     const result3 = await options.run({
-      agent: options.agent,
+      agent,
       sandbox: options.sandbox,
       cwd: options.cwd,
       prompt: buildPrompt(request),
@@ -6359,7 +6370,8 @@ var sandboxResultToResponse = (result3, branch) => {
 };
 var createCreateSandboxPhaseEngineAdapter = (options) => ({
   execute: async (request) => {
-    assertToolAllowlistSupport(options.agent);
+    const agent = resolvePhaseAgent(options, request);
+    assertToolAllowlistSupport(agent);
     const branch = request.checkout.branch;
     const baseBranch = request.checkout.immutable ? request.checkout.candidate?.sha ?? request.assignment.base.sha : request.assignment.base.sha;
     const sandbox = await options.createSandbox({
@@ -6370,7 +6382,7 @@ var createCreateSandboxPhaseEngineAdapter = (options) => ({
     });
     try {
       const result3 = await sandbox.run({
-        agent: options.agent,
+        agent,
         prompt: buildPrompt(request),
         toolAllowlist: request.controls.toolAllowlist,
         maxIterations: request.controls.maxIterations,
@@ -9012,22 +9024,6 @@ var GitHubIntegration = class {
       reason: ingest.reason
     };
   }
-  async recordRejected(input) {
-    const payloadRecord = record(input.payload);
-    const delivery = {
-      deliveryId: input.deliveryId,
-      eventName: input.eventName,
-      repository: payloadRecord ? repositoryName(payloadRecord) ?? "unknown" : "unknown",
-      senderLogin: payloadRecord ? sender(payloadRecord).login : "unknown",
-      receivedAt: this.now(),
-      payloadHash: payloadHash(input.body),
-      payload: input.payload,
-      status: "rejected",
-      reason: input.reason
-    };
-    const stored = await this.options.deliveryStore.recordDeliveryIfAbsent(delivery);
-    if (!stored.inserted) return;
-  }
   async rejectStored(delivery, reason) {
     await this.options.deliveryStore.updateDelivery({
       ...delivery,
@@ -9952,6 +9948,6 @@ var ReleaseIntegration = class {
 };
 var candidateMatchesApproval = (candidate, approval) => sameCandidate(candidate, approval.candidate);
 
-export { ContractValidationError, CredentialNotAllowedError, CredentialUnavailableError, CwdError2 as CwdError, GitHubIntegration, GitHubPublication, InMemoryCoordinatorStorage, InMemoryGitHubStore, InMemoryReleaseStore, InMemoryRepairBatchStore, InMemoryTriageStore, LeaseBusyError, LeaseLostError, Output, PostgresCoordinatorStorage, ReleaseIntegration, StructuredOutputError, WORKFLOW_CONTRACT_VERSION, WorkflowCoordinator, WorkflowOperator, candidateMatchesApproval, claudeCode, claudeHostSessionPath, claudeSandboxSessionPath, closeSourceIssue, codex, completeSourceIssue, createAssignment, createCreateSandboxPhaseEngineAdapter, createFakePhaseEngineAdapter, createGitHubIssueBrief, createInMemoryArtifactStore, createRepositoryPolicy, createRunPhaseEngineAdapter, createSandbox, createWorkBrief, createWorktree, defaultInvestigator as defaultTriageInvestigator, encodeProjectPath, evaluateHandoffReadiness, executePhase, findClaudeSessionOnHost, findCodexSessionOnHost, interactive, isAuthorizationAllowed, mergeProtectedCandidate, parseCheckEvidence, parsePhaseResult, parseRepositoryPolicy, parseWorkBrief, prepareHumanHandoff, prepareIndependentReview, processHumanReviewDecision, redact2 as redactOperatorText, releaseCandidateKey, requireTransition, resolveHumanReviewDecision, reviewDecisionFor, run, runAuthorizedImplementation, runBoundedRepair, runIndependentReview, runTriage, scheduleBoundedRepair, transferClaudeSession, transferCodexSession, verifyGitHubWebhookSignature };
+export { ContractValidationError, CredentialNotAllowedError, CredentialUnavailableError, CwdError2 as CwdError, GitHubIntegration, GitHubPublication, InMemoryCoordinatorStorage, InMemoryGitHubStore, InMemoryReleaseStore, InMemoryRepairBatchStore, InMemoryTriageStore, LeaseBusyError, LeaseLostError, Output, PostgresCoordinatorStorage, ReleaseIntegration, StructuredOutputError, WORKFLOW_CONTRACT_VERSION, WorkflowCoordinator, WorkflowOperator, candidateMatchesApproval, claudeCode, claudeHostSessionPath, claudeSandboxSessionPath, closeSourceIssue, codex, completeSourceIssue, createAssignment, createCreateSandboxPhaseEngineAdapter, createFakePhaseEngineAdapter, createGitHubIssueBrief, createInMemoryArtifactStore, createRepositoryPolicy, createRunPhaseEngineAdapter, createSandbox, createWorkBrief, createWorktree, defaultInvestigator as defaultTriageInvestigator, encodeProjectPath, evaluateHandoffReadiness, executePhase, findClaudeSessionOnHost, findCodexSessionOnHost, interactive, isAuthorizationAllowed, mergeProtectedCandidate, parseCheckEvidence, parsePhaseResult, parseRepositoryPolicy, parseWorkBrief, prepareHumanHandoff, prepareIndependentReview, processHumanReviewDecision, redact2 as redactOperatorText, releaseCandidateKey, requireTransition, resolveAgentSelection, resolveHumanReviewDecision, reviewDecisionFor, run, runAuthorizedImplementation, runBoundedRepair, runIndependentReview, runTriage, scheduleBoundedRepair, transferClaudeSession, transferCodexSession, verifyGitHubWebhookSignature };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map