@magnusekdahl/parallix 1.2.0 → 1.2.1

package/lib/agents/agents.js

@@ -1,17 +1,71 @@
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const fmt = require('../core/fmt');
-const { startCodexDraftAgent, resolveCodexCommand } = require('./codex');
-const { startClaudeAgent, resolveClaudeCommand } = require('./claude');
-const { startMistralAgent, resolveMistralCommand } = require('./mistral');
-const { startOpencodeAgent, resolveOpencodeCommand, isSpuriousOpencodeExit } = require('./opencode');
-const { detectLimitHit, formatBlockUntil, DEFAULT_FALLBACK_HOURS } = require('./limit-hit');
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCommandPathProbe = exports.WORKFLOW_AGENT_NAMES = exports.KNOWN_AGENT_NAMES = void 0;
+exports.startAgent = startAgent;
+exports.startDraftAgent = startDraftAgent;
+exports.selectAgent = selectAgent;
+exports.eligibleAgentsForStep = eligibleAgentsForStep;
+exports.readAgentConfig = readAgentConfig;
+exports.readAgentConfigOrExit = readAgentConfigOrExit;
+exports.assertAgentSupported = assertAgentSupported;
+exports.workflowLauncherStatus = workflowLauncherStatus;
+exports.isAgentBlocked = isAgentBlocked;
+exports.parseBlockUntil = parseBlockUntil;
+exports.isInvalidAgentConfigError = isInvalidAgentConfigError;
+exports.updateAgentBlock = updateAgentBlock;
+exports.resolveBlocklistTargetPath = resolveBlocklistTargetPath;
+exports.resolveNoOutputWatchdogConfig = resolveNoOutputWatchdogConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const fmt = __importStar(require("../core/fmt.js"));
+const codex_js_1 = require("./codex.js");
+const claude_js_1 = require("./claude.js");
+const mistral_js_1 = require("./mistral.js");
+const opencode_js_1 = require("./opencode.js");
+const limit_hit_js_1 = require("./limit-hit.js");
+const storage = __importStar(require("../core/storage.js"));
+const product_config_js_1 = require("../core/product-config.js");
+const persistent_data_migration_js_1 = require("../core/persistent-data-migration.js");
+// tools/sessions is still CJS (not converted in this wave); require keeps it
+// untyped (any) without pulling a non-included .js into the typecheck program.
 const sessions = require('../tools/sessions');
-const storage = require('../core/storage');
-const { resolveAgentModel } = require('../core/product-config');
-const { migrateAgentBlocklists } = require('../core/persistent-data-migration');
-
 // Launchers whose CLI accepts a per-call resume flag threaded by startAgent.
 // Each launcher outputs a session resume hint at the end of its run (e.g.
 // "codex resume <id>", "opencode -s ses_<id>",
@@ -20,913 +74,758 @@ const { migrateAgentBlocklists } = require('../core/persistent-data-migration');
 // custom (opencode) always uses --continue; claude uses --continue; codex uses
 // `exec resume --last`.
 const RESUME_CAPABLE = new Set(['claude', 'codex', 'custom']);
-
-const CONFIG_PATH = path.join(__dirname, '..', '..', 'config', 'agents.json');
-
+const CONFIG_PATH = node_path_1.default.join(__dirname, '..', '..', 'config', 'agents.json');
 // Test hook: when set, used instead of spawning `command -v` to check PATH.
-/** @type {((name: string) => string | null) | null} */
 let _commandPathProbe = null;
-
-/** @type {{[key: string]: Function}} */
 const LAUNCHERS = {
-  codex: startCodexDraftAgent,
-  claude: startClaudeAgent,
-  mistral: startMistralAgent,
-  custom: startOpencodeAgent
+    codex: codex_js_1.startCodexDraftAgent,
+    claude: claude_js_1.startClaudeAgent,
+    mistral: mistral_js_1.startMistralAgent,
+    custom: opencode_js_1.startOpencodeAgent
 };
-
-/** @type {{[key: string]: () => string}} */
 const RESOLVERS = {
-  codex: resolveCodexCommand,
-  claude: resolveClaudeCommand,
-  mistral: resolveMistralCommand,
-  custom: resolveOpencodeCommand
+    codex: codex_js_1.resolveCodexCommand,
+    claude: claude_js_1.resolveClaudeCommand,
+    mistral: mistral_js_1.resolveMistralCommand,
+    custom: opencode_js_1.resolveOpencodeCommand
 };
-
-/** @type {{[key: string]: string[]}} */
 const HEALTH_PROBE_ARGS = Object.freeze({
-  codex: ['--help'],
-  claude: ['--help'],
-  mistral: ['--help'],
-  custom: ['--help']
+    codex: ['--help'],
+    claude: ['--help'],
+    mistral: ['--help'],
+    custom: ['--help']
 });
 const LAUNCHER_HEALTH_TIMEOUT_MS = 3000;
 const DEFAULT_NO_OUTPUT_INITIAL_DELAY_MS = 60_000;
 const DEFAULT_NO_OUTPUT_INTERVAL_MS = 60_000;
 const DRAFT_NO_OUTPUT_INITIAL_DELAY_MS = 15_000;
 const DRAFT_NO_OUTPUT_INTERVAL_MS = 30_000;
-
 const WORKFLOW_AGENT_NAMES = Object.freeze(Object.keys(LAUNCHERS));
+exports.WORKFLOW_AGENT_NAMES = WORKFLOW_AGENT_NAMES;
 const KNOWN_AGENT_NAMES = Object.freeze([
-  ...WORKFLOW_AGENT_NAMES,
-  'human'
+    ...WORKFLOW_AGENT_NAMES,
+    'human'
 ]);
-
-/** @param {string} agent */
+exports.KNOWN_AGENT_NAMES = KNOWN_AGENT_NAMES;
 function workflowLauncherStatus(agent) {
-  const resolver = RESOLVERS[agent];
-  if (!resolver) {
-    return { agent, supported: false, detail: `unknown agent: ${agent}` };
-  }
-  const command = resolver();
-  const exists = command.includes('/') ? fs.existsSync(command) : commandInPath(command);
-  if (!exists) {
-    return { agent, supported: false, detail: command, health: 'missing' };
-  }
-
-  const probeArgs = HEALTH_PROBE_ARGS[agent] || ['--help'];
-  const probe = spawnSync(command, probeArgs, {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: LAUNCHER_HEALTH_TIMEOUT_MS
-  });
-
-  if (probe.error || probe.status !== 0) {
-    /** @type {Error & {code?: string}} */
-    const pErr = probe.error || new Error('');
-    const reason = probe.error
-      ? (pErr.code || pErr.message)
-      : `exit ${probe.status}`;
-    return {
-      agent,
-      supported: false,
-      detail: `${command} ${probeArgs.join(' ')}`.trim(),
-      health: 'probe-failed',
-      reason
-    };
-  }
-
-  return { agent, supported: true, detail: `${command} ${probeArgs.join(' ')}`.trim(), health: 'ok' };
+    const resolver = RESOLVERS[agent];
+    if (!resolver) {
+        return { agent, supported: false, detail: `unknown agent: ${agent}` };
+    }
+    const command = resolver();
+    const exists = command.includes('/') ? node_fs_1.default.existsSync(command) : commandInPath(command);
+    if (!exists) {
+        return { agent, supported: false, detail: command, health: 'missing' };
+    }
+    const probeArgs = HEALTH_PROBE_ARGS[agent] || ['--help'];
+    const probe = (0, node_child_process_1.spawnSync)(command, probeArgs, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: LAUNCHER_HEALTH_TIMEOUT_MS
+    });
+    if (probe.error || probe.status !== 0) {
+        const pErr = probe.error || new Error('');
+        const reason = probe.error
+            ? (pErr.code || pErr.message)
+            : `exit ${probe.status}`;
+        return {
+            agent,
+            supported: false,
+            detail: `${command} ${probeArgs.join(' ')}`.trim(),
+            health: 'probe-failed',
+            reason
+        };
+    }
+    return { agent, supported: true, detail: `${command} ${probeArgs.join(' ')}`.trim(), health: 'ok' };
 }
-
-/** @param {string} name */
 function commandInPath(name) {
-  if (_commandPathProbe) {
-    return _commandPathProbe(name) || false;
-  }
-  const result = spawnSync('bash', ['-c', `command -v ${name}`], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore']
-  });
-  return result.status === 0 && result.stdout.trim().length > 0;
+    if (_commandPathProbe) {
+        return _commandPathProbe(name) || false;
+    }
+    const result = (0, node_child_process_1.spawnSync)('bash', ['-c', `command -v ${name}`], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+    });
+    return result.status === 0 && result.stdout.trim().length > 0;
 }
