@yemi33/minions 0.1.2382 → 0.1.2384

package/engine.js

@@ -34,14 +34,20 @@ const shared = require('./engine/shared');
 const { exec, execAsync, execSilent, runFile, ts, ENGINE_DEFAULTS,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT, AGENT_STATUS,
   FAILURE_CLASS, resolvePollFlag } = shared;
-const { resolveRuntime } = require('./engine/runtimes');
-const { assertStaleHeadOk, preApproveWorkspaceMcps } = require('./engine/spawn-agent');
+const {
+  resolveRuntime,
+  resolveInvocationOptions,
+  buildSpawnFlags,
+  prepareWorkspace,
+} = require('./engine/runtimes');
+const { assertStaleHeadOk } = require('./engine/spawn-agent');
 // P-1d8f0b93 — fleet ACP worker pool + its child_process-shaped facade.
 // NOTE: engine/agent-worker-pool.js is a DIFFERENT module from the
 // dashboard's single-tab CC pool (engine.js must never import that one —
 // see the cc-tab-pool wiring regression guard test).
 const agentWorkerPool = require('./engine/agent-worker-pool');
 const { PooledAgentProcess } = require('./engine/pooled-agent-process');
+const { normalizeExecutionModel } = require('./engine/execution-model');
 const adoGitAuth = require('./engine/ado-git-auth');
 const queries = require('./engine/queries');
 const dispatchEvents = require('./engine/dispatch-events');
@@ -436,22 +442,26 @@ function _maxTurnsForType(type, engineConfig = {}) {
 // ─── Runtime adapter integration (P-2a6d9c4f) ────────────────────────────────
 
 function _buildAgentSpawnFlags(runtime, opts = {}) {
-  if (runtime && typeof runtime.buildSpawnFlags === 'function') return runtime.buildSpawnFlags(opts);
-  const caps = (runtime && runtime.capabilities) || {};
-  const flags = ['--runtime', String(runtime?.name || 'claude')];
-  if (opts.maxTurns != null) flags.push('--max-turns', String(opts.maxTurns));
-  if (opts.model) flags.push('--model', String(opts.model));
-  if (opts.allowedTools) flags.push('--allowedTools', String(opts.allowedTools));
-  if (caps.effortLevels && opts.effort) flags.push('--effort', String(opts.effort));
-  if (caps.sessionResume && opts.sessionId) flags.push('--resume', String(opts.sessionId));
-  if (caps.budgetCap && opts.maxBudget != null) flags.push('--max-budget-usd', String(opts.maxBudget));
-  if (caps.bareMode && opts.bare === true) flags.push('--bare');
-  if (caps.fallbackModel && opts.fallbackModel) flags.push('--fallback-model', String(opts.fallbackModel));
-  if (opts.stream != null && opts.stream !== '') flags.push('--stream', String(opts.stream));
-  if (opts.disableBuiltinMcps === true) flags.push('--disable-builtin-mcps');
-  if (opts.reasoningSummaries === true) flags.push('--enable-reasoning-summaries');
-
-  return flags;
+  return buildSpawnFlags(runtime, opts);
+}
+
+function _syncAgentWorkerPoolConfig(engineConfig = {}) {
+  const enabled = (engineConfig.agentUseWorkerPool ?? ENGINE_DEFAULTS.agentUseWorkerPool) === true;
+  agentWorkerPool.setEnabled(enabled);
+  if (enabled) agentWorkerPool.setPoolSize(shared.resolveAgentAcpPoolSize(engineConfig));
+  return enabled;
+}
+
+function _resolveAgentPoolProcessCwd(project, engineConfig) {
+  const scratchRoot = shared.resolveAgentTempBaseDir(project, engineConfig, MINIONS_DIR)
+    || path.join(os.tmpdir(), 'minions-agent-temp');
+  const processCwd = path.join(
+    scratchRoot,
+    'acp-workers',
+    shared.safeSlugComponent(project?.name || project?.repoName || 'project')
+  );
+  fs.mkdirSync(processCwd, { recursive: true });
+  return processCwd;
 }
 
 function _runtimeLogger() {
@@ -603,10 +613,48 @@ function captureSessionIdFromStdoutChunk(agentId, dispatchId, branchName, runtim
         logger: _runtimeLogger(),
       });
     }
+
     return;
   }
 }
 
