@the-open-engine/zeroshot 6.7.1 → 6.8.0

package/src/attach/socket-paths.js

@@ -0,0 +1,85 @@
+/**
+ * Deterministic attach socket paths.
+ *
+ * Unix-domain sockets have a small path budget (104 bytes on macOS). Keep the
+ * live socket namespace independent from HOME while retaining one namespace
+ * per OS user and Zeroshot home.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const SOCKET_ROOT = process.platform === 'win32' ? null : '/tmp';
+const SOCKET_DIR_MODE = 0o700;
+
+function shortHash(value) {
+  return crypto.createHash('sha256').update(value).digest('hex').slice(0, 16);
+}
+
+function userNamespace() {
+  if (typeof process.getuid === 'function') {
+    return String(process.getuid());
+  }
+  return shortHash(os.userInfo().username);
+}
+
+function resolveHomeDir(env = process.env) {
+  return env.ZEROSHOT_HOME || env.HOME || env.USERPROFILE || os.homedir();
+}
+
+function getSocketDir(homeDir = resolveHomeDir()) {
+  if (process.platform === 'win32') {
+    return path.join(homeDir, '.zeroshot', 'sockets');
+  }
+  return path.join(SOCKET_ROOT, `zeroshot-${userNamespace()}-${shortHash(homeDir)}`);
+}
+
+function assertSafeSocketDir(socketDir) {
+  const stat = fs.lstatSync(socketDir);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Attach socket path is not a directory: ${socketDir}`);
+  }
+  if (typeof process.getuid === 'function' && stat.uid !== process.getuid()) {
+    throw new Error(`Attach socket directory is not owned by the current user: ${socketDir}`);
+  }
+}
+
+function ensureOwnedDirectory(socketDir) {
+  fs.mkdirSync(socketDir, { recursive: true, mode: SOCKET_DIR_MODE });
+  assertSafeSocketDir(socketDir);
+  if (process.platform !== 'win32') {
+    fs.chmodSync(socketDir, SOCKET_DIR_MODE);
+  }
+  return socketDir;
+}
+
+function ensureSocketDir(homeDir = resolveHomeDir()) {
+  const socketDir = getSocketDir(homeDir);
+  return ensureOwnedDirectory(socketDir);
+}
+
+function getTaskSocketPath(taskId, homeDir = resolveHomeDir()) {
+  return path.join(ensureSocketDir(homeDir), `${taskId}.sock`);
+}
+
+function getAgentSocketPath(clusterId, agentId, homeDir = resolveHomeDir()) {
+  const clusterDir = path.join(ensureSocketDir(homeDir), clusterId);
+  ensureOwnedDirectory(clusterDir);
+  return path.join(clusterDir, `${agentId}.sock`);
+}
+
+function getClusterSocketPath(clusterId, homeDir = resolveHomeDir()) {
+  return path.join(ensureSocketDir(homeDir), `${clusterId}.sock`);
+}
+
+module.exports = {
+  SOCKET_DIR_MODE,
+  resolveHomeDir,
+  getSocketDir,
+  ensureSocketDir,
+  getTaskSocketPath,
+  getAgentSocketPath,
+  getClusterSocketPath,
+};

package/src/claude-task-runner.js

@@ -13,6 +13,18 @@ const { normalizeProviderName } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
 const { prepareClaudeConfigDir } = require('./worktree-claude-config');
+const {
+  appendTaskRunModelArgs,
+  wrapTaskRunWithIsolatedSettings,
+} = require('./task-run-model-args');
+
+function rejectCallerSuppliedModelProvenance(options) {
+  if (Object.prototype.hasOwnProperty.call(options, 'modelSpecSource')) {
+    throw new Error(
+      'modelSpecSource is derived from model versus modelLevel/default and cannot be supplied.'
+    );
+  }
+}
 
 function runCommand(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
@@ -112,10 +124,11 @@ class ClaudeTaskRunner extends TaskRunner {
    * Execute a task via zeroshot CLI
    *
    * @param {string} context - Full prompt/context
-   * @param {{agentId?: string, model?: string, outputFormat?: string, jsonSchema?: any, strictSchema?: boolean, cwd?: string, worktreePath?: string|null, isolation?: any}} options - Execution options
+   * @param {{agentId?: string, model?: string, modelLevel?: string, modelSpec?: Object|null, reasoningEffort?: string, outputFormat?: string, jsonSchema?: any, strictSchema?: boolean, cwd?: string, worktreePath?: string|null, isolation?: any}} options - Execution options
    * @returns {Promise<{success: boolean, output: string, error: string|null, taskId?: string}>}
    */
   async run(context, options = {}) {
+    rejectCallerSuppliedModelProvenance(options);
     const {
       agentId = 'unknown',
       provider,
@@ -137,7 +150,7 @@ class ClaudeTaskRunner extends TaskRunner {
       providerName,
       settings
     );
-    const resolvedModelSpec = this._resolveModelSpec({
+    const modelSelection = this._resolveModelSelection({
       explicitModelSpec,
       model,
       reasoningEffort,
@@ -146,13 +159,13 @@ class ClaudeTaskRunner extends TaskRunner {
       providerSettings,
       levelOverrides,
     });
+    const resolvedModelSpec = modelSelection.modelSpec;
 
     // Isolation mode delegates to separate method
     if (isolation?.enabled) {
       return this._runIsolated(context, {
         ...options,
         provider: providerName,
-        modelSpec: resolvedModelSpec,
       });
     }
 
@@ -168,6 +181,7 @@ class ClaudeTaskRunner extends TaskRunner {
       providerName,
       runOutputFormat,
       resolvedModelSpec,
+      modelSpecSource: modelSelection.source,
       jsonSchema,
     });
 
@@ -204,25 +218,74 @@ class ClaudeTaskRunner extends TaskRunner {
     providerSettings,
     levelOverrides,
   }) {
-    if (explicitModelSpec) {
-      if (explicitModelSpec.model) {
-        providerModule.validateModelId(explicitModelSpec.model);
-      }
-      return explicitModelSpec;
-    }
+    return this._resolveModelSelection({
+      explicitModelSpec,
+      model,
+      reasoningEffort,
+      modelLevel,
+      providerModule,
+      providerSettings,
+      levelOverrides,
+    }).modelSpec;
+  }
 
+  _resolveModelSelection({
+    explicitModelSpec,
+    model,
+    reasoningEffort,
+    modelLevel,
+    providerModule,
+    providerSettings,
+    levelOverrides,
+  }) {
     if (model) {
       providerModule.validateModelId(model);
-      return { model, reasoningEffort };
+      return {
+        source: 'direct',
+        modelSpec: { model, reasoningEffort },
+      };
     }
 
-    const level = modelLevel || providerSettings.defaultLevel || providerModule.getDefaultLevel();
-    let resolvedModelSpec = providerModule.resolveModelSpec(level, levelOverrides);
-    if (reasoningEffort) {
-      resolvedModelSpec = { ...resolvedModelSpec, reasoningEffort };
+    if (explicitModelSpec?.model !== undefined) {
+      providerModule.validateModelId(explicitModelSpec.model);
+      return {
+        source: 'direct',
+        modelSpec: explicitModelSpec,
+      };
     }
 
-    return resolvedModelSpec;
+    return {
+      source: 'provider-level',
+      modelSpec: this._resolveProviderLevelModelSpec({
+        explicitModelSpec,
+        modelLevel,
+        reasoningEffort,
+        providerModule,
+        providerSettings,
+        levelOverrides,
+      }),
+    };
+  }
+
+  _resolveProviderLevelModelSpec({
+    explicitModelSpec,
+    modelLevel,
+    reasoningEffort,
+    providerModule,
+    providerSettings,
+    levelOverrides,
+  }) {
+    const level =
+      explicitModelSpec?.level ||
+      modelLevel ||
+      providerSettings.defaultLevel ||
+      providerModule.getDefaultLevel();
+    const resolvedModelSpec = providerModule.resolveModelSpec(level, levelOverrides);
+    const resolvedReasoningEffort = explicitModelSpec?.reasoningEffort || reasoningEffort;
+
+    return resolvedReasoningEffort
+      ? { ...resolvedModelSpec, reasoningEffort: resolvedReasoningEffort }
+      : resolvedModelSpec;
   }
 
   _resolveOutputFormat({ outputFormat, jsonSchema, strictSchema }) {
@@ -232,16 +295,16 @@ class ClaudeTaskRunner extends TaskRunner {
     return jsonSchema && outputFormat === 'json' && !strictSchema ? 'stream-json' : outputFormat;
   }
 
-  _buildRunArgs({ context, providerName, runOutputFormat, resolvedModelSpec, jsonSchema }) {
+  _buildRunArgs({
+    context,
+    providerName,
+    runOutputFormat,
+    resolvedModelSpec,
+    modelSpecSource = 'direct',
+    jsonSchema,
+  }) {
     const args = ['task', 'run', '--output-format', runOutputFormat, '--provider', providerName];
-
-    if (resolvedModelSpec?.model) {
-      args.push('--model', resolvedModelSpec.model);
-    }
-
-    if (resolvedModelSpec?.reasoningEffort) {
-      args.push('--reasoning-effort', resolvedModelSpec.reasoningEffort);
-    }
+    appendTaskRunModelArgs(args, resolvedModelSpec, modelSpecSource);
 
     // Pass schema to CLI only when using json output (strictSchema=true or no conflict)
     if (jsonSchema && runOutputFormat === 'json') {
@@ -542,20 +605,40 @@ class ClaudeTaskRunner extends TaskRunner {
   /**
    * Run task in isolated Docker container
    * @param {string} context
-   * @param {{agentId?: string, model?: string, outputFormat?: string, jsonSchema?: any, strictSchema?: boolean, isolation?: any}} options
+   * @param {{agentId?: string, provider?: string, model?: string, modelLevel?: string, modelSpec?: Object|null, reasoningEffort?: string, outputFormat?: string, jsonSchema?: any, strictSchema?: boolean, isolation?: any}} options
    * @returns {Promise<{success: boolean, output: string, error: string|null}>}
    */
   _runIsolated(context, options) {
+    rejectCallerSuppliedModelProvenance(options);
     const {
       agentId = 'unknown',
       provider = 'claude',
-      modelSpec = null,
+      model = null,
+      modelLevel = null,
+      modelSpec: explicitModelSpec = null,
+      reasoningEffort = null,
       outputFormat = 'stream-json',
       jsonSchema = null,
       strictSchema = false,
       isolation,
     } = options;
     const { manager, clusterId } = isolation;
+    const settings = loadSettings();
+    const { providerModule, providerSettings, levelOverrides } = this._getProviderContext(
+      provider,
+      settings
+    );
+    const modelSelection = this._resolveModelSelection({
+      explicitModelSpec,
+      model,
+      reasoningEffort,
+      modelLevel,
+      providerModule,
+      providerSettings,
+      levelOverrides,
+    });
+    const modelSpec = modelSelection.modelSpec;
+    const modelSpecSource = modelSelection.source;
 
     this._log(`📦 [${agentId}]: Running task in isolated container...`);
 
@@ -565,7 +648,7 @@ class ClaudeTaskRunner extends TaskRunner {
         ? 'stream-json'
         : desiredOutputFormat;
 
-    const command = [
+    let command = [
       'zeroshot',
       'task',
       'run',
@@ -575,13 +658,7 @@ class ClaudeTaskRunner extends TaskRunner {
       provider,
     ];
 
-    if (modelSpec?.model) {
-      command.push('--model', modelSpec.model);
-    }
-
-    if (modelSpec?.reasoningEffort) {
-      command.push('--reasoning-effort', modelSpec.reasoningEffort);
-    }
+    appendTaskRunModelArgs(command, modelSpec, modelSpecSource);
 
     if (jsonSchema && runOutputFormat === 'json') {
       command.push('--json-schema', JSON.stringify(jsonSchema));
@@ -597,16 +674,23 @@ class ClaudeTaskRunner extends TaskRunner {
     }
 
     command.push(finalContext);
+    command = wrapTaskRunWithIsolatedSettings(command, {
+      providerName: provider,
+      settings,
+      modelSpecSource,
+      modelSpec,
+    });
 
     return new Promise((resolve, reject) => {
       let output = '';
       let resolved = false;
 
       const proc = manager.spawnInContainer(clusterId, command, {
-        env:
-          provider === 'claude' && modelSpec?.model
+        env: {
+          ...(provider === 'claude' && modelSpec?.model
             ? { ANTHROPIC_MODEL: modelSpec.model, ZEROSHOT_BLOCK_ASK_USER: '1' }
-            : {},
+            : {}),
+        },
       });
 
       proc.stdout.on('data', (/** @type {Buffer} */ data) => {

package/src/config-validator.js

@@ -2053,8 +2053,8 @@ function validateProviderSettings(provider, providerSettings) {
         `Invalid model override (must be non-empty string) for provider "${provider}"`
       );
     }
-    if (override?.model) {
-      providerModule.validateModelId(override.model);
+    if (override?.model || (provider === 'opencode' && override?.model === '')) {
+      providerModule.resolveModelSpec(level, { [level]: override });
     }
     if (override?.reasoningEffort && !providerSupportsCapability(provider, 'reasoningEffort')) {
       throw new Error(

package/src/isolation-manager.js

@@ -28,6 +28,7 @@ const { readRepoSettings } = require('../lib/repo-settings');
 const { provisionClaudeCredentials } = require('./claude-credentials');
 
 const DEFAULT_WORKTREE_SETUP_TIMEOUT_MS = 15 * 60 * 1000;
+const FRESH_BASE_REF_PREFIX = 'refs/zeroshot/base-fetch';
 
 function runSync(command, args, options = {}) {
   const timeout = options.timeout ?? 30000;
@@ -48,6 +49,61 @@ function runShellSync(command, options = {}) {
   return runSync('/bin/bash', ['-lc', command], options);
 }
 
+function resolveCommit(repoRoot, ref) {
+  return runSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: 'pipe',
+  }).trim();
+}
+
+function deleteTemporaryBaseRef(repoRoot, temporaryRef) {
+  try {
+    runSync('git', ['update-ref', '-d', temporaryRef], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    console.warn(
+      `[IsolationManager] Warning: failed to remove temporary base ref ${temporaryRef}: ${err.message}`
+    );
+  }
+}
+
+function fetchFreshRemoteBase(repoRoot, remoteName, branch) {
+  const temporaryRef = `${FRESH_BASE_REF_PREFIX}/${crypto.randomBytes(16).toString('hex')}`;
+
+  try {
+    runSync(
+      'git',
+      [
+        'fetch',
+        '--atomic',
+        '--no-tags',
+        '--no-write-fetch-head',
+        '--refmap=',
+        '--',
+        remoteName,
+        `+refs/heads/${branch}:${temporaryRef}`,
+      ],
+      {
+        cwd: repoRoot,
+        encoding: 'utf8',
+        stdio: 'pipe',
+      }
+    );
+
+    return {
+      baseSha: resolveCommit(repoRoot, temporaryRef),
+      temporaryRef,
+    };
+  } catch (err) {
+    deleteTemporaryBaseRef(repoRoot, temporaryRef);
+    throw err;
+  }
+}
+
 function expandHomePath(value) {
   if (!value) return value;
   if (value === '~') return os.homedir();
@@ -127,7 +183,7 @@ class IsolationManager {
     this.containers = new Map(); // clusterId -> containerId
     this.isolatedDirs = new Map(); // clusterId -> { path, originalDir }
     this.clusterConfigDirs = new Map(); // clusterId -> configDirPath
-    this.worktrees = new Map(); // clusterId -> { path, branch, repoRoot }
+    this.worktrees = new Map(); // clusterId -> { path, branch, repoRoot, baseRef, baseSha }
     this._exitWatchers = new Map(); // clusterId -> ChildProcess
   }
 
@@ -1443,7 +1499,7 @@ class IsolationManager {
    * Creates a git worktree at ~/.zeroshot/worktrees/{clusterId}
    * @param {string} clusterId - Cluster ID
    * @param {string} workDir - Original working directory (must be a git repo)
-   * @returns {{ path: string, branch: string, repoRoot: string }}
+   * @returns {{ path: string, branch: string, repoRoot: string, baseRef: string, baseSha: string }}
    */
   createWorktreeIsolation(clusterId, workDir, options = {}) {
     if (!this._isGitRepo(workDir)) {
@@ -1485,8 +1541,10 @@ class IsolationManager {
    * @param {string} workDir - Original working directory
    * @param {object} [options] - Worktree creation options
    * @param {string} [options.baseRef] - Git ref to base the worktree branch on
+   * @param {string} [options.remoteName=origin] - Remote used by a remote base ref
+   * @param {boolean} [options.requireFreshBase=false] - Require a freshly fetched remote base
    * @param {number} [options.worktreeSetupTimeoutMs] - Setup command timeout in milliseconds
-   * @returns {{ path: string, branch: string, repoRoot: string }}
+   * @returns {{ path: string, branch: string, repoRoot: string, baseRef: string, baseSha: string }}
    */
   createWorktree(clusterId, workDir, options = {}) {
     const repoRoot = this._getGitRoot(workDir);
@@ -1560,20 +1618,42 @@ class IsolationManager {
     }
     const worktreeSetupTimeoutMs = resolveWorktreeSetupTimeoutMs(repoSettings, options);
 
-    // Best-effort ensure origin/<branch> exists locally if requested.
-    if (worktreeBaseRef && worktreeBaseRef.startsWith('origin/')) {
-      const branch = worktreeBaseRef.slice('origin/'.length);
-      try {
-        runSync('git', ['fetch', 'origin', branch], {
-          cwd: repoRoot,
-          encoding: 'utf8',
-          stdio: 'pipe',
-        });
-      } catch {
-        // ignore
+    const baseRef = worktreeBaseRef || 'HEAD';
+    const remoteName = options.remoteName || 'origin';
+    let baseSha;
+    let temporaryBaseRef = null;
+
+    if (worktreeBaseRef && worktreeBaseRef.startsWith(`${remoteName}/`)) {
+      const branch = worktreeBaseRef.slice(remoteName.length + 1);
+      const remoteTrackingRef = `refs/remotes/${remoteName}/${branch}`;
+
+      if (options.requireFreshBase === true) {
+        const freshBase = fetchFreshRemoteBase(repoRoot, remoteName, branch);
+        baseSha = freshBase.baseSha;
+        temporaryBaseRef = freshBase.temporaryRef;
+      } else {
+        try {
+          runSync(
+            'git',
+            ['fetch', '--no-tags', '--', remoteName, `+refs/heads/${branch}:${remoteTrackingRef}`],
+            {
+              cwd: repoRoot,
+              encoding: 'utf8',
+              stdio: 'pipe',
+            }
+          );
+        } catch {
+          // Repository worktree settings historically allowed an offline cached remote ref.
+        }
+        baseSha = resolveCommit(repoRoot, remoteTrackingRef);
       }
+    } else {
+      baseSha = resolveCommit(repoRoot, baseRef);
     }
 
+    console.log(`[IsolationManager] Worktree base ref: ${baseRef}`);
+    console.log(`[IsolationManager] Worktree base commit: ${baseSha}`);
+
     // Create branch name from cluster ID (e.g., cluster-cosmic-meteor-87 -> zeroshot/cosmic-meteor-87)
     const baseBranchName = `zeroshot/${clusterId.replace(/^cluster-/, '')}`;
     let branchName = baseBranchName;
@@ -1581,44 +1661,18 @@ class IsolationManager {
     // Worktree path in persistent location (survives reboots)
     const worktreePath = path.join(os.homedir(), '.zeroshot', 'worktrees', clusterId);
 
-    // Ensure parent directory exists
-    const parentDir = path.dirname(worktreePath);
-    if (!fs.existsSync(parentDir)) {
-      fs.mkdirSync(parentDir, { recursive: true });
-    }
-
-    // Best-effort cleanup of stale worktree metadata and directory.
-    // IMPORTANT: If a previous run deleted the directory without deregistering the worktree,
-    // git may keep the branch "checked out" and block deletion/reuse.
     try {
-      runSync('git', ['worktree', 'remove', '--force', worktreePath], {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: 'pipe',
-      });
-    } catch {
-      // ignore
-    }
-    try {
-      runSync('git', ['worktree', 'prune'], { cwd: repoRoot, encoding: 'utf8', stdio: 'pipe' });
-    } catch {
-      // ignore
-    }
-    try {
-      fs.rmSync(worktreePath, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-
-    const baseRef = worktreeBaseRef || 'HEAD';
-    console.log(`[IsolationManager] Worktree base ref: ${baseRef}`);
-    console.log(`[IsolationManager] Worktree path: ${worktreePath}`);
+      // Ensure parent directory exists
+      const parentDir = path.dirname(worktreePath);
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
 
-    // Create worktree with new branch based on baseRef (retry on branch collision/in-use)
-    for (let attempt = 0; attempt < 10; attempt++) {
-      // Best-effort delete if branch exists and is not in use by another worktree.
+      // Best-effort cleanup of stale worktree metadata and directory.
+      // IMPORTANT: If a previous run deleted the directory without deregistering the worktree,
+      // git may keep the branch "checked out" and block deletion/reuse.
       try {
-        runSync('git', ['branch', '-D', branchName], {
+        runSync('git', ['worktree', 'remove', '--force', worktreePath], {
           cwd: repoRoot,
           encoding: 'utf8',
           stdio: 'pipe',
@@ -1626,38 +1680,72 @@ class IsolationManager {
       } catch {
         // ignore
       }
-
       try {
-        runSync('git', ['worktree', 'add', '-b', branchName, worktreePath, baseRef], {
+        runSync('git', ['worktree', 'prune'], {
           cwd: repoRoot,
           encoding: 'utf8',
           stdio: 'pipe',
         });
-        console.log(`[IsolationManager] Worktree setup phase: created branch ${branchName}`);
-        break;
-      } catch (err) {
-        const stderr = (
-          err && (err.stderr || err.message) ? String(err.stderr || err.message) : ''
-        ).toLowerCase();
-        const isBranchCollision =
-          stderr.includes('already exists') ||
-          stderr.includes('cannot delete branch') ||
-          stderr.includes('checked out');
-
-        if (attempt < 9 && isBranchCollision) {
-          branchName = `${baseBranchName}-${crypto.randomBytes(3).toString('hex')}`;
-          try {
-            runSync('git', ['worktree', 'prune'], {
-              cwd: repoRoot,
-              encoding: 'utf8',
-              stdio: 'pipe',
-            });
-          } catch {
-            // ignore
+      } catch {
+        // ignore
+      }
+      try {
+        fs.rmSync(worktreePath, { recursive: true, force: true });
+      } catch {
+        // ignore
+      }
+
+      console.log(`[IsolationManager] Worktree path: ${worktreePath}`);
+
+      // Create worktree with new branch based on baseRef (retry on branch collision/in-use)
+      for (let attempt = 0; attempt < 10; attempt++) {
+        // Best-effort delete if branch exists and is not in use by another worktree.
+        try {
+          runSync('git', ['branch', '-D', branchName], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: 'pipe',
+          });
+        } catch {
+          // ignore
+        }
+
+        try {
+          runSync('git', ['worktree', 'add', '-b', branchName, worktreePath, baseSha], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            stdio: 'pipe',
+          });
+          console.log(`[IsolationManager] Worktree setup phase: created branch ${branchName}`);
+          break;
+        } catch (err) {
+          const stderr = (
+            err && (err.stderr || err.message) ? String(err.stderr || err.message) : ''
+          ).toLowerCase();
+          const isBranchCollision =
+            stderr.includes('already exists') ||
+            stderr.includes('cannot delete branch') ||
+            stderr.includes('checked out');
+
+          if (attempt < 9 && isBranchCollision) {
+            branchName = `${baseBranchName}-${crypto.randomBytes(3).toString('hex')}`;
+            try {
+              runSync('git', ['worktree', 'prune'], {
+                cwd: repoRoot,
+                encoding: 'utf8',
+                stdio: 'pipe',
+              });
+            } catch {
+              // ignore
+            }
+            continue;
           }
-          continue;
+          throw err;
         }
-        throw err;
+      }
+    } finally {
+      if (temporaryBaseRef) {
+        deleteTemporaryBaseRef(repoRoot, temporaryBaseRef);
       }
     }
 
@@ -1684,6 +1772,8 @@ class IsolationManager {
       path: worktreePath,
       branch: branchName,
       repoRoot,
+      baseRef,
+      baseSha,
     };
   }