-
-/** @param {string} configPath @param {string} scope @param {{message?: string} | null} originalError */
 function buildInvalidAgentConfigError(configPath, scope, originalError) {
-  const location = path.resolve(configPath);
-  const detail = originalError && originalError.message ? originalError.message : 'invalid JSON';
-  /** @type {any} */
-  const error = new Error(
-    `Invalid ${scope} agent config at ${location}: ${detail}. ` +
-    'Fix or remove the malformed file before running workflow commands so agent blocking is applied deterministically.'
-  );
-  error.code = 'WORKFLOW_AGENT_CONFIG_INVALID';
-  error.configPath = location;
-  error.configScope = scope;
-  return error;
+    const location = node_path_1.default.resolve(configPath);
+    const detail = originalError && originalError.message ? originalError.message : 'invalid JSON';
+    const error = new Error(`Invalid ${scope} agent config at ${location}: ${detail}. ` +
+        'Fix or remove the malformed file before running workflow commands so agent blocking is applied deterministically.');
+    error.code = 'WORKFLOW_AGENT_CONFIG_INVALID';
+    error.configPath = location;
+    error.configScope = scope;
+    return error;
 }
-
-/** @param {{code?: string}} error */
 function isInvalidAgentConfigError(error) {
-  return Boolean(error && error.code === 'WORKFLOW_AGENT_CONFIG_INVALID');
+    return Boolean(error && error.code === 'WORKFLOW_AGENT_CONFIG_INVALID');
 }
-
 function readAgentConfigOrExit(configPath = CONFIG_PATH, options = {}) {
-  try {
-    return readAgentConfig(configPath, options);
-  } catch (/** @type {unknown} */ error) {
-    if (isInvalidAgentConfigError(/** @type {any} */ (error))) {
-      fmt.log.fail(/** @type {any} */ (error).message);
-      process.exit(1);
-    }
-    throw error;
-  }
+    try {
+        return readAgentConfig(configPath, options);
+    }
+    catch (error) {
+        if (isInvalidAgentConfigError(error)) {
+            fmt.log.fail(error.message);
+            process.exit(1);
+        }
+        throw error;
+    }
 }
-
-/** @param {string} configPath @param {string} scope */
 function parseAgentConfigFile(configPath, scope) {
-  try {
-    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  } catch (/** @type {unknown} */ err) {
-    throw buildInvalidAgentConfigError(configPath, scope, /** @type {{message?: string}} */ (err));
-  }
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    catch (err) {
+        throw buildInvalidAgentConfigError(configPath, scope, err);
+    }
 }
-
-/** @param {{mergeLocal?: boolean, mainWorktreePath?: string | null, warn?: Function, targetPath?: string}} options */
 function readAgentConfig(configPath = CONFIG_PATH, options = {}) {
-  const {
-    mergeLocal = path.resolve(configPath) === path.resolve(CONFIG_PATH),
-    mainWorktreePath,
-    warn = fmt.log.warn
-  } = options;
-  /** @type {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}}} */
-  let config = {};
-  if (fs.existsSync(configPath)) {
-    config = parseAgentConfigFile(configPath, 'workflow');
-  }
-
-  if (mergeLocal) {
-    config = config || {};
-    const projectRoot = path.resolve(path.dirname(configPath), '..', '..');
-    const mainWorktree = mainWorktreePath !== undefined
-      ? mainWorktreePath
-      : getMainWorktreePath({ cwd: projectRoot, warn });
-    const /** @type {string[]} */ legacyPaths = [
-      path.join(path.dirname(configPath), 'agents.local.json'),
-      path.join(projectRoot, 'agents.local.json'),
-      mainWorktree ? path.join(mainWorktree, 'agents.local.json') : ''
-    ].filter(/** @param {string} p */ (p) => Boolean(p));
-    const /** @type {string} */ targetPath = options.targetPath || storage.resolveAgentsLocalPath({ ensureDir: true });
-    if (!fs.existsSync(targetPath)) {
-      try {
-        migrateAgentBlocklists({
-          sourcePaths: legacyPaths,
-          destinationPath: targetPath,
-          warn
-        });
-      } catch (/** @type {unknown} */ error) {
-        throw buildInvalidAgentConfigError(targetPath, 'local', /** @type {any} */ (error));
-      }
-    }
-    if (fs.existsSync(targetPath)) {
-      const localConfig = parseAgentConfigFile(targetPath, 'local');
-      if (localConfig && localConfig.blocklist) {
-        /** @type {{blocklist?: {[key: string]: any}}} */ (config).blocklist = Object.assign(/** @type {{blocklist?: {[key: string]: any}}} */ (config).blocklist || {}, localConfig.blocklist);
-      }
-    }
-  }
-
-  return config;
+    const { mergeLocal = node_path_1.default.resolve(configPath) === node_path_1.default.resolve(CONFIG_PATH), mainWorktreePath, warn = fmt.log.warn } = options;
+    let config = {};
+    if (node_fs_1.default.existsSync(configPath)) {
+        config = parseAgentConfigFile(configPath, 'workflow');
+    }
+    if (mergeLocal) {
+        config = config || {};
+        const projectRoot = node_path_1.default.resolve(node_path_1.default.dirname(configPath), '..', '..');
+        const mainWorktree = mainWorktreePath !== undefined
+            ? mainWorktreePath
+            : getMainWorktreePath({ cwd: projectRoot, warn });
+        const /** @type {string[]} */ legacyPaths = [
+            node_path_1.default.join(node_path_1.default.dirname(configPath), 'agents.local.json'),
+            node_path_1.default.join(projectRoot, 'agents.local.json'),
+            mainWorktree ? node_path_1.default.join(mainWorktree, 'agents.local.json') : ''
+        ].filter(/** @param {string} p */ (p) => Boolean(p));
+        const /** @type {string} */ targetPath = options.targetPath || storage.resolveAgentsLocalPath({ ensureDir: true });
+        if (!node_fs_1.default.existsSync(targetPath)) {
+            try {
+                (0, persistent_data_migration_js_1.migrateAgentBlocklists)({
+                    sourcePaths: legacyPaths,
+                    destinationPath: targetPath,
+                    warn: warn
+                });
+            }
+            catch (error) {
+                throw buildInvalidAgentConfigError(targetPath, 'local', error);
+            }
+        }
+        if (node_fs_1.default.existsSync(targetPath)) {
+            const localConfig = parseAgentConfigFile(targetPath, 'local');
+            if (localConfig && localConfig.blocklist) {
+                config.blocklist = Object.assign(config.blocklist || {}, localConfig.blocklist);
+            }
+        }
+    }
+    return config;
 }