+function _runtimeModelFromOutputLine(runtime, line) {
+  if (!runtime || typeof runtime.parseOutput !== 'function') return null;
+  try {
+    return normalizeExecutionModel(runtime.parseOutput(String(line), { maxTextLength: 0 })?.model);
+  } catch {
+    return null;
+  }
+}
+
+function captureExecutionModelFromStdoutChunk(dispatchItem, dispatchId, runtime, procInfo, chunk, state) {
+  if (!procInfo || procInfo.executionModel || !chunk) return null;
+  const text = String(state.modelLineBuffer || '') + String(chunk);
+  const lines = text.split('\n');
+  state.modelLineBuffer = /[\r\n]$/.test(text) ? '' : (lines.pop() || '');
+  if (state.modelLineBuffer.length > 65536) state.modelLineBuffer = '';
+
+  for (const line of lines) {
+    const model = _runtimeModelFromOutputLine(runtime, line);
+    if (!model) continue;
+    procInfo.executionModel = model;
+    dispatchItem.executionModel = model;
+    try {
+      mutateDispatch((dispatch) => {
+        for (const section of ['pending', 'active']) {
+          const item = (dispatch[section] || []).find(entry => entry.id === dispatchId);
+          if (item) item.executionModel = model;
+        }
+        return dispatch;
+      });
+    } catch (err) {
+      log('warn', `Could not persist runtime model for ${dispatchId}: ${err.message}`);
+    }
+    return model;
+  }
+  return null;
+}
+
 function mergePendingSteeringEntries(...groups) {
   const merged = [];
   const seen = new Set();
@@ -905,16 +953,14 @@ function _isTransientGitNetworkError(err) {
 }
 
 // Wraps shellSafeGit(['fetch', ...]) with a single retry on transient
-// network errors. Preserves the pre-fix convention that fetch failures
-// are NON-fatal here: we log + swallow the terminal error so the caller
-// falls back to the local ref. The retry just gives transient errors one
-// shot to recover before that fallback kicks in — empirically eliminates
-// most "couldn't find remote ref" cascades downstream caused by a 0-second
-// network blip during the initial fetch.
+// network errors. Most existing callers keep the historical non-fatal
+// behavior and receive false on terminal failure. Callers that cannot safely
+// use a stale local ref (ordinary fresh-branch creation) pass throwOnFailure
+// so the terminal git error remains available for accurate classification.
 //
 // `args` is the array passed to git AFTER 'fetch' (e.g. ['origin', branch]).
 // `label` is a short string used in the log line for triage.
-async function _fetchWithTransientRetry(args, opts, label) {
+async function _fetchWithTransientRetry(args, opts, label, { throwOnFailure = false } = {}) {
   const _attempt = async () => shared.shellSafeGit(['fetch', ...args], opts);
   try {
     await _attempt();
@@ -930,6 +976,7 @@ async function _fetchWithTransientRetry(args, opts, label) {
       // incident. _redactBearer keeps any bearer header echoed in the failing
       // git command out of engine logs.
       log('warn', `git fetch ${label}: ${adoGitAuth.redactBearer(String(e.message || e))}`);
+      if (throwOnFailure) throw e;
       return false; // swallow non-transient — caller falls back to local ref
     }
     const transientMsg = adoGitAuth.redactBearer(String(e.message || e));
@@ -941,19 +988,30 @@ async function _fetchWithTransientRetry(args, opts, label) {
       return true;
     } catch (e2) {
       const retryMsg = adoGitAuth.redactBearer(String(e2.message || e2));
-      log('warn', `git fetch ${label}: retry also failed (${retryMsg}) — falling back to local ref`);
+      log('warn', `git fetch ${label}: retry also failed (${retryMsg})${throwOnFailure ? ' — surfacing error' : ' — falling back to local ref'}`);
+      if (throwOnFailure) throw e2;
       return false;
     }
   }
 }
 
-// W-mr3tayu4 — thin wrapper around shared.removeStaleIndexLock. The age-gated
-// (>300000ms) stale-lock removal now lives in engine/shared.js so both the
-// worktree-add retry paths here and engine/live-checkout.js#prepareLiveCheckout
-// share one implementation (no circular import). Kept as a named local because
-// three internal call sites and the test harness reference `removeStaleIndexLock`.
-function removeStaleIndexLock(rootDir) {
-  return shared.removeStaleIndexLock(rootDir);
+function _classifyFreshBaseFetchFailure(err) {
+  return adoGitAuth.isAdoAuthFailure(err)
+    ? FAILURE_CLASS.AUTH
+    : FAILURE_CLASS.NETWORK_ERROR;
+}
+
+async function _probeBranchLocally(rootDir, branchName, gitOpts) {
+  try {
+    await shared.shellSafeGit(
+      ['rev-parse', '--verify', '--quiet', `refs/heads/${branchName}`],
+      { ...gitOpts, cwd: rootDir, timeout: 10000 },
+    );
+    return true;
+  } catch (e) {
+    if (e?.code === 1) return false;
+    throw e;
+  }
 }
 
 async function runWorktreeAdd(rootDir, worktreePath, addArgs, gitOpts, worktreeCreateRetries) {
@@ -970,7 +1028,6 @@ async function runWorktreeAdd(rootDir, worktreePath, addArgs, gitOpts, worktreeC
     try {
       if (attempt > 0) {
         try { await shared.shellSafeGit(['worktree', 'prune'], { ...gitOpts, cwd: rootDir, timeout: 15000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-        removeStaleIndexLock(rootDir);
         log('warn', `Retrying git worktree add (attempt ${attempt + 1}/${retries + 1}) for ${path.basename(worktreePath)}`);
       }
       await shared.shellSafeGit(['worktree', 'add', worktreePath, ...addArgs], { ...gitOpts, cwd: rootDir });
@@ -2315,7 +2372,6 @@ async function spawnAgent(dispatchItem, config) {
   // (large prompts are written to engine/contexts/<id>.md to keep dispatch rows
   // small — see shared.sidecarDispatchPrompt / #1167).
   let taskPrompt = shared.resolveDispatchPrompt(dispatchItem);
-  const claudeConfig = config.claude || {};
   const engineConfig = config.engine || {};
   const startedAt = ts();
   // Phase timing — raw timestamps, emitted as one structured `[spawn-timing]`
@@ -2341,8 +2397,12 @@ async function spawnAgent(dispatchItem, config) {
     updateAgentStatus(id, AGENT_STATUS.FAILED, err.message);
     throw err;
   }
-  const metaProjectFields = metaProject && typeof metaProject === 'object' ? metaProject : {};
-  const project = projectResolution.project ? { ...projectResolution.project, ...metaProjectFields } : {};
+  // Persisted dispatch metadata is an identity hint only. Never merge stale
+  // checkout configuration back into the current configured project.
+  const project = projectResolution.project ? { ...projectResolution.project } : {};
+  const configuredProjects = getProjects(config);
+  const assertSafeWorktreePath = (candidate) =>
+    shared.assertWorktreeOutsideProjects(candidate, configuredProjects);
 
   // ── Workspace manifest repo gate (W-mq07avbk000m5543) ────────────────────
   // Dispatch-time enforcement of `agents.<id>.workspace_manifest.allowed_repos`.
@@ -2376,19 +2436,14 @@ async function spawnAgent(dispatchItem, config) {
 
   // W-mp73x32w000l143d: decouple agent cwd from worktree placement.
   // resolveSpawnPaths returns:
-  //   - read-only types: { cwd: <project dir or MINIONS_DIR>, worktreeRootDir: null }
-  //     (no drive-root preflight — these tasks don't need a worktree)
+  //   - project-bound read-only types: detached worktree placement
+  //   - project-less read-only types: { cwd: MINIONS_DIR, worktreeRootDir: null }
   //   - code-mutating types: { cwd: null, worktreeRootDir: <project root> }
   //     (caller defaults cwd to worktreeRootDir; drive-root collapse throws
   //     WORKTREE_ROOTDIR_COLLAPSED_TO_DRIVE_ROOT — same fail-fast behavior as
   //     the legacy resolveProjectRootDir call this replaced).
-  // W-mp8ho6w500034a58: read-only task types (meeting/ask/explore/plan/plan-to-prd)
-  // never need a worktree — even when carrying a pipeline branch. Pipeline branches
-  // on read-only stages are a no-op label; the stage doesn't commit anything, so
-  // the worktree had no functional purpose and was only there to absorb a drive-
-  // root preflight that fired against MINIONS_DIR's parent. Read-only pipeline
-  // stages now short-circuit alongside any other read-only WI (see the gate at
-  // `if (branchName && READ_ONLY_ROOT_TASK_TYPES.has(type))` below).
+  // Pipeline branch labels remain irrelevant to read-only tasks, so they are
+  // discarded before detached placement.
   const _preBranchName = meta?.branch ? sanitizeBranch(meta.branch) : null;
 
   // ── Per-WI meta.workdir override (P-714ef144) ─────────────────────────
@@ -2435,9 +2490,10 @@ async function spawnAgent(dispatchItem, config) {
   }
   const validatedWorkdir = _wdValidation.value;  // null when unset / empty
 
-  let cwd, worktreeRootDir, liveMode = false;
+  let cwd, worktreeRootDir, liveMode = false, readOnlyWorktree = false;
   try {
-    ({ cwd, worktreeRootDir, liveMode = false } = shared.resolveSpawnPaths(project, type, MINIONS_DIR, { workdir: validatedWorkdir }));
+    ({ cwd, worktreeRootDir, liveMode = false, readOnlyWorktree = false } =
+      shared.resolveSpawnPaths(project, type, MINIONS_DIR, { workdir: validatedWorkdir }));
   } catch (rootErr) {
     if (rootErr?.code === 'WORKTREE_ROOTDIR_COLLAPSED_TO_DRIVE_ROOT' || rootErr?.code === 'WORKTREE_ROOTDIR_MISSING_BASE') {
       log('error', `spawnAgent: project rootDir resolution failed for ${id}: ${rootErr.message}`);
@@ -2486,6 +2542,29 @@ async function spawnAgent(dispatchItem, config) {
     }
     throw rootErr;
   }
+  const checkoutModeAtDispatch = liveMode
+    ? shared.CHECKOUT_MODES.LIVE
+    : shared.CHECKOUT_MODES.WORKTREE;
+  const resolvedProjectMeta = project?.name || project?.localPath
+    ? { name: project.name, localPath: project.localPath }
+    : null;
+  dispatchItem.checkoutMode = checkoutModeAtDispatch;
+  if (resolvedProjectMeta && dispatchItem.meta) {
+    dispatchItem.meta.project = resolvedProjectMeta;
+  }
+  try {
+    mutateDispatch((dispatch) => {
+      for (const queue of ['pending', 'active']) {
+        const found = (dispatch?.[queue] || []).find(d => d && d.id === id);
+        if (!found) continue;
+        found.checkoutMode = checkoutModeAtDispatch;
+        if (resolvedProjectMeta && found.meta) found.meta.project = resolvedProjectMeta;
+      }
+      return dispatch;
+    });
+  } catch (e) {
+    log('warn', `spawnAgent: failed to persist checkout context for ${id}: ${e.message}`);
+  }
   // Legacy local alias: downstream git ops (worktree add, prune, fetch) and
   // the `cwd === rootDir` safety warn at line ~1387 reference `rootDir`. For
   // read-only rootless tasks (no worktree, no branch) this is null — the
@@ -2583,6 +2662,28 @@ async function spawnAgent(dispatchItem, config) {
     });
   } catch (e) { log('warn', `spawnAgent: failed to persist tmpDir for ${id}: ${e.message}`); }
   const _cleanupPromptFiles = () => { shared.removeDispatchTmpDir(dispatchTmpDir); };
+  const _failWorktreeRemotePreparation = (remoteErr, reasonContext, unavailableContext) => {
+    const classificationErr = remoteErr?._probeFailed && remoteErr._cause
+      ? remoteErr._cause
+      : remoteErr;
+    const failureClass = _classifyFreshBaseFetchFailure(classificationErr);
+    const safeRemoteError = adoGitAuth.redactBearer(String(remoteErr?.message || remoteErr));
+    const reason = `${failureClass.toUpperCase().replace(/-/g, '_')}: ${reasonContext}: ${safeRemoteError}`;
+    log('error', `spawnAgent: ${reason}`);
+    _cleanupPromptFiles();
+    completeDispatch(
+      id,
+      DISPATCH_RESULT.ERROR,
+      reason.slice(0, 800),
+      `No worktree or agent was started. The work item remains retryable and will not count against the selected agent because ${unavailableContext}.`,
+      {
+        failureClass,
+        agentRetryable: true,
+        countAgentRetryFailure: false,
+      },
+    );
+    cleanupTempAgent(agentId);
+  };
   // Convert a WORKTREE_NESTED_IN_PROJECT throw into a fail-fast non-retryable
   // dispatch failure (W-mp62taw2000ubcc3). The error's `.code` is set by
   // shared.assertWorktreeOutsideProject so we don't have to parse the message.
@@ -2683,17 +2784,11 @@ async function spawnAgent(dispatchItem, config) {
   _phaseT.afterPrompt = Date.now();
 
   if (branchName && READ_ONLY_ROOT_TASK_TYPES.has(type)) {
-    // W-mp7havqf0007ce6b: read-only types (meeting/ask/explore/plan/plan-to-prd)
-    // short-circuit BEFORE the worktree-creation block. resolveSpawnPaths returns
-    // worktreeRootDir=null for read-only types, and path.resolve(null, ...) throws
-    // ("paths[0] must be of type string. Received null"). Pipeline branches used
-    // to be exempt — they don't need to be (W-mp8ho6w500034a58): read-only stages
-    // never commit, so a pipeline-branch label is meaningless for them and the
-    // forced worktree only existed to feed the drive-root preflight that this
-    // short-circuit now correctly avoids.
-    log('info', `${type}: read-only task with branch ${branchName} — skipping worktree, running in cwd ${cwd}`);
+    // Read-only dispatches never own a branch. Project-bound worktree-mode
+    // dispatches still get a detached worktree below; project-less/live tasks
+    // keep their resolved cwd.
+    log('info', `${type}: ignoring branch label ${branchName} for read-only dispatch`);
     branchName = null;
-    worktreePath = null;
   }
 
   // ── Live-checkout mode handling (P-a3f9b204) ─────────────────────────────
@@ -3452,6 +3547,55 @@ async function spawnAgent(dispatchItem, config) {
     }
   }
 
+  const needsDetachedProjectWorktree = !liveMode && !!rootDir && !!project?.localPath && !branchName;
+  if (needsDetachedProjectWorktree) {
+    const detachedKind = readOnlyWorktree ? 'read-only' : 'branchless';
+    updateAgentStatus(id, AGENT_STATUS.WORKTREE_SETUP, `Setting up detached ${detachedKind} worktree for ${project.name || 'project'}`);
+    const wtDirName = shared.buildWorktreeDirName({
+      dispatchId: id,
+      projectName: project.name || 'default',
+      branchName: detachedKind,
+    });
+    const worktreeRoot = path.resolve(rootDir, engineConfig.worktreeRoot || '../worktrees');
+    worktreePath = path.resolve(worktreeRoot, wtDirName);
+    try {
+      assertSafeWorktreePath(worktreePath);
+      if (fs.existsSync(worktreePath)) {
+        shared.removeWorktree(worktreePath, rootDir, worktreeRoot, { excludeDispatchId: id });
+      }
+      const mainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+      await runWorktreeAdd(
+        rootDir,
+        worktreePath,
+        ['--detach', mainRef],
+        _worktreeGitOpts,
+        worktreeCreateRetries,
+      );
+      cwd = worktreePath;
+      log('info', `${type}: running in detached ${detachedKind} worktree ${worktreePath}; operator checkout ${project.localPath} is protected`);
+    } catch (readOnlyWtErr) {
+      try {
+        if (worktreePath && fs.existsSync(worktreePath)) {
+          shared.removeWorktree(worktreePath, rootDir, worktreeRoot, { excludeDispatchId: id });
+        }
+      } catch (cleanupErr) {
+        log('warn', `read-only worktree cleanup failed for ${id}: ${cleanupErr.message}`);
+      }
+      const summary = `Detached ${detachedKind} worktree setup failed: ${readOnlyWtErr.message}`;
+      log('error', `spawnAgent: ${summary}`);
+      _cleanupPromptFiles();
+      completeDispatch(
+        id,
+        DISPATCH_RESULT.ERROR,
+        summary.slice(0, 800),
+        'The operator checkout was not used. Fix the worktree setup failure and retry.',
+        { failureClass: FAILURE_CLASS.WORKTREE_PREFLIGHT, agentRetryable: true },
+      );
+      cleanupTempAgent(agentId);
+      return null;
+    }
+  }
+
   if (branchName && !liveMode) {
     updateAgentStatus(id, AGENT_STATUS.WORKTREE_SETUP, `Setting up worktree for branch ${branchName}`);
     // W-mpwy3mp5 (#2996): track whether we ended up reusing an existing
@@ -3469,7 +3613,7 @@ async function spawnAgent(dispatchItem, config) {
     // nested worktrees cause glob/grep to match both copies (mirror writes).
     // WORKTREE_NESTED_IN_PROJECT is non-retryable: the recompute on the next
     // tick will produce the same path. Fail fast (W-mp62taw2000ubcc3).
-    try { shared.assertWorktreeOutsideProject(worktreePath, rootDir); }
+    try { assertSafeWorktreePath(worktreePath); }
     catch (assertErr) {
       if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
       throw assertErr;
@@ -3483,7 +3627,7 @@ async function spawnAgent(dispatchItem, config) {
       // Same guard for reuse — a previously-created bad worktree must not
       // be silently reused either; the cleanup sweep flags these so the
       // operator can remove them.
-      try { shared.assertWorktreeOutsideProject(existingWt, rootDir); }
+      try { assertSafeWorktreePath(existingWt); }
       catch (assertErr) {
         if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
         throw assertErr;
@@ -3535,7 +3679,7 @@ async function spawnAgent(dispatchItem, config) {
         if (!_branchOnRemote) {
           const borrowed = worktreePool.tryBorrow(_poolProject, id);
           if (borrowed && borrowed.path && fs.existsSync(borrowed.path)) {
-            try { shared.assertWorktreeOutsideProject(borrowed.path, rootDir); }
+            try { assertSafeWorktreePath(borrowed.path); }
             catch (assertErr) {
               // Always evict before deciding what to do — leaves no BORROWED
               // orphan tied to a dispatch that won't complete normally.
@@ -3597,9 +3741,6 @@ async function spawnAgent(dispatchItem, config) {
           const isSharedBranch = meta?.branchStrategy === 'shared-branch' || meta?.useExistingBranch;
           // Prune stale worktree entries before creating (handles leftover entries from crashed runs)
           try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-          // Remove stale index.lock before creating worktree (Windows crashes can leave this behind)
-          removeStaleIndexLock(rootDir);
-
           if (isSharedBranch) {
             log('info', `Creating worktree for shared branch: ${worktreePath} on ${branchName}`);
             await _fetchWithTransientRetry(['origin', branchName], { ..._gitOpts, cwd: rootDir }, `origin/${branchName} (shared-branch pre-create)`);
@@ -3609,7 +3750,7 @@ async function spawnAgent(dispatchItem, config) {
               if (eShared.message?.includes('already used by worktree') || eShared.message?.includes('already checked out')) {
                 const existingWtPath = await findExistingWorktree(rootDir, branchName);
                 if (existingWtPath && fs.existsSync(existingWtPath)) {
-                  try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
+                  try { assertSafeWorktreePath(existingWtPath); }
                   catch (assertErr) {
                     if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
                     throw assertErr;
@@ -3659,7 +3800,17 @@ async function spawnAgent(dispatchItem, config) {
             // ahead of main) — two consecutive fix dispatches errored on
             // STALE_HEAD over 10 min and the engine then starved the PR for
             // the cooldown window (60 min effective).
-            const _branchOnRemote = await probeBranchOnRemote(rootDir, branchName, _gitOpts);
+            let _branchOnRemote;
+            try {
+              _branchOnRemote = await probeBranchOnRemote(rootDir, branchName, _gitOpts);
+            } catch (probeErr) {
+              _failWorktreeRemotePreparation(
+                probeErr,
+                `could not determine whether origin has branch ${branchName}`,
+                `its required origin/${branchName} existence check could not complete`,
+              );
+              return null;
+            }
 
             if (_branchOnRemote) {
               // Mirror shared-branch fetch+add (~line 1157-1159).
@@ -3684,7 +3835,7 @@ async function spawnAgent(dispatchItem, config) {
                       log('warn', `Branch ${branchName} actively used by another agent at ${existingWtPath} — cannot create worktree`);
                       throw eRemote;
                     }
-                    try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
+                    try { assertSafeWorktreePath(existingWtPath); }
                     catch (assertErr) {
                       if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
                       throw assertErr;
@@ -3709,7 +3860,7 @@ async function spawnAgent(dispatchItem, config) {
                 } else { throw eRemote; }
               }
             } else {
-              // Branch isn't on origin (or probe failed) — start a fresh local
+              // Branch is confirmed absent on origin — start a fresh local
               // branch from origin/<mainRef>. This is the dominant path for new
               // implement/decompose dispatches.
               // W-mph6n4p00006ce38: mirror the pool-borrow path (~line 1110-1114)
@@ -3717,27 +3868,43 @@ async function spawnAgent(dispatchItem, config) {
               // not the local ref. Without this, fresh-create dispatches inherit
               // whatever stale local master the engine clone happens to be on
               // (most painful: long-lived engine processes between restarts).
-              // Non-fatal: if the fetch fails (network blip, transient auth),
-              // fall back to local mainRef so the dispatch still progresses;
-              // the dep-merge phase's own fetch + the on-failure
-              // `git reset --hard origin/<mainRef>` recovery remain as safety nets.
+              // Fail closed: an ordinary brand-new branch must never inherit a
+              // stale local mainRef when origin/<mainRef> could not be refreshed.
+              // Existing/PR/shared branches are handled above and retain their
+              // continuation semantics.
+              // A local branch with no upstream is an intentional retry/WIP
+              // continuation. Preserve the old `-b` -> "already exists" fallback
+              // below; only truly brand-new branches require a fresh base.
+              const _branchExistsLocally = await _probeBranchLocally(rootDir, branchName, _gitOpts);
               let _freshCreateBase = mainRef;
-              const _baseFetchOk = await _fetchWithTransientRetry(
-                ['origin', mainRef],
-                { ..._gitOpts, cwd: rootDir, timeout: 30000 },
-                `origin/${mainRef} (fresh-create base for ${branchName})`
-              );
-              if (_baseFetchOk) _freshCreateBase = `origin/${mainRef}`;
+              if (!_branchExistsLocally) {
+                try {
+                  await _fetchWithTransientRetry(
+                    ['origin', mainRef],
+                    { ..._gitOpts, cwd: rootDir, timeout: 30000 },
+                    `origin/${mainRef} (fresh-create base for ${branchName})`,
+                    { throwOnFailure: true },
+                  );
+                  _freshCreateBase = `origin/${mainRef}`;
+                } catch (freshBaseErr) {
+                  _failWorktreeRemotePreparation(
+                    freshBaseErr,
+                    `could not refresh origin/${mainRef} before creating brand-new branch ${branchName}`,
+                    `its required fresh origin/${mainRef} base was unavailable`,
+                  );
+                  return null;
+                }
+              }
               try {
                 await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, worktreeCreateRetries);
               } catch (e1) {
                 const branchExists = e1.message?.includes('already exists');
                 log('warn', `Worktree -b failed for ${branchName}: ${e1.message?.split('\n')[0]}`);
                 if (!branchExists) {
-                  // Transient error (lock, timeout) — prune, clean, and retry -b once more
+                  // Transient error (lock, timeout) — prune and retry -b once more.
+                  // Never delete the operator checkout's .git/index.lock.
                   log('info', `Retrying -b create after prune for ${branchName}`);
                   try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
-                  removeStaleIndexLock(rootDir);
                   // Clean up partial worktree directory from the failed -b
                   // attempt. This husk pre-dates `git worktree add`, so git
                   // does not yet own it and shared.removeWorktree's
@@ -3799,7 +3966,7 @@ async function spawnAgent(dispatchItem, config) {
                           log('warn', `Branch ${branchName} actively used by another agent at ${existingWtPath} — cannot create worktree`);
                           throw e2;
                         }
-                        try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
+                        try { assertSafeWorktreePath(existingWtPath); }
                         catch (assertErr) {
                           if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
                           throw assertErr;
@@ -4509,6 +4676,21 @@ async function spawnAgent(dispatchItem, config) {
     }
   }
 
+  if (worktreePath) {
+    dispatchItem.worktreePath = worktreePath;
+    try {
+      mutateDispatch((dispatch) => {
+        for (const queue of ['pending', 'active']) {
+          const found = (dispatch?.[queue] || []).find(d => d && d.id === id);
+          if (found) found.worktreePath = worktreePath;
+        }
+        return dispatch;
+      });
+    } catch (e) {
+      log('warn', `spawnAgent: failed to persist pre-spawn worktree path for ${id}: ${e.message}`);
+    }
+  }
+
   updateAgentStatus(id, AGENT_STATUS.READY, 'Worktree ready, preparing to spawn process');
 
   if (worktreePath && meta?.source === 'work-item' && meta?.item?.branchStrategy === 'shared-branch') {
@@ -4625,40 +4807,18 @@ async function spawnAgent(dispatchItem, config) {
   const resolvedModel = runtime.resolveModel(shared.resolveAgentModel(agentConfig, engineConfig));
   const resolvedMaxBudget = shared.resolveAgentMaxBudget(agentConfig, engineConfig);
   const resolvedBare = shared.resolveAgentBareMode(agentConfig, engineConfig);
-  // P-1d8f0b93 — pool a copilot dispatch through the persistent ACP worker
-  // pool (engine/agent-worker-pool.js) instead of cold-spawning a fresh CLI
-  // process, when the capability + config gate allows it. Structurally
-  // copilot-only (runtime.capabilities.acpWorkerPool) — see
-  // shared.resolveAgentUseWorkerPool for the exact precedence chain.
-  const useAgentPool = shared.resolveAgentUseWorkerPool(engineConfig, runtime);
-  if (useAgentPool) {
-    // Idempotent — cheap to call on every pooled dispatch so a live config
-    // change (agentAcpPoolSize / maxConcurrent) takes effect without a
-    // separate engine-restart-only wiring hook.
-    agentWorkerPool.setPoolSize(shared.resolveAgentAcpPoolSize(engineConfig));
-  }
-
-  // W-mpg6isvy000xca4d — On retry after FAILURE_CLASS.MODEL_UNAVAILABLE, swap
-  // to the runtime-appropriate fallback model. Two paths gated on
-  // `runtime.capabilities.fallbackModel` (no `runtime.name === ...` branches):
-  //   - Capability TRUE (Claude): the CLI's own --fallback-model handles
-  //     the swap on 429. We keep `engineConfig.claudeFallbackModel` plumbed
-  //     unconditionally via the fallbackModel opt below; no model override
-  //     needed at the engine layer.
-  //   - Capability FALSE (Copilot): no --fallback-model flag exists, so we
-  //     OVERRIDE the --model arg directly with engine.copilotFallbackModel
-  //     for this retry attempt only. The work item's _lastFailureClass is
-  //     written by dispatch.js's retry block; the next normal dispatch loop
-  //     pick-up re-reads it through meta.item.
-  let effectiveModel = resolvedModel;
-  const prevFailureClass = meta?.item?._lastFailureClass || null;
-  if (prevFailureClass === FAILURE_CLASS.MODEL_UNAVAILABLE
-      && runtime.capabilities?.fallbackModel === false
-      && engineConfig.copilotFallbackModel) {
-    effectiveModel = engineConfig.copilotFallbackModel;
-    log('info', `MODEL_UNAVAILABLE retry: ${runtimeName} ${id} — overriding --model to ${effectiveModel}`);
+  // Pool through the persistent ACP worker transport when the selected adapter
+  // opts into that capability and config allows it. keep_processes requires
+  // the cold wrapper so descendant ownership remains enforceable.
+  _syncAgentWorkerPoolConfig(engineConfig);
+  const keepProcessesRequested = !!meta?.item?.meta?.keep_processes || !!dispatchItem.meta?.keep_processes;
+  const agentPoolRequested = shared.resolveAgentUseWorkerPool(engineConfig, runtime);
+  const useAgentPool = agentPoolRequested && !keepProcessesRequested;
+  if (keepProcessesRequested && agentPoolRequested) {
+    log('info', `spawnAgent: disabling ACP worker pool for keep_processes dispatch ${id} so descendants can be reaped safely`);
   }
 
+  const prevFailureClass = meta?.item?._lastFailureClass || null;
   const requestedEffort = engineConfig.agentEffort || null;
 
   let cachedSessionId = null;
@@ -4667,53 +4827,49 @@ async function spawnAgent(dispatchItem, config) {
       agentId,
       branchName,
       agentsDir: AGENTS_DIR,
-      // Pass the working directory so the Claude adapter can probe for the
-      // conversation jsonl and avoid `--resume <dead-uuid>` retry loops when
-      // the agent died before checkpoint (W-mouugzow00068741).
+      // Adapters may use cwd to verify that their backing session still exists
+      // before returning a resumable ID.
       cwd,
       logger: _runtimeLogger(),
     });
   }
 
-  const args = _buildAgentSpawnFlags(runtime, {
-    model: effectiveModel,
+  const runtimeOptions = resolveInvocationOptions(runtime, {
+    model: resolvedModel,
     maxTurns: _maxTurnsForType(type, engineConfig),
-    allowedTools: shared.mergeManifestAllowedTools(
-      claudeConfig.allowedTools,
-      shared.resolveAgentManifest(_manifestAgent).allowed_tools,
-    ),
+    allowedTools: shared.resolveAgentAllowedTools(config),
     effort: requestedEffort,
     sessionId: cachedSessionId,
     maxBudget: resolvedMaxBudget,
     bare: resolvedBare,
-    fallbackModel: engineConfig.claudeFallbackModel,
-    stream: engineConfig.copilotStreamMode,
-    disableBuiltinMcps: engineConfig.copilotDisableBuiltinMcps,
-    reasoningSummaries: engineConfig.copilotReasoningSummaries,
+  }, {
+    config,
+    engineConfig,
+    failureClass: prevFailureClass,
   });
+  runtimeOptions.allowedTools = shared.mergeManifestAllowedTools(
+    runtimeOptions.allowedTools,
+    shared.resolveAgentManifest(_manifestAgent).allowed_tools,
+  );
+  const effectiveModel = runtimeOptions.model;
+  if (prevFailureClass === FAILURE_CLASS.MODEL_UNAVAILABLE
+      && effectiveModel && effectiveModel !== resolvedModel) {
+    log('info', `MODEL_UNAVAILABLE retry: ${runtimeName} ${id} — adapter selected model ${effectiveModel}`);
+  }
+  const args = _buildAgentSpawnFlags(runtime, runtimeOptions);
 
-  // MCP servers: agents inherit from ~/.claude.json directly as Claude Code processes.
-  // No --mcp-config needed — avoids redundant config and ensures agents always have latest servers.
-  //
-  // P-7d31a06b — When the runtime is Claude AND the worktree has a `.mcp.json`,
-  // pre-warm `~/.claude.json` projects.<worktreePath>.enabledMcpjsonServers so
-  // Claude's first call doesn't show the project-MCP trust prompt (which
-  // --dangerously-skip-permissions silently suppresses → agent runs without the
-  // workspace MCPs connected). Helper internally no-ops for non-Claude runtimes
-  // and when engine.claudePreApproveWorkspaceMcps is false (no runtime.name
-  // check at this call site, per CLAUDE.md rule). Best-effort: NEVER block dispatch.
-  //
+  // Let the adapter prepare any runtime-owned workspace state. Best-effort:
+  // harness setup must never block dispatch.
   try {
-    const result = preApproveWorkspaceMcps({
-      runtimeName,
+    const result = prepareWorkspace(runtime, {
       worktreePath,
       homeDir: os.homedir(),
       engineConfig,
       mutateJsonFileLocked: shared.mutateJsonFileLocked,
     });
     if (result.wrote) {
-      log('info', `Pre-approved ${result.servers.length} workspace MCP server(s) in ~/.claude.json for ${worktreePath}: ${result.servers.join(', ')}`);
-    } else if (result.reason !== 'no-workspace-mcp' && result.reason !== 'not-claude' && result.reason !== 'no-worktree') {
+      log('info', `Runtime workspace prepared for ${id}${result.target ? ` (${result.target})` : ''}`);
+    } else if (result.reason !== 'no-workspace-mcp' && result.reason !== 'unsupported-runtime' && result.reason !== 'no-worktree') {
       log('debug', `Skipped workspace MCP pre-approval for ${id} (reason=${result.reason})`);
     }
   } catch (err) {
@@ -4724,10 +4880,22 @@ async function spawnAgent(dispatchItem, config) {
 
   log('info', `Spawning agent: ${agentId} (${id}) in ${cwd}`);
   log('info', `Task type: ${type} | Branch: ${branchName || 'none'}`);
+  dispatchItem.executionCwd = cwd;
+  try {
+    mutateDispatch((dispatch) => {
+      for (const queue of ['pending', 'active']) {
+        const found = (dispatch?.[queue] || []).find(d => d && d.id === id);
+        if (found) found.executionCwd = cwd;
+      }
+      return dispatch;
+    });
+  } catch (e) {
+    log('warn', `spawnAgent: failed to persist execution cwd for ${id}: ${e.message}`);
+  }
 
   // Agent status is derived from dispatch state.
 
-  // Spawn the claude process
+  // Spawn the selected harness runtime.
   const childEnv = shared.cleanChildEnv();
   if (completionReportPath) childEnv.MINIONS_COMPLETION_REPORT = completionReportPath;
   if (completionNonce) childEnv.MINIONS_COMPLETION_NONCE = completionNonce;
@@ -4740,6 +4908,11 @@ async function spawnAgent(dispatchItem, config) {
       || dispatchItem.meta?.keep_processes_skip_workdir_check) {
     childEnv.MINIONS_KEEP_PROCESSES_SKIP_WORKDIR_CHECK = '1';
   }
+  const keepProcessesAllowedCwdRoot = worktreePath
+    || (liveMode && project?.localPath ? path.resolve(String(project.localPath)) : cwd);
+  if (keepProcessesAllowedCwdRoot) {
+    childEnv.MINIONS_KEEP_PROCESSES_ALLOWED_CWD_ROOT = keepProcessesAllowedCwdRoot;
+  }
 
   // W-mpg54mi2000n7b7e — suppress Git's interactive credential prompts and
   // Git Credential Manager's GUI dialog for every agent spawn. Without these,
@@ -4787,7 +4960,7 @@ async function spawnAgent(dispatchItem, config) {
 
   // Spawn via wrapper script — node directly (no bash intermediary)
   // spawn-agent.js handles CLAUDECODE env cleanup and claude binary resolution
-  const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
+  const spawnScript = runtime.spawnScript || path.join(ENGINE_DIR, 'spawn-agent.js');
 
   const spawnArgs = [spawnScript, promptPath, sysPromptPath, ...args];
   // P-1d8f0b93 — the pooled-dispatch branch further down (agentWorkerPool
@@ -4850,9 +5023,9 @@ async function spawnAgent(dispatchItem, config) {
     }
 
     _phaseT.spawnCallStart = Date.now();
-    // P-c5a1f3b8 (Item D — live-mode push/PR-create cwd guard): in live mode
-    // worktreePath stays null, so `cwd` here is project.localPath (it is never
-    // reassigned to a worktree by the `if (worktreePath ...)` block above). The
+    // P-c5a1f3b8 (Item D — live-mode push/PR-create cwd guard): only live mode
+    // leaves worktreePath null with cwd=project.localPath. Worktree-mode
+    // project dispatches, including read-only types, have an isolated path. The
     // agent's `git push -u origin <branch>` and PR-create therefore run in-place
     // against the operator's checkout. This cwd MUST NEVER be null for a mutating
     // live dispatch — shared.resolveSpawnPaths returns cwd === project.localPath
@@ -4891,6 +5064,7 @@ async function spawnAgent(dispatchItem, config) {
         'MINIONS_LIVE_OUTPUT_PATH',
         'MINIONS_STEERING_ACK_DIR',
         'MINIONS_AGENT_CWD',
+        'MINIONS_KEEP_PROCESSES_ALLOWED_CWD_ROOT',
       ];
       const pooledProcessEnv = { ...childEnv };
       const pooledSessionContext = {};
@@ -4900,18 +5074,30 @@ async function spawnAgent(dispatchItem, config) {
       }
       proc = new PooledAgentProcess({
         pool: agentWorkerPool,
+        runtime,
         dispatchId: id,
         cwd,
-        model: effectiveModel,
-        effort: requestedEffort,
+        processCwd: _resolveAgentPoolProcessCwd(project, engineConfig),
+        model: runtimeOptions.model,
+        effort: runtimeOptions.effort,
         // Mirrors the CC worker pool's convention (dashboard.js) — a single
         // flat top-level config array, not per-agent-resolved.
         mcpServers: (engineConfig && engineConfig.mcpServers) || [],
         hermeticDirs: addDirs,
         processEnv: pooledProcessEnv,
+        workerOptions: runtimeOptions,
+        sessionId: cachedSessionId,
         sessionContext: pooledSessionContext,
+        agentId,
+        reapDescendants: true,
+        keepProcessesSkipWorkdirCheck: !!(
+          meta?.item?.meta?.keep_processes_skip_workdir_check
+          || dispatchItem.meta?.keep_processes_skip_workdir_check
+        ),
         systemPromptText: systemPrompt,
-        promptText: fullTaskPrompt,
+        // The prompt file may have gained dirty-file or cross-repo dependency
+        // sections after `fullTaskPrompt` was first built.
+        promptText: fs.readFileSync(promptPath, 'utf8'),
       });
       // The child_process PID file is normally written asynchronously by
       // spawn-agent.js itself (engine/spawn-agent.js:606) once it starts.
@@ -5043,7 +5229,7 @@ async function spawnAgent(dispatchItem, config) {
   let stdout = '';
   let stderr = '';
   let steeringAckStdout = '';
-  const sessionCaptureState = { sessionLineBuffer: '' };
+  const sessionCaptureState = { sessionLineBuffer: '', modelLineBuffer: '' };
   let _trustCheckDone = false;
   const _spawnTime = Date.now();
 
@@ -5078,6 +5264,7 @@ async function spawnAgent(dispatchItem, config) {
     // Copilot emits sessionId, so use the runtime-neutral steering helper.
     const procInfo = activeProcesses.get(id);
     markRuntimeResumeOutputSeen(procInfo);
+    captureExecutionModelFromStdoutChunk(dispatchItem, id, runtime, procInfo, chunk, sessionCaptureState);
     captureSessionIdFromStdoutChunk(agentId, id, branchName, runtime, procInfo, chunk, sessionCaptureState);
 
     ackPendingSteeringFiles(agentId, procInfo, chunk);
@@ -5199,22 +5386,17 @@ async function spawnAgent(dispatchItem, config) {
         return;
       }
 
-      const resumeArgs = _buildAgentSpawnFlags(runtime, {
-        model: effectiveModel,
+      const resumeRuntimeOptions = resolveInvocationOptions(runtime, {
+        ...runtimeOptions,
         maxTurns: engineConfig?.maxTurns || ENGINE_DEFAULTS.maxTurns,
-        allowedTools: shared.mergeManifestAllowedTools(
-          claudeConfig?.allowedTools,
-          shared.resolveAgentManifest(_manifestAgent).allowed_tools,
-        ),
         sessionId: steerSessionId,
-        maxBudget: resolvedMaxBudget,
-        bare: resolvedBare,
-        fallbackModel: engineConfig?.claudeFallbackModel,
-        stream: engineConfig?.copilotStreamMode,
-        disableBuiltinMcps: engineConfig?.copilotDisableBuiltinMcps,
-        reasoningSummaries: engineConfig?.copilotReasoningSummaries,
+      }, {
+        config,
+        engineConfig,
+        failureClass: prevFailureClass,
       });
-      if (!resumeArgs.includes('--resume')) {
+      const resumeArgs = _buildAgentSpawnFlags(runtime, resumeRuntimeOptions);
+      if (runtime.capabilities?.sessionResume !== true) {
         log('warn', `Steering: runtime ${runtime.name} did not accept session resume — skipping for ${agentId}`);
         try { fs.appendFileSync(liveOutputPath, `\n[steering-failed] Runtime ${runtime.name} does not support session resume. Message was: ${steerMsg}\n`); } catch {}
         try { fs.unlinkSync(steerPromptPath); } catch {}
@@ -5224,7 +5406,7 @@ async function spawnAgent(dispatchItem, config) {
         return;
       }
 
-      const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
+      const spawnScript = runtime.spawnScript || path.join(ENGINE_DIR, 'spawn-agent.js');
       const childEnv = shared.cleanChildEnv();
       if (completionReportPath) childEnv.MINIONS_COMPLETION_REPORT = completionReportPath;
       // P-d2a8f6c1: preserve the per-dispatch nonce across steering resume so
@@ -5271,6 +5453,24 @@ async function spawnAgent(dispatchItem, config) {
       // Re-expose the engine-resolved cwd on steering resume (matches the
       // initial spawn path) so $MINIONS_AGENT_CWD stays valid across resumes.
       childEnv.MINIONS_AGENT_CWD = cwd;
+      if (keepProcessesAllowedCwdRoot) {
+        childEnv.MINIONS_KEEP_PROCESSES_ALLOWED_CWD_ROOT = keepProcessesAllowedCwdRoot;
+      }
+      try {
+        mutateDispatch((dp) => {
+          const active = dp.active.find((entry) => entry.id === id);
+          if (active) delete active.pooled;
+          return dp;
+        });
+        delete dispatchItem.pooled;
+      } catch (e) {
+        log('warn', `Steering: failed to persist cold-resume mode for ${agentId}: ${e.message}`);
+        try { fs.unlinkSync(steerPromptPath); } catch { /* cleanup */ }
+        activeProcesses.delete(id);
+        completeDispatch(id, DISPATCH_RESULT.ERROR, `Steering state update failed: ${e.message}`);
+        cleanupTempAgent(agentId);
+        return;
+      }
       let resumeProc;
       try {
         // detached so the resumed steering session also survives engine death (matches initial spawn)
@@ -5289,6 +5489,12 @@ async function spawnAgent(dispatchItem, config) {
         cleanupTempAgent(agentId);
         return;
       }
+      const writeResumePid = () => {
+        if (!resumeProc.pid) return;
+        try { fs.writeFileSync(pidFilePath, String(resumeProc.pid)); } catch { /* best-effort */ }
+      };
+      if (resumeProc.pid) writeResumePid();
+      else if (typeof resumeProc.once === 'function') resumeProc.once('spawn', writeResumePid);
 
       // Re-attach to existing tracking — do NOT carry _steeringAt forward (#1052).
       // The kill watcher in timeout.js fires 30s after _steeringAt is set. If we carry it
@@ -5321,6 +5527,7 @@ async function spawnAgent(dispatchItem, config) {
         stderr = '';
       }
       sessionCaptureState.sessionLineBuffer = '';
+      sessionCaptureState.modelLineBuffer = '';
       // Re-wire stdout/stderr handlers (same as original)
       resumeProc.stdout.on('data', (data) => {
         const chunk = data.toString();
@@ -5348,6 +5555,7 @@ async function spawnAgent(dispatchItem, config) {
           } catch { /* best-effort */ }
         }
         markRuntimeResumeOutputSeen(resumeInfo);
+        captureExecutionModelFromStdoutChunk(dispatchItem, id, runtime, resumeInfo, chunk, sessionCaptureState);
         captureSessionIdFromStdoutChunk(agentId, id, branchName, runtime, resumeInfo, chunk, sessionCaptureState);
         ackPendingSteeringFiles(agentId, resumeInfo, chunk);
       });
@@ -5509,8 +5717,12 @@ async function spawnAgent(dispatchItem, config) {
           let evalResult = schemaResult;
           let isWorkdirRejection = false;
           const workdirGateOn = !_kpSkipWorkdir && ENGINE_DEFAULTS.keepProcesses?.requireGitWorkdir !== false;
-          if (schemaResult.exists && schemaResult.accepted && workdirGateOn) {
-            const workdirResult = keepProcessSweep.evaluateKeepPidsAcceptance(agentId, { requireGitWorkdir: true });
+          const allowedCwdRoot = keepProcessesAllowedCwdRoot;
+          if (schemaResult.exists && schemaResult.accepted && (workdirGateOn || allowedCwdRoot)) {
+            const workdirResult = keepProcessSweep.evaluateKeepPidsAcceptance(agentId, {
+              requireGitWorkdir: workdirGateOn,
+              ...(allowedCwdRoot ? { allowedCwdRoot } : {}),
+            });
             if (workdirResult.exists && !workdirResult.accepted && workdirResult.isWorkdirRejection) {
               evalResult = workdirResult;
               isWorkdirRejection = true;
@@ -5605,6 +5817,22 @@ async function spawnAgent(dispatchItem, config) {
             } catch (alertErr) {
               log('warn', `keep-processes acceptance: failed to emit inbox alert for ${agentId}: ${alertErr.message}`);
             }
+          } else if (evalResult.exists && evalResult.accepted) {
+            try {
+              const enriched = {
+                ...(evalResult.parsedRaw || {}),
+                cwd: evalResult.recordedCwd || '',
+                project: project?.name || '',
+                work_type: type,
+                checkout_mode: checkoutModeAtDispatch,
+                dispatch_root: allowedCwdRoot
+                  ? shared.realPathForComparison(allowedCwdRoot)
+                  : '',
+              };
+              fs.writeFileSync(evalResult.filePath, JSON.stringify(enriched, null, 2));
+            } catch (e) {
+              log('warn', `keep-processes acceptance: could not persist checkout provenance for ${agentId}: ${e.message}`);
+            }
           }
         } catch (e) {
           log('warn', `keep-processes acceptance check failed for ${agentId} (${id}): ${e.message}`);
@@ -5632,7 +5860,12 @@ async function spawnAgent(dispatchItem, config) {
       if (_msEnabled) {
         try {
           const managedSpawn = require('./engine/managed-spawn');
-          const evalResult = managedSpawn.evaluateManagedSpawnAcceptance(agentId);
+          const allowedCwdRoot = keepProcessesAllowedCwdRoot;
+          const evalResult = managedSpawn.evaluateManagedSpawnAcceptance(agentId, {
+            projects: getProjects(config),
+            project,
+            ...(allowedCwdRoot ? { allowedCwdRoot } : {}),
+          });
           if (evalResult.exists && !evalResult.accepted) {
             managedSpawnAcceptanceFailure = {
               reason: evalResult.reason,
@@ -5690,6 +5923,9 @@ async function spawnAgent(dispatchItem, config) {
               owner_agent: agentId,
               owner_wi: dispatchItem.meta?.item?.id || '',
               owner_project: project?.name || '',
+              owner_work_type: type,
+              dispatch_root: allowedCwdRoot || '',
+              checkout_mode: checkoutModeAtDispatch,
             };
             const spawnedItems = [];
             let spawnFailureReason = null;
@@ -6030,7 +6266,7 @@ async function spawnAgent(dispatchItem, config) {
     // crashed dispatch leaks `work/W-<id>` worktree entries that block
     // every retry with `fatal: 'work/W-<id>' is already used by worktree
     // at …` until the 2-hour age sweep in cleanup.js eventually catches up.
-    if (worktreePath && rootDir && branchName) {
+    if (worktreePath && rootDir) {
       try {
         const _wgc = require('./engine/worktree-gc');
         const _wtRoot = path.resolve(rootDir, engineConfig.worktreeRoot || ENGINE_DEFAULTS.worktreeRoot);
@@ -6077,7 +6313,7 @@ async function spawnAgent(dispatchItem, config) {
     //    restore is a plain `git checkout <originalRef>` — never --force/reset/
     //    clean/stash — and is best-effort: a thrown restore never alters the
     //    dispatch result.
-    if (liveMode && branchName) {
+    if (liveMode && branchName && shared.isLiveCheckoutDispatchRecord(dispatchItem, getConfig())) {
       try {
         const _liveRestore = require('./engine/live-checkout');
         await _liveRestore.restoreLiveCheckoutAtDispatchEnd({
@@ -6259,11 +6495,19 @@ async function spawnAgent(dispatchItem, config) {
     // route output parsing through the right adapter. Also surfaces the choice
     // in dispatch state for debugging multi-runtime fleets.
     item.runtimeName = runtimeName;
+    if (effectiveModel) item.requestedModel = effectiveModel;
+    else delete item.requestedModel;
+    if (dispatchItem.executionModel) item.executionModel = dispatchItem.executionModel;
+    else delete item.executionModel;
     // P-3f5b7d26 — persist pooled on the DISK record (activeProcesses/_pooled
     // is wiped on restart); cli.js's reattach path needs this since a pooled
     // ACP worker isn't spawned detached and a fresh pool cold-starts empty —
     // a live worker PID must never be mistaken for a resumable dispatch.
     if (useAgentPool) item.pooled = true;
+    else delete item.pooled;
+    item.checkoutMode = checkoutModeAtDispatch;
+    item.executionCwd = cwd;
+    if (resolvedProjectMeta && item.meta) item.meta.project = resolvedProjectMeta;
     // W-mq5rwwss000f30a7 — persist the worktree path so the live-worktree
     // guard (shared.isWorktreePathLive) can correlate destructive callers
     // (removeWorktree, cleanup orphan-dir sweep, pool-return, quarantine)
@@ -6542,73 +6786,6 @@ function safePrdProjectSlug(projectName) {
   return slug || 'project';
 }
 
-// Fleet branches the engine/CC create. A worktree-mode operator checkout should
-// NEVER sit on one of these (or any branch); when it does, a flow ran raw
-// `git checkout`/`merge` in the live checkout instead of a worktree.
-const _FLEET_BRANCH_RE = /^(cc-pr|backport|e2e|verify|sched-|work)\//;
-
-// Self-heal: a worktree-mode project's operator checkout (project.localPath) must
-// always sit on its mainBranch — agents use isolated worktrees, CC Create-PR uses
-// prepare-create-pr-worktree. But fleet flows (CC raw git, backport, sync)
-// sometimes run `git checkout <branch>` + `git merge` THERE despite the rules,
-// leaving it stuck on a feature branch (often mid-conflict) — which restores
-// git-tracked dead PRDs and pollutes the operator's main, then the materializer
-// re-runs finished work. Detect + restore. Conservative: only acts on a stuck
-// merge/rebase OR a recognizably fleet-created branch, so a human's deliberate
-// `git checkout my-feature` in their checkout is left alone. Branch commits are
-// preserved on their ref (reset --hard only drops the uncommitted hijack state).
-function restoreHijackedOperatorCheckouts(config) {
-  if (config?.engine?.autoRestoreOperatorCheckout === false) return;
-  let projects;
-  try { projects = getProjects(config); } catch { return; }
-  for (const project of projects) {
-    try {
-      const localPath = project?.localPath;
-      if (!localPath || !fs.existsSync(localPath)) continue;
-      if (shared.resolveCheckoutMode(project) === shared.CHECKOUT_MODES.LIVE) continue; // live-mode: feature branch is intentional
-      const main = project.mainBranch || 'main';
-      const opts = { cwd: localPath };
-      // W-mrcvh5hw000o6cf1: use the argv-form (shell: false) git helper instead of
-      // execSilent(). execSilent() shells out via cmd.exe, which cannot chdir into
-      // a UNC path (`//wsl.localhost/...`, `\\server\share\...`) — it silently
-      // falls back to the Windows directory and every git call then fails with
-      // "fatal: not a git repository", every tick, forever, for WSL/UNC-hosted
-      // projects. shellSafeGitSync spawns git.exe directly (execFileSync,
-      // shell:false) so `cwd` is honored even for UNC paths.
-      let isRepo;
-      try { isRepo = String(shared.shellSafeGitSync(['rev-parse', '--is-inside-work-tree'], opts) || '').trim(); }
-      catch { continue; } // not a git repo (or transiently unreachable) — nothing to restore, skip quietly
-      if (isRepo !== 'true') continue;
-      const cur = String(shared.shellSafeGitSync(['rev-parse', '--abbrev-ref', 'HEAD'], opts) || '').trim();
-      if (!cur || cur === 'HEAD' || cur === main) continue; // on main or detached — fine
-      const gitDir = String(shared.shellSafeGitSync(['rev-parse', '--git-dir'], opts) || '').trim();
-      const absGitDir = gitDir ? (path.isAbsolute(gitDir) ? gitDir : path.join(localPath, gitDir)) : path.join(localPath, '.git');
-      const mergeStuck = fs.existsSync(path.join(absGitDir, 'MERGE_HEAD'));
-      const rebaseStuck = fs.existsSync(path.join(absGitDir, 'rebase-merge')) || fs.existsSync(path.join(absGitDir, 'rebase-apply'));
-      if (!mergeStuck && !rebaseStuck && !_FLEET_BRANCH_RE.test(cur)) continue; // likely a human's deliberate checkout — leave it
-      const why = mergeStuck ? ' (stuck merge)' : rebaseStuck ? ' (stuck rebase)' : ' (fleet branch in live checkout)';
-      log('warn', `Operator checkout for ${project.name} is on '${cur}'${why}; worktree-mode requires ${main} — restoring`);
-      if (mergeStuck) shared.shellSafeGitSync(['merge', '--abort'], opts);
-      if (rebaseStuck) shared.shellSafeGitSync(['rebase', '--abort'], opts);
-      shared.shellSafeGitSync(['reset', '--hard', 'HEAD'], opts); // drop uncommitted hijack state; branch commits stay on the ref
-      try { shared.validateGitRef(main); } catch (ve) { throw new Error(`restoreHijackedOperatorCheckouts: invalid mainBranch ${JSON.stringify(main)}: ${ve.message}`); }
-      shared.shellSafeGitSync(['checkout', main], opts);
-      const now = String(shared.shellSafeGitSync(['rev-parse', '--abbrev-ref', 'HEAD'], opts) || '').trim();
-      if (now === main) {
-        try {
-          writeInboxAlert(`operator-checkout-restored-${project.name}`,
-            `Operator checkout ${localPath} was hijacked onto '${cur}'${why} and restored to ${main}. ` +
-            'A fleet flow ran git checkout/merge in the LIVE operator checkout instead of an isolated worktree ' +
-            '(playbooks/shared-rules.md: "Do NOT checkout branches in the main working tree — use worktrees"). ' +
-            `The '${cur}' branch commits are preserved on its ref.`);
-        } catch { /* alert is best-effort */ }
-      } else {
-        log('warn', `Operator checkout restore for ${project.name} did not reach ${main} (now '${now}') — manual intervention needed`);
-      }
-    } catch (e) { log('warn', `restoreHijackedOperatorCheckouts ${project?.name || '?'}: ${e?.message || e}`); }
-  }
-}
-
 function materializePlansAsWorkItems(config) {
   const writePrdLocked = (fileName, data) => {
     return prdStore.writePrd(fileName, data);
@@ -7990,6 +8167,7 @@ async function discoverFromPrs(config, project) {
             const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
               pr_id: pr.id, pr_branch: prBranch,
               review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
+              review_finding_id: shared.prReviewFindingIdentity(pr),
             }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, {
               dispatchKey: key, cooldownKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta,
               // W-mpg58wv3 — closure-loop binding. Carries the originating minion review
@@ -10484,6 +10662,7 @@ async function tickInner() {
   catch (e) { log('warn', `lastTickAt write: ${e.message}`); }
 
   const config = getConfig();
+  _syncAgentWorkerPoolConfig(config.engine);
   tickCount++;
   const now = Date.now();
   const tickIntervalMs = Math.max(1, Number(config.engine?.tickInterval) || ENGINE_DEFAULTS.tickInterval);
@@ -11516,9 +11695,6 @@ async function tickInner() {
     const maxC = resolveMaxConcurrent(config);
     setTempBudget(Math.max(0, maxC - activeCountPre));
   }
-  // Self-heal a hijacked operator checkout BEFORE discovery/materialization, so a
-  // dead PRD restored by a stray `git checkout` can't be re-materialized this tick.
-  try { restoreHijackedOperatorCheckouts(config); } catch (e) { log('warn', 'restoreHijackedOperatorCheckouts: ' + e.message); }
   let discoveryOk = true;
   try { await withTickTimeout(() => discoverWork(config), 'discoverWork', tickOpTimeoutMs); } catch (e) { log('warn', 'discoverWork: ' + e.message); discoveryOk = false; }
   if (_isTickStale(myGeneration)) return;
@@ -11619,7 +11795,6 @@ module.exports = {
   discoverWork, discoverFromPrs, discoverFromWorkItems, discoverCentralWorkItems,
   materializePlansAsWorkItems,
   materializeSpecsAsWorkItems, // exported for testing (P-f7-git-log)
-  restoreHijackedOperatorCheckouts, // exported for testing — operator-checkout self-heal
 
   // Shared helpers (used by lifecycle.js and tests)
   reconcileItemsWithPrs, detectDependencyCycles,
@@ -11631,13 +11806,15 @@ module.exports = {
   gitOutputToString, gitErrorOutput, classifyDepMergeFailureOutput, listUnmergedFiles, // exported for testing
   buildDepConflictFixItem, deriveConflictFixKey, // exported for testing (W-mpcwojgr000a0244)
   runWorktreeAdd, // exported for testing (W-mqvaxv65000m76f2 — GVFS partial-checkout behavioral test)
-  isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, pushCleanAheadBranch, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
+  _fetchWithTransientRetry, _classifyFreshBaseFetchFailure, _probeBranchLocally, // exported for testing
+  isWorktreeRetryableError, syncReusedWorktree, pushCleanAheadBranch, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
   _statusPorcelainCmd, _killGitDescendantsForWorktree, _bumpQuarantineOutcome, // exported for testing (W-mq5n1zx5)
   _reapWorktreeHolders, _findTerminalWorktreeOwners, // exported for testing (W-mqila0t5 — CWD-pinned holder reap)
   pruneStaleWorktreeForBranch, // exported for testing
   findExistingWorktree, // exported for testing
   probeBranchOnRemote, // exported for testing (W-mphnm6a1000281b8)
   _maxTurnsForType, buildProjectContext, normalizeAc, _buildAgentSpawnFlags, _classifyAgentFailure, // exported for testing
+  _runtimeModelFromOutputLine, captureExecutionModelFromStdoutChunk, // exported for testing
   _tryAutoResolveLiveCheckoutWorktreeConflict, // exported for testing (W-mr28h2j2000y0de1 review — auto-resolve worktree conflicts)
   _isOutputTruncated, AGENT_OUTPUT_CAP_BYTES, // P-8e4c2a17: exported for testing (OUTPUT_TRUNCATED detection)
   promoteCheckpointSteeringForClose, // exported for testing