-
-/** @param {{cwd?: string, warn?: Function}} options */
 function getMainWorktreePath(options = {}) {
-  const { cwd = process.cwd(), warn = fmt.log.warn } = options;
-  try {
-    const commonDir = getGitPath(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
-    if (commonDir && MainWorktreeDetector.byCommonDir.has(commonDir)) {
-      return MainWorktreeDetector.byCommonDir.get(commonDir);
-    }
-
-    const result = spawnSync('git', ['-C', cwd, 'worktree', 'list', '--porcelain'], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 1000
-    });
-    if (result.status !== 0) {
-      warn(
-        `Could not inspect git worktrees while looking for main-worktree agents.local.json; ` +
-        `skipping that lookup (git exited with status ${result.status}).`
-      );
-      return null;
-    }
-
-    const lines = result.stdout.split('\n');
-    const mainWorktreePath = detectMainWorktreePath(lines, cwd, commonDir);
-    if (mainWorktreePath) {
-      if (commonDir) {MainWorktreeDetector.byCommonDir.set(commonDir, mainWorktreePath);}
-      return mainWorktreePath;
-    }
-
-    // Fallback: pick the first worktree whose HEAD points to main
-    let i = 0;
-    while (i < lines.length) {
-      if (lines[i].startsWith('worktree ')) {
-        const wt = lines[i].slice('worktree '.length).trim();
-        const branchLineIdx = i + 1;
-        if (branchLineIdx < lines.length && lines[branchLineIdx].startsWith('branch refs/heads/main')) {
-          if (commonDir) {MainWorktreeDetector.byCommonDir.set(commonDir, wt);}
-          return wt;
+    const { cwd = process.cwd(), warn = fmt.log.warn } = options;
+    try {
+        const commonDir = getGitPath(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+        if (commonDir && MainWorktreeDetector.byCommonDir.has(commonDir)) {
+            return MainWorktreeDetector.byCommonDir.get(commonDir);
+        }
+        const result = (0, node_child_process_1.spawnSync)('git', ['-C', cwd, 'worktree', 'list', '--porcelain'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 1000
+        });
+        if (result.status !== 0) {
+            warn(`Could not inspect git worktrees while looking for main-worktree agents.local.json; ` +
+                `skipping that lookup (git exited with status ${result.status}).`);
+            return null;
+        }
+        const lines = result.stdout.split('\n');
+        const mainWorktreePath = detectMainWorktreePath(lines, cwd, commonDir);
+        if (mainWorktreePath) {
+            if (commonDir) {
+                MainWorktreeDetector.byCommonDir.set(commonDir, mainWorktreePath);
+            }
+            return mainWorktreePath;
         }
-      }
-      i++;
-    }
-
-    // Last resort: the first worktree in the list that isn't the current cwd
-    for (i = 0; i < lines.length; i++) {
-      if (lines[i].startsWith('worktree ')) {
-        const wt = lines[i].slice('worktree '.length).trim();
-        if (wt !== cwd) {
-          if (commonDir) {MainWorktreeDetector.byCommonDir.set(commonDir, wt);}
-          return wt;
+        // Fallback: pick the first worktree whose HEAD points to main
+        let i = 0;
+        while (i < lines.length) {
+            if (lines[i].startsWith('worktree ')) {
+                const wt = lines[i].slice('worktree '.length).trim();
+                const branchLineIdx = i + 1;
+                if (branchLineIdx < lines.length && lines[branchLineIdx].startsWith('branch refs/heads/main')) {
+                    if (commonDir) {
+                        MainWorktreeDetector.byCommonDir.set(commonDir, wt);
+                    }
+                    return wt;
+                }
+            }
+            i++;
         }
-      }
-    }
-  } catch (/** @type {unknown} */ err) {
-    /** @type {Error & {code?: string}} */
-    const e = /** @type {any} */ (err);
-    const detail = e && (e.code || e.message) ? (e.code || e.message) : 'unknown error';
-    warn(
-      `Could not inspect git worktrees while looking for main-worktree agents.local.json; ` +
-      `skipping that lookup (${detail}).`
-    );
+        // Last resort: the first worktree in the list that isn't the current cwd
+        for (i = 0; i < lines.length; i++) {
+            if (lines[i].startsWith('worktree ')) {
+                const wt = lines[i].slice('worktree '.length).trim();
+                if (wt !== cwd) {
+                    if (commonDir) {
+                        MainWorktreeDetector.byCommonDir.set(commonDir, wt);
+                    }
+                    return wt;
+                }
+            }
+        }
+    }
+    catch (err) {
+        const e = err;
+        const detail = e && (e.code || e.message) ? (e.code || e.message) : 'unknown error';
+        warn(`Could not inspect git worktrees while looking for main-worktree agents.local.json; ` +
+            `skipping that lookup (${detail}).`);
+        return null;
+    }
+    warn('Could not determine the main worktree from `git worktree list --porcelain`; ' +
+        'skipping main-worktree agents.local.json lookup.');
     return null;
-  }
-
-  warn(
-    'Could not determine the main worktree from `git worktree list --porcelain`; ' +
-    'skipping main-worktree agents.local.json lookup.'
-  );
-  return null;
 }
-
 // Extract the known main worktree path from the repo metadata so worktree
 // iteration doesn't accidentally pick the current (non-main) worktree.
 // Cached per git common directory to avoid repeated subprocess calls without
 // leaking a temp-repo answer into later tests or nested workflow invocations.
 const MainWorktreeDetector = {
-  byCommonDir: new Map()
+    byCommonDir: new Map()
 };
-
-/** @param {string} cwd @param {string[]} args */
 function getGitPath(cwd, args) {
-  const result = spawnSync('git', ['-C', cwd, ...args], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-    timeout: 1000
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  return result.stdout.trim() || null;
+    const result = (0, node_child_process_1.spawnSync)('git', ['-C', cwd, ...args], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    return result.stdout.trim() || null;
 }
-
-/** @param {string[]} lines */
 function parseWorktreePaths(lines) {
-  return lines
-    .filter(/** @param {string} line */ (line) => line.startsWith('worktree '))
-    .map(/** @param {string} line */ (line) => line.slice('worktree '.length).trim())
-    .filter(Boolean);
+    return lines
+        .filter(/** @param {string} line */ (line) => line.startsWith('worktree '))
+        .map(/** @param {string} line */ (line) => line.slice('worktree '.length).trim())
+        .filter(Boolean);
 }
-
-/** @param {string[]} lines @param {string} cwd @param {string | null} commonDir */
 function detectMainWorktreePath(lines, cwd, commonDir) {
-  const worktrees = parseWorktreePaths(lines);
-  if (worktrees.length === 0) {
+    const worktrees = parseWorktreePaths(lines);
+    if (worktrees.length === 0) {
+        return null;
+    }
+    const resolvedCommonDir = commonDir ? node_path_1.default.resolve(commonDir) : null;
+    for (const wt of worktrees) {
+        const gitDir = getGitPath(wt, ['rev-parse', '--absolute-git-dir']);
+        const wtCommonDir = getGitPath(wt, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+        if (gitDir &&
+            wtCommonDir &&
+            node_path_1.default.resolve(gitDir) === node_path_1.default.resolve(wtCommonDir) &&
+            (!resolvedCommonDir || node_path_1.default.resolve(wtCommonDir) === resolvedCommonDir)) {
+            return wt;
+        }
+    }
+    const currentTopLevel = getGitPath(cwd, ['rev-parse', '--show-toplevel']);
+    if (currentTopLevel && worktrees.length === 1 && node_path_1.default.resolve(worktrees[0]) === node_path_1.default.resolve(currentTopLevel)) {
+        return worktrees[0];
+    }
     return null;
-  }
-
-  const resolvedCommonDir = commonDir ? path.resolve(commonDir) : null;
-  for (const wt of worktrees) {
-    const gitDir = getGitPath(wt, ['rev-parse', '--absolute-git-dir']);
-    const wtCommonDir = getGitPath(wt, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
-    if (
-      gitDir &&
-      wtCommonDir &&
-      path.resolve(gitDir) === path.resolve(wtCommonDir) &&
-      (!resolvedCommonDir || path.resolve(wtCommonDir) === resolvedCommonDir)
-    ) {
-      return wt;
-    }
-  }
-
-  const currentTopLevel = getGitPath(cwd, ['rev-parse', '--show-toplevel']);
-  if (currentTopLevel && worktrees.length === 1 && path.resolve(worktrees[0]) === path.resolve(currentTopLevel)) {
-    return worktrees[0];
-  }
-  return null;
 }
-
-/** @param {string | number} value */
 function parseBlockUntil(value) {
-  if (typeof value !== 'string') {
-    return NaN;
-  }
-
-  const match = value.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2})$/);
-  if (!match) {
-    return NaN;
-  }
-
-  const [, yearStr, monthStr, dayStr, hourStr] = match;
-  const year = Number(yearStr);
-  const month = Number(monthStr);
-  const day = Number(dayStr);
-  const hour = Number(hourStr);
-  const parsed = new Date(year, month - 1, day, hour, 0, 0, 0);
-
-  if (
-    parsed.getFullYear() !== year ||
-    parsed.getMonth() !== month - 1 ||
-    parsed.getDate() !== day ||
-    parsed.getHours() !== hour
-  ) {
-    return NaN;
-  }
-
-  return parsed.getTime();
+    if (typeof value !== 'string') {
+        return NaN;
+    }
+    const match = value.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2})$/);
+    if (!match) {
+        return NaN;
+    }
+    const [, yearStr, monthStr, dayStr, hourStr] = match;
+    const year = Number(yearStr);
+    const month = Number(monthStr);
+    const day = Number(dayStr);
+    const hour = Number(hourStr);
+    const parsed = new Date(year, month - 1, day, hour, 0, 0, 0);
+    if (parsed.getFullYear() !== year ||
+        parsed.getMonth() !== month - 1 ||
+        parsed.getDate() !== day ||
+        parsed.getHours() !== hour) {
+        return NaN;
+    }
+    return parsed.getTime();
 }
-
-/**
- * @param {string} agent
- * @param {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}} | null} config
- */
 function isAgentBlocked(agent, config) {
-  if (!config || !config.blocklist || config.blocklist[agent] === undefined) {
-    return false;
-  }
-  const entry = config.blocklist[agent];
-  if (entry === true) {return true;}
-  if (entry === false) {return false;}
-  if (entry && typeof entry === 'object') {
-    if (entry.blocked === true) {return true;}
-    if (entry.blocked === false) {return false;}
-    if (entry.until) {
-      const until = parseBlockUntil(entry.until);
-      if (!isNaN(until) && until > Date.now()) {
+    if (!config || !config.blocklist || config.blocklist[agent] === undefined) {
+        return false;
+    }
+    const entry = config.blocklist[agent];
+    if (entry === true) {
         return true;
-      }
     }
-  }
-  return false;
+    if (entry === false) {
+        return false;
+    }
+    if (entry && typeof entry === 'object') {
+        if (entry.blocked === true) {
+            return true;
+        }
+        if (entry.blocked === false) {
+            return false;
+        }
+        if (entry.until) {
+            const until = parseBlockUntil(entry.until);
+            if (!isNaN(until) && until > Date.now()) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
-
-/**
- * @param {string} step
- * @param {{config?: {blocklist?: {[key: string]: any}, steps?: {[key: string]: any}}, configPath?: string}} options
- */
 function eligibleAgentsForStep(step, options = {}) {
-  const /** @type {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}} | null} */ config = options.config !== undefined
-    ? options.config
-    : readAgentConfig(options.configPath || CONFIG_PATH, /** @type {{mergeLocal?: boolean, mainWorktreePath?: string | null, warn?: Function, targetPath?: string}} */ (options));
-  let eligible;
-  if (!config || !config.steps || !config.steps[step]) {
-    eligible = Object.keys(LAUNCHERS);
-  } else {
-    eligible = config.steps[step].eligible || Object.keys(LAUNCHERS);
-  }
-  return eligible.filter(/** @param {string} agent */ (agent) => !isAgentBlocked(agent, config));
+    const /** @type {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}} | null} */ config = options.config !== undefined
+        ? options.config
+        : readAgentConfig(options.configPath || CONFIG_PATH, options);
+    let eligible;
+    if (!config || !config.steps || !config.steps[step]) {
+        eligible = Object.keys(LAUNCHERS);
+    }
+    else {
+        eligible = config.steps[step].eligible || Object.keys(LAUNCHERS);
+    }
+    return eligible.filter(/** @param {string} agent */ (agent) => !isAgentBlocked(agent, config));
 }
-
-/** @param {string[]} agents @param {{[key: string]: number}} weights */
 function weightedRandom(agents, weights) {
-  const total = agents.reduce(/** @param {number} sum @param {string} a */ (sum, a) => sum + (weights[a] || 1), 0);
-  let r = Math.random() * total;
-  for (const agent of agents) {
-    r -= weights[agent] || 1;
-    if (r <= 0) {return agent;}
-  }
-  return agents[agents.length - 1];
+    const total = agents.reduce(/** @param {number} sum @param {string} a */ (sum, a) => sum + (weights[a] || 1), 0);
+    let r = Math.random() * total;
+    for (const agent of agents) {
+        r -= weights[agent] || 1;
+        if (r <= 0) {
+            return agent;
+        }
+    }
+    return agents[agents.length - 1];
 }
-
-/**
- * @param {string} step
- * @param {{exclude?: Set<string>, config?: {blocklist?: {[key: string]: any}, steps?: {[key: string]: any}}, configPath?: string}} options
- */
 function selectAgent(step, options = {}) {
-  const envOverride = process.env.WORKFLOW_AGENT;
-  const excluded = options.exclude instanceof Set ? options.exclude : new Set();
-  const eligible = eligibleAgentsForStep(step, options);
-  // Honor the env override only when it is in the current eligible-and-unblocked
-  // pool and not already excluded (a previous limit-hit attempt in the same
-  // startAgent retry loop). A pinned agent that is hard-blocked in
-  // agents.local.json or excluded by step eligibility falls through to normal
-  // selection — matches parallix/docs/agents.md, which documents that
-  // WORKFLOW_AGENT is honored alongside the eligibility config and blocklist.
-  if (envOverride && !excluded.has(envOverride) && eligible.includes(envOverride)) {
-    return envOverride;
-  }
-
-  const pool = eligible.filter(/** @param {string} agent */ (agent) => !excluded.has(agent));
-  if (eligible.length === 0) {
-    throw new Error(`No agents are eligible for workflow step: ${step}`);
-  }
-  if (pool.length === 0) {
-    throw new Error(
-      `All eligible agents for step "${step}" are exhausted (limit-hit or excluded). ` +
-      `Tried: ${[...excluded].join(', ')}.`
-    );
-  }
-
-  // Filter to agents that are both eligible (per config) and supported (launcher present).
-  const statuses = new Map(
-    pool
-      .filter(/** @param {string} agent */ (agent) => LAUNCHERS[agent])
-      .map(/** @param {string} agent */ (agent) => [agent, workflowLauncherStatus(agent)])
-  );
-  const available = pool.filter(/** @param {string} agent */ (agent) => {
-    const status = statuses.get(agent);
-    return Boolean(status && status.supported);
-  });
-  if (available.length === 0) {
-    const blockers = pool.map(/** @param {string} agent */ (agent) => {
-      const status = statuses.get(agent) || { detail: agent, reason: 'unsupported-agent' };
-      const suffix = status.reason ? `; ${status.reason}` : '';
-      return `${agent} (looked for: ${status.detail}${suffix})`;
+    const envOverride = process.env.WORKFLOW_AGENT;
+    const excluded = options.exclude instanceof Set ? options.exclude : new Set();
+    const eligible = eligibleAgentsForStep(step, options);
+    // Honor the env override only when it is in the current eligible-and-unblocked
+    // pool and not already excluded (a previous limit-hit attempt in the same
+    // startAgent retry loop). A pinned agent that is hard-blocked in
+    // agents.local.json or excluded by step eligibility falls through to normal
+    // selection — matches parallix/docs/agents.md, which documents that
+    // WORKFLOW_AGENT is honored alongside the eligibility config and blocklist.
+    if (envOverride && !excluded.has(envOverride) && eligible.includes(envOverride)) {
+        return envOverride;
+    }
+    const pool = eligible.filter(/** @param {string} agent */ (agent) => !excluded.has(agent));
+    if (eligible.length === 0) {
+        throw new Error(`No agents are eligible for workflow step: ${step}`);
+    }
+    if (pool.length === 0) {
+        throw new Error(`All eligible agents for step "${step}" are exhausted (limit-hit or excluded). ` +
+            `Tried: ${[...excluded].join(', ')}.`);
+    }
+    // Filter to agents that are both eligible (per config) and supported (launcher present).
+    const statuses = new Map(pool
+        .filter(/** @param {string} agent */ (agent) => LAUNCHERS[agent])
+        .map(/** @param {string} agent */ (agent) => [agent, workflowLauncherStatus(agent)]));
+    const available = pool.filter(/** @param {string} agent */ (agent) => {
+        const status = statuses.get(agent);
+        return Boolean(status && status.supported);
     });
-    throw new Error(
-      `No eligible agents have a working launcher for step "${step}". ` +
-      `Eligible but blocked: ${blockers.join(', ')}. ` +
-      `Set WORKFLOW_AGENT=<name> to override or install a supported agent.`
-    );
-  }
-
-  const /** @type {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}} | null} */ config = options.config !== undefined
-    ? options.config
-    : readAgentConfig(options.configPath || CONFIG_PATH, /** @type {{mergeLocal?: boolean, mainWorktreePath?: string | null, warn?: Function, targetPath?: string}} */ (options));
-  const stepConfig = config && config.steps && config.steps[step] ? config.steps[step] : {};
-  const selection = stepConfig.selection || 'random';
-
-  if (selection === 'weighted') {
-    const weights = stepConfig.weights || {};
-    return weightedRandom(available, weights);
-  }
-
-  if (selection === 'random') {
-    return available[Math.floor(Math.random() * available.length)];
-  }
-
-  return available[0];
+    if (available.length === 0) {
+        const blockers = pool.map(/** @param {string} agent */ (agent) => {
+            const status = statuses.get(agent) || { detail: agent, reason: 'unsupported-agent' };
+            const suffix = status.reason ? `; ${status.reason}` : '';
+            return `${agent} (looked for: ${status.detail}${suffix})`;
+        });
+        throw new Error(`No eligible agents have a working launcher for step "${step}". ` +
+            `Eligible but blocked: ${blockers.join(', ')}. ` +
+            `Set WORKFLOW_AGENT=<name> to override or install a supported agent.`);
+    }
+    const /** @type {{blocklist?: {[key: string]: any}, steps?: {[key: string]: any}} | null} */ config = options.config !== undefined
+        ? options.config
+        : readAgentConfig(options.configPath || CONFIG_PATH, options);
+    const stepConfig = config && config.steps && config.steps[step] ? config.steps[step] : {};
+    const selection = stepConfig.selection || 'random';
+    if (selection === 'weighted') {
+        const weights = stepConfig.weights || {};
+        return weightedRandom(available, weights);
+    }
+    if (selection === 'random') {
+        return available[Math.floor(Math.random() * available.length)];
+    }
+    return available[0];
 }
-
-/** @param {string} agent */
 function assertAgentSupported(agent) {
-  if (!LAUNCHERS[agent]) {
-    /** @type {any} */
-    const error = new Error(
-      `Unknown agent: "${fmt.agent(agent)}". Supported agents: ${Object.keys(LAUNCHERS).join(', ')}.`
-    );
-    error.code = 'UNKNOWN_AGENT';
-    throw error;
-  }
-
-  const status = workflowLauncherStatus(agent);
-  if (!status.supported) {
-    const health = status.health ? ` (${status.health})` : '';
-    const reason = status.reason ? `; reason: ${status.reason}` : '';
-    /** @type {any} */
-    const error = new Error(
-      `Agent "${fmt.agent(agent)}" launcher is not available on this workstation${health}. ` +
-      `Looked for: ${fmt.path(status.detail)}${reason}. ` +
-      `Ensure ${fmt.agent(agent)} is on your PATH and retry.`
-    );
-    error.code = 'LAUNCHER_UNAVAILABLE';
-    throw error;
-  }
+    if (!LAUNCHERS[agent]) {
+        const error = new Error(`Unknown agent: "${fmt.agent(agent)}". Supported agents: ${Object.keys(LAUNCHERS).join(', ')}.`);
+        error.code = 'UNKNOWN_AGENT';
+        throw error;
+    }
+    const status = workflowLauncherStatus(agent);
+    if (!status.supported) {
+        const health = status.health ? ` (${status.health})` : '';
+        const reason = status.reason ? `; reason: ${status.reason}` : '';
+        const error = new Error(`Agent "${fmt.agent(agent)}" launcher is not available on this workstation${health}. ` +
+            `Looked for: ${fmt.path(status.detail)}${reason}. ` +
+            `Ensure ${fmt.agent(agent)} is on your PATH and retry.`);
+        error.code = 'LAUNCHER_UNAVAILABLE';
+        throw error;
+    }
 }
-
-/** @param {{targetPath?: string}} options */
 function resolveBlocklistTargetPath(options = {}) {
-  if (options.targetPath) {return options.targetPath;}
-  return storage.resolveAgentsLocalPath({ ensureDir: true });
+    if (options.targetPath) {
+        return options.targetPath;
+    }
+    return storage.resolveAgentsLocalPath({ ensureDir: true });
 }
-
-/** @param {string} agent @param {string} until @param {{targetPath?: string}} options */
 function updateAgentBlock(agent, until, options = {}) {
-  if (!agent || typeof agent !== 'string') {
-    throw new Error('updateAgentBlock requires an agent name');
-  }
-  if (!until || typeof until !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}$/.test(until)) {
-    throw new Error(`updateAgentBlock requires an "YYYY-MM-DD HH" timestamp; got: ${until}`);
-  }
-
-  const targetPath = resolveBlocklistTargetPath(options);
-
-  /** @type {{blocklist?: {[key: string]: any}}} */
-  let payload = {};
-  if (fs.existsSync(targetPath)) {
-    // Match the read-path contract (parseAgentConfigFile): malformed local agent
-    // JSON is a hard failure, not a silent overwrite. Otherwise a limit hit on a
-    // corrupted agents.local.json would destroy whatever was on disk.
-    try {
-      payload = JSON.parse(fs.readFileSync(targetPath, 'utf8')) || {};
-    } catch (/** @type {unknown} */ err) {
-      throw buildInvalidAgentConfigError(targetPath, 'local', /** @type {{message?: string}} */ (err));
-    }
-    if (typeof payload !== 'object' || Array.isArray(payload)) {
-      throw buildInvalidAgentConfigError(
-        targetPath,
-        'local',
-        new Error('expected a JSON object at the file root')
-      );
-    }
-  }
-  if (!payload.blocklist || typeof payload.blocklist !== 'object' || Array.isArray(payload.blocklist)) {
-    payload.blocklist = {};
-  }
-  payload.blocklist[agent] = { until };
-
-  storage.writeJson(targetPath, payload);
-  return { path: targetPath, blocklist: payload.blocklist };
+    if (!agent || typeof agent !== 'string') {
+        throw new Error('updateAgentBlock requires an agent name');
+    }
+    if (!until || typeof until !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}$/.test(until)) {
+        throw new Error(`updateAgentBlock requires an "YYYY-MM-DD HH" timestamp; got: ${until}`);
+    }
+    const targetPath = resolveBlocklistTargetPath(options);
+    let payload = {};
+    if (node_fs_1.default.existsSync(targetPath)) {
+        // Match the read-path contract (parseAgentConfigFile): malformed local agent
+        // JSON is a hard failure, not a silent overwrite. Otherwise a limit hit on a
+        // corrupted agents.local.json would destroy whatever was on disk.
+        try {
+            payload = JSON.parse(node_fs_1.default.readFileSync(targetPath, 'utf8')) || {};
+        }
+        catch (err) {
+            throw buildInvalidAgentConfigError(targetPath, 'local', err);
+        }
+        if (typeof payload !== 'object' || Array.isArray(payload)) {
+            throw buildInvalidAgentConfigError(targetPath, 'local', new Error('expected a JSON object at the file root'));
+        }
+    }
+    if (!payload.blocklist || typeof payload.blocklist !== 'object' || Array.isArray(payload.blocklist)) {
+        payload.blocklist = {};
+    }
+    payload.blocklist[agent] = { until };
+    storage.writeJson(targetPath, payload);
+    return { path: targetPath, blocklist: payload.blocklist };
 }
-
-/** @param {string} agent */
 function defaultIsAgentBlockedNow(agent) {
-  try {
-    const config = readAgentConfig(CONFIG_PATH, {});
-    return isAgentBlocked(agent, config);
-  } catch (/** @type {unknown} */ err) {
-    // If the config is malformed, surface that through the launcher path
-    // (assertAgentSupported / launch) instead of silently rerouting. Treat as
-    // not-blocked here so the existing error path runs.
-    return false;
-  }
+    try {
+        const config = readAgentConfig(CONFIG_PATH, {});
+        return isAgentBlocked(agent, config);
+    }
+    catch (err) {
+        // If the config is malformed, surface that through the launcher path
+        // (assertAgentSupported / launch) instead of silently rerouting. Treat as
+        // not-blocked here so the existing error path runs.
+        return false;
+    }
 }
-
-/** @param {string} name */
 function readPositiveMsEnv(name) {
-  const raw = process.env[name];
-  if (raw === undefined || raw === '') {return null;}
-  const value = Number(raw);
-  return Number.isFinite(value) && value >= 0 ? value : null;
+    const raw = process.env[name];
+    if (raw === undefined || raw === '') {
+        return null;
+    }
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : null;
 }
-
-/** @param {{initialDelayMs?: number, intervalMs?: number}|boolean} config @param {string | null} step */
 function resolveNoOutputWatchdogConfig(config, step = null) {
-  if (config === false || process.env.WORKFLOW_AGENT_NO_OUTPUT_WATCHDOG === '0') {
-    return null;
-  }
-  const /** @type {{initialDelayMs?: number, intervalMs?: number}} */ explicit = config && typeof config === 'object' ? config : {};
-  // Draft gets a shorter default watchdog to surface agent-launch visibility
-  // quickly; the generic default (60s) is too slow for the draft entrypoint
-  // where an operator cannot tell launch from hang.
-  let initialDelayMs;
-  let intervalMs;
-  if (step === 'draft') {
-    initialDelayMs = explicit.initialDelayMs ??
-      readPositiveMsEnv('WORKFLOW_DRAFT_AGENT_NO_OUTPUT_INITIAL_MS') ??
-      DRAFT_NO_OUTPUT_INITIAL_DELAY_MS;
-    intervalMs = explicit.intervalMs ??
-      readPositiveMsEnv('WORKFLOW_DRAFT_AGENT_NO_OUTPUT_INTERVAL_MS') ??
-      DRAFT_NO_OUTPUT_INTERVAL_MS;
-  } else {
-    initialDelayMs = explicit.initialDelayMs ??
-      readPositiveMsEnv('WORKFLOW_AGENT_NO_OUTPUT_INITIAL_MS') ??
-      DEFAULT_NO_OUTPUT_INITIAL_DELAY_MS;
-    intervalMs = explicit.intervalMs ??
-      readPositiveMsEnv('WORKFLOW_AGENT_NO_OUTPUT_INTERVAL_MS') ??
-      DEFAULT_NO_OUTPUT_INTERVAL_MS;
-  }
-  return { initialDelayMs, intervalMs };
+    if (config === false || process.env.WORKFLOW_AGENT_NO_OUTPUT_WATCHDOG === '0') {
+        return null;
+    }
+    const explicit = config && typeof config === 'object' ? config : {};
+    // Draft gets a shorter default watchdog to surface agent-launch visibility
+    // quickly; the generic default (60s) is too slow for the draft entrypoint
+    // where an operator cannot tell launch from hang.
+    let initialDelayMs;
+    let intervalMs;
+    if (step === 'draft') {
+        initialDelayMs = explicit.initialDelayMs ??
+            readPositiveMsEnv('WORKFLOW_DRAFT_AGENT_NO_OUTPUT_INITIAL_MS') ??
+            DRAFT_NO_OUTPUT_INITIAL_DELAY_MS;
+        intervalMs = explicit.intervalMs ??
+            readPositiveMsEnv('WORKFLOW_DRAFT_AGENT_NO_OUTPUT_INTERVAL_MS') ??
+            DRAFT_NO_OUTPUT_INTERVAL_MS;
+    }
+    else {
+        initialDelayMs = explicit.initialDelayMs ??
+            readPositiveMsEnv('WORKFLOW_AGENT_NO_OUTPUT_INITIAL_MS') ??
+            DEFAULT_NO_OUTPUT_INITIAL_DELAY_MS;
+        intervalMs = explicit.intervalMs ??
+            readPositiveMsEnv('WORKFLOW_AGENT_NO_OUTPUT_INTERVAL_MS') ??
+            DEFAULT_NO_OUTPUT_INTERVAL_MS;
+    }
+    return { initialDelayMs, intervalMs };
 }
-
-/** @param {number} elapsedMs */
 function formatElapsed(elapsedMs) {
-  const seconds = Math.max(0, Math.round(elapsedMs / 1000));
-  if (seconds < 60) {return `${seconds}s`;}
-  const minutes = Math.floor(seconds / 60);
-  const remainder = seconds % 60;
-  return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+    const seconds = Math.max(0, Math.round(elapsedMs / 1000));
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainder = seconds % 60;
+    return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
 }
-
-/**
- * @param {string} step
- * @param {{prompt: string | Function, worktree?: string, agent?: string, env?: {[key: string]: string}, exclude?: (string|null|Set<string>)[], onLimitHit?: Function, onLaunch?: Function, slug?: string | null, role?: string | null, detectLimitHitFn?: Function, updateAgentBlockFn?: Function, selectAgentFn?: Function, resolveAgentModelFn?: Function, isAgentBlockedFn?: Function, sessionsModule?: object, log?: Function, noOutputWatchdog?: {initialDelayMs?: number, intervalMs?: number}}} opts
- */
 async function startAgent(step, opts = { prompt: '' }) {
-  const {
-    prompt,
-    worktree,
-    agent: agentOverride,
-    env = {},
-    exclude = [],
-    onLimitHit,
-    onLaunch,
-    slug = null,
-    role = null,
-    detectLimitHitFn = detectLimitHit,
-    updateAgentBlockFn = updateAgentBlock,
-    selectAgentFn = selectAgent,
-    resolveAgentModelFn = resolveAgentModel,
-    isAgentBlockedFn = defaultIsAgentBlockedNow,
-    sessionsModule = sessions,
-    log = fmt.log.plain,
-    noOutputWatchdog = {}
-  } = opts;
-
-  // `exclude` seeds the tried-set so callers can reserve agents (e.g. exclude
-  // the current implementer from reviewer fallback to preserve family separation).
-  const excludeIterable = exclude instanceof Set ? exclude : exclude;
-  const tried = new Set(excludeIterable);
-  // Track per-agent failure details for accurate exhaustion diagnostics (SC 3)
-  const agentErrors = new Map();
-  // Track agents actually launched (not just pre-excluded) for accurate reporting
-  const launched = new Set();
-  let iteration = 0;
-  let chosen = agentOverride;
-
-  while (true) {
-    iteration += 1;
-    if (!chosen) {
-      try {
-        chosen = selectAgentFn(step, { exclude: tried });
-      } catch (/** @type {unknown} */ err) {
-        // Only catch pool exhaustion errors from selectAgent.
-        // Configuration errors (no eligible agents, no working launcher) must
-        // propagate unchanged to preserve diagnostics (SC 3).
-        // Exhaustion is indicated by:
-        // - "exhausted" from real selectAgent pool exhaustion ("are exhausted")
-        // - "No agents available" from test mocks simulating exhaustion
-        if (!(/** @type {any} */ (err).message || '').includes('exhausted') &&
-          !(/** @type {any} */ (err).message || '').includes('No agents available')
-        ) {
-          throw err;
+    const { prompt, worktree, agent: agentOverride, env = {}, exclude = [], onLimitHit, onLaunch, slug = null, role = null, detectLimitHitFn = limit_hit_js_1.detectLimitHit, updateAgentBlockFn = updateAgentBlock, selectAgentFn = selectAgent, resolveAgentModelFn = product_config_js_1.resolveAgentModel, isAgentBlockedFn = defaultIsAgentBlockedNow, sessionsModule = sessions, log = fmt.log.plain, noOutputWatchdog = {} } = opts;
+    // `exclude` seeds the tried-set so callers can reserve agents (e.g. exclude
+    // the current implementer from reviewer fallback to preserve family separation).
+    const excludeIterable = exclude instanceof Set ? exclude : exclude;
+    const tried = new Set(excludeIterable);
+    // Track per-agent failure details for accurate exhaustion diagnostics (SC 3)
+    const agentErrors = new Map();
+    // Track agents actually launched (not just pre-excluded) for accurate reporting
+    const launched = new Set();
+    let iteration = 0;
+    let chosen = agentOverride;
+    while (true) {
+        iteration += 1;
+        if (!chosen) {
+            try {
+                chosen = selectAgentFn(step, { exclude: tried });
+            }
+            catch (err) {
+                // Only catch pool exhaustion errors from selectAgent.
+                // Configuration errors (no eligible agents, no working launcher) must
+                // propagate unchanged to preserve diagnostics (SC 3).
+                // Exhaustion is indicated by:
+                // - "exhausted" from real selectAgent pool exhaustion ("are exhausted")
+                // - "No agents available" from test mocks simulating exhaustion
+                if (!(err.message || '').includes('exhausted') &&
+                    !(err.message || '').includes('No agents available')) {
+                    throw err;
+                }
+                // Pool exhausted; build clear exhaustion diagnostics with per-agent errors (SC 3)
+                const errorDetails = [...agentErrors.entries()].map(([agent, details]) => {
+                    const status = details.exitInfo === 'stalled'
+                        ? 'stalled (no output)'
+                        : (details.status !== undefined && details.status !== null
+                            ? `exit ${details.status}`
+                            : (details.signal ? `signal ${details.signal}` : 'unknown'));
+                    const stderrSnippet = details.stderr ? ` (${details.stderr.trim().split('\n')[0]})` : '';
+                    return `${agent}: ${status}${stderrSnippet}`;
+                }).join('; ');
+                const launchedList = [...launched].join(', ');
+                throw new Error(`All eligible agents exhausted for step "${step}". ` +
+                    `Tried: ${launchedList}. Errors: ${errorDetails}.`);
+            }
         }
-        // Pool exhausted; build clear exhaustion diagnostics with per-agent errors (SC 3)
-        const errorDetails = [...agentErrors.entries()].map(([agent, details]) => {
-          const status = details.exitInfo === 'stalled'
-            ? 'stalled (no output)'
-            : (details.status !== undefined && details.status !== null
-              ? `exit ${details.status}`
-              : (details.signal ? `signal ${details.signal}` : 'unknown'));
-          const stderrSnippet = details.stderr ? ` (${details.stderr.trim().split('\n')[0]})` : '';
-          return `${agent}: ${status}${stderrSnippet}`;
-        }).join('; ');
-        const launchedList = [...launched].join(', ');
-        throw new Error(
-          `All eligible agents exhausted for step "${step}". ` +
-          `Tried: ${launchedList}. Errors: ${errorDetails}.`
-        );
-      }
-    } else if (isAgentBlockedFn(chosen)) {
-      // Pre-launch blocklist gate. An explicit `agent:` override (e.g. a pinned
-      // reviewer/implementer carried over from review-state.json) bypasses
-      // selectAgent's blocklist filter. Without this check, a known-blocked
-      // family is relaunched immediately and the harness wastes a retry hitting
-      // the same limit. Reroute through normal selection on the next iteration.
-      log(fmt.status('WARN', `Pinned agent "${fmt.agent(chosen)}" is currently blocked in agents.local.json; rerouting via selectAgent for step "${step}".`));
-      tried.add(chosen);
-      chosen = undefined;
-      continue;
-    }
-
-    try {
-      assertAgentSupported(chosen || '');
-    } catch (/** @type {unknown} */ err) {
-      /** @type {Error & {code?: string}} */
-      const e = /** @type {any} */ (err);
-      if (e.code !== 'LAUNCHER_UNAVAILABLE') {
-        throw err;
-      }
-      log(fmt.status('WARN', /** @type {any} */ (err).message));
-      // Only reroute for launcher-availability failures (missing or probe-failed).
-      tried.add(chosen || '');
-      // If the caller pinned a specific agent, allow one retry that ignores
-      // the override and falls back to normal selection (matches limit-hit logic).
-      if (agentOverride && agentOverride === chosen && iteration === 1) {
-        chosen = undefined;
-        continue;
-      }
-      chosen = undefined;
-      continue;
-    }
-    tried.add(chosen || '');
-    launched.add(chosen || '');
-
-    const launcher = LAUNCHERS[chosen || ''];
-    log(fmt.status('INFO', `Selected agent for step "${step}": ${fmt.agent(chosen || '')}${iteration > 1 ? ` (attempt ${iteration})` : ''}`));
-
-    // Enforce the agent family as the Forgejo identity (ADR 0029 / task-095).
-    // FORGEJO_USER is set last so the harness-selected identity always wins;
-    // a caller-supplied env.FORGEJO_USER cannot override it.
-    const agentEnv = { ...env, FORGEJO_USER: chosen };
-
-    // Decide whether to resume the agent's prior session for this (slug, role).
-    // Only honored when the caller passed slug+role+worktree AND the previous
-    // marker matches the chosen agent family (a fallback to a different family
-    // invalidates the prior session).
-    const resume = Boolean(
-      worktree && slug && role &&
-      RESUME_CAPABLE.has(chosen || '') &&
-      (/** @type {any} */ (sessionsModule)).shouldResume(worktree, slug, role, chosen || '')
-    );
-    const sessionId = (/** @type {any} */ (sessionsModule)).getSessionId(worktree, slug, role);
-    if (slug && role) {
-      if (resume) {
-        log(fmt.status('INFO', `Resuming ${fmt.agent(chosen || '')} session for ${fmt.slug(slug)} (${role}).${sessionId ? ` Session: ${sessionId}` : ''}`));
-      } else if (RESUME_CAPABLE.has(chosen || '')) {
-        log(fmt.status('INFO', `No prior ${fmt.agent(chosen || '')} session for ${fmt.slug(slug)} (${role}); launching fresh.`));
-      }
-    }
-
-    // Resolve the prompt string. If a function was provided, call it with the
-    // currently chosen agent name (TASK-1051). This ensures that if startAgent
-    // falls back to a different family after a limit hit, the fallback agent
-    // receives a prompt tailored to its own identity.
-    const actualPrompt = typeof prompt === 'function' ? prompt(chosen) : prompt;
-
-    // Resolve the per-family model override (adapters.agents.models[chosen]).
-    // null when the family is not configured, in which case the launcher omits
-    // the model flag entirely and the agent uses its own default.
-    const model = resolveAgentModelFn(chosen || '', worktree || process.cwd());
-    if (model) {
-      log(fmt.status('INFO', `Using configured model for ${fmt.agent(chosen || '')}: ${model}`));
-    }
-
-    const watchdogConfig = resolveNoOutputWatchdogConfig(noOutputWatchdog, step);
-    const launchResult = launcher({
-      prompt: actualPrompt,
-      worktree,
-      env: agentEnv,
-      resume,
-      sessionId,
-      model,
-      slug,
-      role,
-      teeOptions: watchdogConfig ? {
-        noOutputWatchdog: {
-          ...watchdogConfig,
-          onNoOutput: (/** @type {{pid: number, elapsedMs: number}} */ evt) => {
-            const stage = evt.elapsedMs < (step === 'draft' ? DRAFT_NO_OUTPUT_INITIAL_DELAY_MS : DEFAULT_NO_OUTPUT_INITIAL_DELAY_MS)
-              ? 'starting up'
-              : 'running';
-            log(fmt.status(
-              'INFO',
-              `No output yet from ${fmt.agent(chosen || '')} for step "${step}" after ${formatElapsed(evt.elapsedMs)} ` +
-              `(pid ${evt.pid || 'unknown'}, agent ${stage}). ` +
-              `Launcher is still running; stdout/stderr have not produced visible output.`
-            ));
-          }
+        else if (isAgentBlockedFn(chosen)) {
+            // Pre-launch blocklist gate. An explicit `agent:` override (e.g. a pinned
+            // reviewer/implementer carried over from review-state.json) bypasses
+            // selectAgent's blocklist filter. Without this check, a known-blocked
+            // family is relaunched immediately and the harness wastes a retry hitting
+            // the same limit. Reroute through normal selection on the next iteration.
+            log(fmt.status('WARN', `Pinned agent "${fmt.agent(chosen)}" is currently blocked in agents.local.json; rerouting via selectAgent for step "${step}".`));
+            tried.add(chosen);
+            chosen = undefined;
+            continue;
         }
-      } : {}
-    });
-    const { invocation, resultPromise } = launchResult;
-    if (invocation) {
-      log(fmt.status('INFO', `Launching: ${fmt.command(`${invocation.command} ${invocation.args.join(' ')}`)}`));
-      if (invocation.options && invocation.options.cwd) {
-        log(fmt.status('INFO', `Working directory: ${fmt.path(invocation.options.cwd)}`));
-      }
-    }
-
-    if (onLaunch) {
-      await onLaunch({ agent: chosen, invocation });
-    }
-
-    const result = resultPromise ? await resultPromise : launchResult.result;
-
-    // Pass exit metadata so detectLimitHit only treats matching transcript text
-    // as a real limit hit when the launcher actually failed. A successful run
-    // (status === 0) that happens to contain limit-hit phrases — for example,
-    // an agent reviewing code or logs that quote those phrases — must not block
-    // the healthy agent.
-    const limitHit = detectLimitHitFn({
-      agent: chosen,
-      stdout: result && result.stdout,
-      stderr: result && result.stderr,
-      status: result && result.status,
-      signal: result && result.signal,
-      error: result && result.error
-    });
-
-    if (limitHit) {
-      log(fmt.status('WARN', `Limit hit detected for ${fmt.agent(chosen || '')}; reset estimate "${limitHit.until}" (${limitHit.source}). Blocking and retrying.`));
-      try {
-        const blockResult = updateAgentBlockFn(chosen || '', limitHit.until);
-        log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)}`));
-      } catch (/** @type {unknown} */ err) {
-        log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${/** @type {any} */ (err).message}`));
-      }
-      if (typeof onLimitHit === 'function') {
-        onLimitHit({ agent: chosen, until: limitHit.until, source: limitHit.source });
-      }
-      // Reset chosen so next iteration reselects, but only when no explicit override.
-      // If the caller pinned a specific agent, fail loudly — there is no fallback.
-      if (agentOverride && agentOverride === chosen && iteration === 1) {
-        // Allow one retry that ignores the override.
-        chosen = undefined;
-        continue;
-      }
-      chosen = undefined;
-      continue;
-    }
-
-    // Reroute if the launcher binary could not be started (ENOENT = not found, EACCES = not executable).
-    if (result && result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {
-      log(fmt.status('WARN', `Launcher for "${chosen || ''}" could not be started (${result.error.code}); rerouting.`));
-      tried.add(chosen || '');
-      if (agentOverride && agentOverride === chosen && iteration === 1) {
-        chosen = undefined;
-        continue;
-      }
-      chosen = undefined;
-      continue;
-    }
-
-    // Detect launch failure: agent started but exited with non-zero status and
-    // no limit-hit was detected. This catches errors like "Model not found" in
-    // opencode that cause the launcher to exit immediately with an error code.
-    // Retry with the next eligible agent instead of returning the failure.
-    // Only treat `status !== null && status !== 0` or `signal` (with no spawn
-    // error) as a launch failure; `status: null` without signal is ambiguous
-    // (spawn-tee close event can emit null code) and should not trigger a retry.
-    // Spurious opencode v2.0.0 JSON-mode exits (exit 1 after a valid
-    // "reason":"stop" completion) are excluded — the agent completed, the
-    // non-zero code is a post-run cleanup race.
-    const launchFailed = result &&
-      ((result.status !== null && result.status !== 0) || (result.signal && !result.error)) &&
-      !limitHit &&
-      !isSpuriousOpencodeExit(result);
-    if (launchFailed) {
-      const exitInfo = result.signal
-        ? `signal ${result.signal}`
-        : `exit ${result.status}`;
-      const stderrSnippet = result && result.stderr
-        ? ` (${result.stderr.trim().split('\n')[0]})`
-        : '';
-      log(fmt.status('WARN', `Agent ${fmt.agent(chosen || '')} failed to complete (${exitInfo}${stderrSnippet}); retrying with next eligible agent.`));
-      agentErrors.set(chosen || '', {
-        exitInfo,
-        stderr: result.stderr,
-        stdout: result.stdout,
-        signal: result.signal,
-        status: result.status,
-      });
-      tried.add(chosen || '');
-      launched.add(chosen || '');
-      // Block non-custom agents on non-limit failures so selectAgent excludes them
-      // on the next retry iteration, and the review-loop fallback path can activate.
-      // custom (opencode/local AI) is excluded — exit 1 is a temporary local error.
-      if (chosen !== 'custom') {
-        const blockUntil = formatBlockUntil(new Date(Date.now() + DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000));
         try {
-          const blockResult = updateAgentBlockFn(chosen || '', blockUntil);
-          log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${DEFAULT_FALLBACK_HOURS}h block)`));
-        } catch (/** @type {unknown} */ err) {
-          log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${/** @type {any} */ (err).message}`));
+            assertAgentSupported(chosen || '');
+        }
+        catch (err) {
+            /** @type {Error & {code?: string}} */
+            const e = err;
+            if (e.code !== 'LAUNCHER_UNAVAILABLE') {
+                throw err;
+            }
+            log(fmt.status('WARN', err.message));
+            // Only reroute for launcher-availability failures (missing or probe-failed).
+            tried.add(chosen || '');
+            // If the caller pinned a specific agent, allow one retry that ignores
+            // the override and falls back to normal selection (matches limit-hit logic).
+            if (agentOverride && agentOverride === chosen && iteration === 1) {
+                chosen = undefined;
+                continue;
+            }
+            chosen = undefined;
+            continue;
         }
-      }
-      chosen = undefined;
-      continue;
-    }
-    // Record the marker so a subsequent same-(slug, role) launch knows which
-    // family last ran here. We only persist when the run exited cleanly
-    // (status 0 and no spawn error); a failed launch should not overwrite
-    // the canonical session marker with a stale transcript.
-    if (worktree && slug && role && result && result.status === 0 && !result.error) {
-      try {
-        const sessionId = result && result.sessionId ? result.sessionId : null;
-        (/** @type {any} */ (sessionsModule)).writeSession(worktree, slug, role, { agent: chosen || '', sessionId });
-      } catch (/** @type {unknown} */ err) {
-        log(fmt.status('WARN', `Could not persist session marker for ${fmt.slug(slug)} (${role}): ${/** @type {any} */ (err).message}`));
-      }
-    }
-
-    return { agent: chosen, invocation, result };
-  }
+        tried.add(chosen || '');
+        launched.add(chosen || '');
+        const launcher = LAUNCHERS[chosen || ''];
+        log(fmt.status('INFO', `Selected agent for step "${step}": ${fmt.agent(chosen || '')}${iteration > 1 ? ` (attempt ${iteration})` : ''}`));
+        // Enforce the agent family as the Forgejo identity (ADR 0029 / task-095).
+        // FORGEJO_USER is set last so the harness-selected identity always wins;
+        // a caller-supplied env.FORGEJO_USER cannot override it.
+        const agentEnv = { ...env, FORGEJO_USER: chosen };
+        // Decide whether to resume the agent's prior session for this (slug, role).
+        // Only honored when the caller passed slug+role+worktree AND the previous
+        // marker matches the chosen agent family (a fallback to a different family
+        // invalidates the prior session).
+        const resume = Boolean(worktree && slug && role &&
+            RESUME_CAPABLE.has(chosen || '') &&
+            sessionsModule.shouldResume(worktree, slug, role, chosen || ''));
+        const sessionId = sessionsModule.getSessionId(worktree, slug, role);
+        if (slug && role) {
+            if (resume) {
+                log(fmt.status('INFO', `Resuming ${fmt.agent(chosen || '')} session for ${fmt.slug(slug)} (${role}).${sessionId ? ` Session: ${sessionId}` : ''}`));
+            }
+            else if (RESUME_CAPABLE.has(chosen || '')) {
+                log(fmt.status('INFO', `No prior ${fmt.agent(chosen || '')} session for ${fmt.slug(slug)} (${role}); launching fresh.`));
+            }
+        }
+        // Resolve the prompt string. If a function was provided, call it with the
+        // currently chosen agent name (TASK-1051). This ensures that if startAgent
+        // falls back to a different family after a limit hit, the fallback agent
+        // receives a prompt tailored to its own identity.
+        const actualPrompt = typeof prompt === 'function' ? prompt(chosen) : prompt;
+        // Resolve the per-family model override (adapters.agents.models[chosen]).
+        // null when the family is not configured, in which case the launcher omits
+        // the model flag entirely and the agent uses its own default.
+        const model = resolveAgentModelFn(chosen || '', worktree || process.cwd());
+        if (model) {
+            log(fmt.status('INFO', `Using configured model for ${fmt.agent(chosen || '')}: ${model}`));
+        }
+        const watchdogConfig = resolveNoOutputWatchdogConfig(noOutputWatchdog, step);
+        const launchResult = launcher({
+            prompt: actualPrompt,
+            worktree,
+            env: agentEnv,
+            resume,
+            sessionId,
+            model,
+            slug,
+            role,
+            teeOptions: watchdogConfig ? {
+                noOutputWatchdog: {
+                    ...watchdogConfig,
+                    onNoOutput: (evt) => {
+                        const stage = evt.elapsedMs < (step === 'draft' ? DRAFT_NO_OUTPUT_INITIAL_DELAY_MS : DEFAULT_NO_OUTPUT_INITIAL_DELAY_MS)
+                            ? 'starting up'
+                            : 'running';
+                        log(fmt.status('INFO', `No output yet from ${fmt.agent(chosen || '')} for step "${step}" after ${formatElapsed(evt.elapsedMs)} ` +
+                            `(pid ${evt.pid || 'unknown'}, agent ${stage}). ` +
+                            `Launcher is still running; stdout/stderr have not produced visible output.`));
+                    }
+                }
+            } : {}
+        });
+        const { invocation, resultPromise } = launchResult;
+        if (invocation) {
+            log(fmt.status('INFO', `Launching: ${fmt.command(`${invocation.command} ${invocation.args.join(' ')}`)}`));
+            if (invocation.options && invocation.options.cwd) {
+                log(fmt.status('INFO', `Working directory: ${fmt.path(invocation.options.cwd)}`));
+            }
+        }
+        if (onLaunch) {
+            await onLaunch({ agent: chosen, invocation });
+        }
+        const result = resultPromise ? await resultPromise : launchResult.result;
+        // Pass exit metadata so detectLimitHit only treats matching transcript text
+        // as a real limit hit when the launcher actually failed. A successful run
+        // (status === 0) that happens to contain limit-hit phrases — for example,
+        // an agent reviewing code or logs that quote those phrases — must not block
+        // the healthy agent.
+        const limitHit = detectLimitHitFn({
+            agent: chosen,
+            stdout: result && result.stdout,
+            stderr: result && result.stderr,
+            status: result && result.status,
+            signal: result && result.signal,
+            error: result && result.error
+        });
+        if (limitHit) {
+            log(fmt.status('WARN', `Limit hit detected for ${fmt.agent(chosen || '')}; reset estimate "${limitHit.until}" (${limitHit.source}). Blocking and retrying.`));
+            try {
+                const blockResult = updateAgentBlockFn(chosen || '', limitHit.until);
+                log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)}`));
+            }
+            catch (err) {
+                log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${err.message}`));
+            }
+            if (typeof onLimitHit === 'function') {
+                onLimitHit({ agent: chosen, until: limitHit.until, source: limitHit.source });
+            }
+            // Reset chosen so next iteration reselects, but only when no explicit override.
+            // If the caller pinned a specific agent, fail loudly — there is no fallback.
+            if (agentOverride && agentOverride === chosen && iteration === 1) {
+                // Allow one retry that ignores the override.
+                chosen = undefined;
+                continue;
+            }
+            chosen = undefined;
+            continue;
+        }
+        // Reroute if the launcher binary could not be started (ENOENT = not found, EACCES = not executable).
+        if (result && result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {
+            log(fmt.status('WARN', `Launcher for "${chosen || ''}" could not be started (${result.error.code}); rerouting.`));
+            tried.add(chosen || '');
+            if (agentOverride && agentOverride === chosen && iteration === 1) {
+                chosen = undefined;
+                continue;
+            }
+            chosen = undefined;
+            continue;
+        }
+        // Detect launch failure: agent started but exited with non-zero status and
+        // no limit-hit was detected. This catches errors like "Model not found" in
+        // opencode that cause the launcher to exit immediately with an error code.
+        // Retry with the next eligible agent instead of returning the failure.
+        // Only treat `status !== null && status !== 0` or `signal` (with no spawn
+        // error) as a launch failure; `status: null` without signal is ambiguous
+        // (spawn-tee close event can emit null code) and should not trigger a retry.
+        // Spurious opencode v2.0.0 JSON-mode exits (exit 1 after a valid
+        // "reason":"stop" completion) are excluded — the agent completed, the
+        // non-zero code is a post-run cleanup race.
+        const launchFailed = result &&
+            ((result.status !== null && result.status !== 0) || (result.signal && !result.error)) &&
+            !limitHit &&
+            !(0, opencode_js_1.isSpuriousOpencodeExit)(result);
+        if (launchFailed) {
+            const exitInfo = result.signal
+                ? `signal ${result.signal}`
+                : `exit ${result.status}`;
+            const stderrSnippet = result && result.stderr
+                ? ` (${result.stderr.trim().split('\n')[0]})`
+                : '';
+            log(fmt.status('WARN', `Agent ${fmt.agent(chosen || '')} failed to complete (${exitInfo}${stderrSnippet}); retrying with next eligible agent.`));
+            agentErrors.set(chosen || '', {
+                exitInfo,
+                stderr: result.stderr,
+                stdout: result.stdout,
+                signal: result.signal,
+                status: result.status,
+            });
+            tried.add(chosen || '');
+            launched.add(chosen || '');
+            // Block non-custom agents on non-limit failures so selectAgent excludes them
+            // on the next retry iteration, and the review-loop fallback path can activate.
+            // custom (opencode/local AI) is excluded — exit 1 is a temporary local error.
+            if (chosen !== 'custom') {
+                const blockUntil = (0, limit_hit_js_1.formatBlockUntil)(new Date(Date.now() + limit_hit_js_1.DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000));
+                try {
+                    const blockResult = updateAgentBlockFn(chosen || '', blockUntil);
+                    log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${limit_hit_js_1.DEFAULT_FALLBACK_HOURS}h block)`));
+                }
+                catch (err) {
+                    log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${err.message}`));
+                }
+            }
+            chosen = undefined;
+            continue;
+        }
+        // Record the marker so a subsequent same-(slug, role) launch knows which
+        // family last ran here. We only persist when the run exited cleanly
+        // (status 0 and no spawn error); a failed launch should not overwrite
+        // the canonical session marker with a stale transcript.
+        if (worktree && slug && role && result && result.status === 0 && !result.error) {
+            try {
+                const sessionId = result && result.sessionId ? result.sessionId : null;
+                sessionsModule.writeSession(worktree, slug, role, { agent: chosen || '', sessionId });
+            }
+            catch (err) {
+                log(fmt.status('WARN', `Could not persist session marker for ${fmt.slug(slug)} (${role}): ${err.message}`));
+            }
+        }
+        return { agent: chosen, invocation, result };
+    }
 }
-
 // Legacy alias kept for backwards compatibility — draft.js calls this directly.
 // Returns { agent, invocation, result } so callers can log which agent ran.
 async function startDraftAgent(opts = { prompt: '' }) {
-  return startAgent('draft', opts);
+    return startAgent('draft', opts);
 }
-
-module.exports = {
-  KNOWN_AGENT_NAMES,
-  WORKFLOW_AGENT_NAMES,
-  startAgent,
-  startDraftAgent,
-  selectAgent,
-  eligibleAgentsForStep,
-  readAgentConfig,
-  readAgentConfigOrExit,
-  assertAgentSupported,
-  workflowLauncherStatus,
-  setCommandPathProbe: (/** @type {(name: string) => string | null} */ fn) => { _commandPathProbe = fn; },
-  isAgentBlocked,
-  parseBlockUntil,
-  isInvalidAgentConfigError,
-  updateAgentBlock,
-  resolveBlocklistTargetPath,
-  resolveNoOutputWatchdogConfig
-};
+const setCommandPathProbe = (fn) => { _commandPathProbe = fn; };
+exports.setCommandPathProbe = setCommandPathProbe;