swarm-orchestrator 7.0.0-alpha.0

package/dist/src/adapters/claude-code-adapter.js

@@ -0,0 +1,126 @@
+"use strict";
+// Claude Code CLI adapter: spawns `claude` with --dangerously-skip-permissions
+// for non-interactive use. No transcript sharing; stdout/stderr captured directly.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeAdapter = void 0;
+const agent_adapter_1 = require("./agent-adapter");
+const fatal_error_classifier_1 = require("./fatal-error-classifier");
+const persistent_session_1 = require("./persistent-session");
+const process_supervisor_1 = require("./process-supervisor");
+// Claude Code can spend several minutes on internal reasoning and multi-file
+// operations without producing stdout, unlike streaming CLI tools.
+const STALL_TIMEOUT_MS = 600_000;
+class ClaudeCodeAdapter {
+    name = 'claude-code';
+    supportsPersistentInteractive = true;
+    persistentSessions = new Map();
+    async spawn(opts) {
+        const persistent = await this.tryPersistent(opts);
+        if (persistent)
+            return persistent;
+        const startTime = Date.now();
+        // Pipe the prompt via stdin instead of passing it as a CLI argument.
+        // Long prompts (SWE-bench issue descriptions with embedded code) can
+        // exceed Linux ARG_MAX (~2 MB total argv+env), causing spawn E2BIG.
+        // Claude Code supports: echo "prompt" | claude --dangerously-skip-permissions -p -
+        const args = ['--dangerously-skip-permissions', '-p', '-'];
+        if (opts.model) {
+            args.push('--model', opts.model);
+        }
+        const result = await (0, process_supervisor_1.supervisedSpawn)({
+            command: 'claude',
+            args,
+            cwd: opts.workdir,
+            env: (0, agent_adapter_1.buildRestrictedEnv)(['ANTHROPIC_API_KEY']),
+            logPrefix: opts.logPrefix,
+            stallTimeoutMs: opts.timeout ?? STALL_TIMEOUT_MS,
+            stdinData: opts.prompt,
+            onLine: opts.onAgentLine ? (line) => opts.onAgentLine(line) : undefined,
+        });
+        const durationMs = Date.now() - startTime;
+        // D5: Parse premium request count from Claude Code CLI output.
+        // Claude Code prints a cost/usage summary that we can extract.
+        // Fallback: count conversation turns (each assistant response = 1 request).
+        const premiumRequestsConsumed = this.parseRequestCount(result.stdout, result.stderr);
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, result.stderr, result.exitCode);
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            durationMs,
+            executionMode: 'cold-start',
+            premiumRequestsConsumed,
+            ...(fatalError ? { fatalError } : {}),
+        };
+    }
+    async shutdown() {
+        await Promise.all(Array.from(this.persistentSessions.values()).map(session => session.shutdown()));
+        this.persistentSessions.clear();
+    }
+    async tryPersistent(opts) {
+        if (!shouldAttemptPersistent(opts))
+            return undefined;
+        const startTime = Date.now();
+        const sessionKey = opts.persistentSessionId ?? `${opts.workdir}:${opts.model ?? 'default'}`;
+        const args = ['--dangerously-skip-permissions'];
+        if (opts.model)
+            args.push('--model', opts.model);
+        let session = this.persistentSessions.get(sessionKey);
+        if (!session || session.unavailable) {
+            session = new persistent_session_1.PersistentInteractiveSession({
+                command: 'claude',
+                args,
+                cwd: opts.workdir,
+                env: (0, agent_adapter_1.buildRestrictedEnv)(['ANTHROPIC_API_KEY']),
+                onLine: (line) => opts.onAgentLine?.(`[claude-code:persistent] ${line}`),
+            });
+            this.persistentSessions.set(sessionKey, session);
+        }
+        const result = await session.send(opts.prompt, opts.persistentTurnTimeoutMs ?? opts.timeout ?? STALL_TIMEOUT_MS);
+        if (result.exitCode === 0) {
+            return {
+                ...result,
+                executionMode: 'persistent-interactive',
+                premiumRequestsConsumed: this.parseRequestCount(result.stdout, result.stderr),
+            };
+        }
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, result.stderr, result.exitCode);
+        const reason = session.reason ?? (result.stderr || 'persistent interactive mode failed');
+        this.persistentSessions.delete(sessionKey);
+        await session.shutdown();
+        // Fatal account-level errors short-circuit the cold-start fallback for
+        // the same reason as in the codex adapter: another spawn cannot recover
+        // from a usage-limit or auth wall.
+        if (opts.executionMode === 'persistent-interactive' || fatalError) {
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                durationMs: Date.now() - startTime,
+                executionMode: 'persistent-interactive',
+                fallbackReason: reason,
+                ...(fatalError ? { fatalError } : {}),
+            };
+        }
+        return undefined;
+    }
+    /**
+     * D5: Extract the number of premium API requests from Claude Code output.
+     * Claude Code's `claude -p` does not currently emit a stable per-session
+     * "premium requests consumed" marker on stdout or stderr — the turn
+     * markers the old version counted never appear in non-interactive mode.
+     *
+     * Return undefined rather than a synthetic "1" so the orchestrator can
+     * fall back honestly and `premium_requests_actual` does not silently
+     * encode "one per step" when the real count is unknown.
+     */
+    parseRequestCount(_stdout, _stderr) {
+        return undefined;
+    }
+}
+exports.ClaudeCodeAdapter = ClaudeCodeAdapter;
+function shouldAttemptPersistent(opts) {
+    if (opts.executionMode === 'persistent-interactive')
+        return true;
+    return opts.executionMode === 'auto' && process.env.SWARM_ENABLE_PERSISTENT_INTERACTIVE === '1';
+}

package/dist/src/adapters/claude-code-teams.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeTeamsAdapter = void 0;
+const claude_code_adapter_1 = require("./claude-code-adapter");
+const process_supervisor_1 = require("./process-supervisor");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('claude-code-teams');
+class ClaudeCodeTeamsAdapter {
+    name = 'claude-code-teams';
+    fallbackAdapter;
+    constructor() {
+        this.fallbackAdapter = new claude_code_adapter_1.ClaudeCodeAdapter();
+    }
+    // Single-step spawn delegates to team execution with one step.
+    // Preserves the AgentAdapter contract for callers that don't batch.
+    async spawn(opts) {
+        const results = await this.executeWave([opts]);
+        return results[0];
+    }
+    async executeWave(steps) {
+        if (steps.length === 0)
+            return [];
+        try {
+            return await this.spawnTeamWave(steps);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return this.fallbackToPerStep(steps, error);
+        }
+    }
+    // Check if a model string indicates Opus 4.6+, which is required for
+    // Agent Teams. Non-Opus models will trigger a fallback to per-step execution.
+    static isOpusModel(model) {
+        if (!model)
+            return false;
+        return /opus/i.test(model);
+    }
+    async spawnTeamWave(steps) {
+        // Build the team lead prompt that spawns teammates for each step
+        const teamLeadPrompt = this.buildTeamLeadPrompt(steps);
+        const workdir = steps[0].workdir;
+        const model = steps[0].model;
+        // Agent Teams requires Opus model. Check before attempting to spawn.
+        if (model && !ClaudeCodeTeamsAdapter.isOpusModel(model)) {
+            throw new Error(`Agent Teams requires Opus 4.6+, got "${model}". Use --tool claude-code for non-Opus models.`);
+        }
+        const startTime = Date.now();
+        // Spawn the team lead as a single claude session with the
+        // CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS env var enabled
+        const spawnOpts = {
+            prompt: teamLeadPrompt,
+            workdir,
+        };
+        if (model)
+            spawnOpts.model = model;
+        const result = await this.fallbackAdapter.spawn(spawnOpts);
+        const durationMs = Date.now() - startTime;
+        // If the team lead failed, throw to trigger fallback
+        if (result.exitCode !== 0) {
+            throw new Error(`Team lead exited with code ${result.exitCode}: ${result.stderr.slice(0, 500)}`);
+        }
+        // Map the single team lead output to per-step results.
+        // Each step gets the same transcript since the team lead orchestrated all work.
+        // fatalError is propagated identically across mapped results because
+        // a usage-limit / auth error on the team lead applies to every teammate
+        // it would have spawned — they share the same underlying account.
+        return steps.map((_step, _i) => ({
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            durationMs,
+            shareTranscriptPath: undefined,
+            ...(result.fatalError ? { fatalError: result.fatalError } : {}),
+        }));
+    }
+    buildTeamLeadPrompt(steps) {
+        const sections = [
+            `You are the team lead for ${steps.length} task(s).`,
+            'Spawn one teammate per task and execute them concurrently.',
+            '',
+            'For each task below, spawn a teammate with the given prompt.',
+            'Wait for all teammates to complete before reporting results.',
+            ''
+        ];
+        for (let i = 0; i < steps.length; i++) {
+            sections.push(`=== Teammate ${i + 1} ===`);
+            sections.push(steps[i].prompt);
+            sections.push('');
+        }
+        sections.push('Report the combined results of all teammates when done.');
+        return sections.join('\n');
+    }
+    async fallbackToPerStep(steps, error) {
+        logger.warn(`Teams fallback: ${error.message}`);
+        // Execute each step individually via the standard claude-code adapter
+        const results = [];
+        for (const step of steps) {
+            results.push(await this.fallbackAdapter.spawn(step));
+        }
+        return results;
+    }
+    spawnClaudeProcess(prompt, opts) {
+        const args = ['-p', prompt, '--yes'];
+        if (opts.model) {
+            args.push('--model', opts.model);
+        }
+        const spawnOpts = {
+            command: 'claude',
+            args,
+            cwd: opts.workdir
+        };
+        if (opts.additionalEnv)
+            spawnOpts.env = opts.additionalEnv;
+        if (opts.logPrefix)
+            spawnOpts.logPrefix = `${opts.logPrefix} [teams]`;
+        return (0, process_supervisor_1.supervisedSpawn)(spawnOpts);
+    }
+}
+exports.ClaudeCodeTeamsAdapter = ClaudeCodeTeamsAdapter;

package/dist/src/adapters/codex-adapter.js

@@ -0,0 +1,118 @@
+"use strict";
+// OpenAI Codex CLI adapter: spawns `codex exec` for non-interactive use.
+// Uses --dangerously-bypass-approvals-and-sandbox because git worktrees have
+// .git references to the parent repo, which --full-auto's sandbox blocks.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAdapter = void 0;
+const agent_adapter_1 = require("./agent-adapter");
+const fatal_error_classifier_1 = require("./fatal-error-classifier");
+const persistent_session_1 = require("./persistent-session");
+const process_supervisor_1 = require("./process-supervisor");
+// Codex can spend significant time on reasoning and file operations
+// without producing stdout, similar to Claude Code. supervisedSpawn's
+// heartbeat surfaces progress during these quiet periods.
+const STALL_TIMEOUT_MS = 600_000;
+class CodexAdapter {
+    name = 'codex';
+    supportsPersistentInteractive = true;
+    persistentSessions = new Map();
+    async spawn(opts) {
+        const persistent = await this.tryPersistent(opts);
+        if (persistent)
+            return persistent;
+        const startTime = Date.now();
+        const args = [
+            'exec',
+            '--dangerously-bypass-approvals-and-sandbox',
+            '-C', opts.workdir,
+        ];
+        if (opts.model) {
+            args.push('-m', opts.model);
+        }
+        args.push(opts.prompt);
+        // stdinMode: 'ignore' prevents Codex from printing
+        // "Reading additional input from stdin..." into the transcript when it
+        // detects a piped (but empty) stdin. With stdin wired to /dev/null Codex
+        // treats the prompt arg as the full instruction.
+        const result = await (0, process_supervisor_1.supervisedSpawn)({
+            command: 'codex',
+            args,
+            cwd: opts.workdir,
+            env: (0, agent_adapter_1.buildRestrictedEnv)(['OPENAI_API_KEY']),
+            logPrefix: opts.logPrefix ?? '[codex]',
+            stallTimeoutMs: opts.timeout ?? STALL_TIMEOUT_MS,
+            stdinMode: 'ignore',
+            onLine: opts.onAgentLine ? (line) => opts.onAgentLine(line) : undefined,
+        });
+        const durationMs = Date.now() - startTime;
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, result.stderr, result.exitCode);
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            durationMs,
+            executionMode: 'cold-start',
+            ...(fatalError ? { fatalError } : {}),
+        };
+    }
+    async shutdown() {
+        await Promise.all(Array.from(this.persistentSessions.values()).map(session => session.shutdown()));
+        this.persistentSessions.clear();
+    }
+    async tryPersistent(opts) {
+        if (!shouldAttemptPersistent(opts))
+            return undefined;
+        const startTime = Date.now();
+        const sessionKey = opts.persistentSessionId ?? `${opts.workdir}:${opts.model ?? 'default'}`;
+        const args = [
+            '--dangerously-bypass-approvals-and-sandbox',
+            '-C', opts.workdir,
+            '--no-alt-screen',
+        ];
+        if (opts.model)
+            args.push('-m', opts.model);
+        let session = this.persistentSessions.get(sessionKey);
+        if (!session || session.unavailable) {
+            session = new persistent_session_1.PersistentInteractiveSession({
+                command: 'codex',
+                args,
+                cwd: opts.workdir,
+                env: (0, agent_adapter_1.buildRestrictedEnv)(['OPENAI_API_KEY']),
+                onLine: (line) => opts.onAgentLine?.(`[codex:persistent] ${line}`),
+            });
+            this.persistentSessions.set(sessionKey, session);
+        }
+        const result = await session.send(opts.prompt, opts.persistentTurnTimeoutMs ?? opts.timeout ?? STALL_TIMEOUT_MS);
+        if (result.exitCode === 0) {
+            return {
+                ...result,
+                executionMode: 'persistent-interactive',
+            };
+        }
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, result.stderr, result.exitCode);
+        const reason = session.reason ?? (result.stderr || 'persistent interactive mode failed');
+        this.persistentSessions.delete(sessionKey);
+        await session.shutdown();
+        // A fatal account-level error short-circuits the cold-start fallback —
+        // a fresh subprocess will hit the same usage-limit / auth wall, just
+        // ten seconds later and after another wasted spawn. Surface it now.
+        if (opts.executionMode === 'persistent-interactive' || fatalError) {
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                durationMs: Date.now() - startTime,
+                executionMode: 'persistent-interactive',
+                fallbackReason: reason,
+                ...(fatalError ? { fatalError } : {}),
+            };
+        }
+        return undefined;
+    }
+}
+exports.CodexAdapter = CodexAdapter;
+function shouldAttemptPersistent(opts) {
+    if (opts.executionMode === 'persistent-interactive')
+        return true;
+    return opts.executionMode === 'auto' && process.env.SWARM_ENABLE_PERSISTENT_INTERACTIVE === '1';
+}

package/dist/src/adapters/copilot-adapter.js

@@ -0,0 +1,224 @@
+"use strict";
+// Copilot CLI adapter: spawns `copilot -p` with the same flags and behavior
+// as the original SessionExecutor.runCommand path. This is a refactor, not
+// new behavior; it preserves the stall detection, line buffering, and heartbeat
+// logic from the original implementation.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotAdapter = void 0;
+exports.scrubCopilotHostileTokens = scrubCopilotHostileTokens;
+exports.parseCopilotRequestCount = parseCopilotRequestCount;
+exports.hasFatalStderrError = hasFatalStderrError;
+const fatal_error_classifier_1 = require("./fatal-error-classifier");
+const persistent_session_1 = require("./persistent-session");
+const process_supervisor_1 = require("./process-supervisor");
+// Maximum silence before killing a stalled copilot subprocess.
+// Copilot CLI can go quiet for several minutes during extended tool-use
+// or thinking phases, so this needs headroom beyond typical inference time.
+const STALL_TIMEOUT_MS = 300_000;
+// Copilot CLI outputs these when an agent tries to access paths outside its sandbox
+const SCOPE_NOISE_PATTERNS = [
+    /Permission denied and could not request permission/i,
+    /could not request permission from user/i,
+];
+// Env vars Copilot CLI prefers over its keyring OAuth for authentication.
+// If the user has a repo-scoped PAT (e.g. GITHUB_TOKEN in .env) that lacks
+// "Copilot Requests" permission, Copilot picks it up and every session 401s
+// before a single tool call runs. Scrub these by default so Copilot falls
+// back to the keyring token the user already authenticated with via
+// `copilot /login`. Opt back in by setting SWARM_USE_ENV_GITHUB_TOKEN=1
+// when you do have a Copilot-capable PAT and want to force env-based auth.
+const COPILOT_AUTH_ENV_VARS = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
+function scrubCopilotHostileTokens(env) {
+    if (env.SWARM_USE_ENV_GITHUB_TOKEN === '1') {
+        return { ...env };
+    }
+    const copy = { ...env };
+    for (const key of COPILOT_AUTH_ENV_VARS) {
+        delete copy[key];
+    }
+    return copy;
+}
+// Build the env spread the spawn helpers feed Copilot. The supervisor merges
+// process.env first, so the scrubbed tokens have to be set to `undefined`
+// here (not just deleted from a copy) to actually unset them in the child.
+// Returns the same shape for cold-start and persistent paths so they stay
+// in sync. Respects SWARM_USE_ENV_GITHUB_TOKEN=1 by leaving the tokens
+// alone when the user has explicitly opted into env-based Copilot auth.
+function copilotChildEnv() {
+    const env = {
+        GIT_AUTHOR_NAME: 'swarm-orchestrator',
+        GIT_AUTHOR_EMAIL: 'swarm@localhost',
+        GIT_COMMITTER_NAME: 'swarm-orchestrator',
+        GIT_COMMITTER_EMAIL: 'swarm@localhost',
+        COPILOT_ALLOW_ALL: 'true',
+    };
+    if (process.env.SWARM_USE_ENV_GITHUB_TOKEN !== '1') {
+        for (const key of COPILOT_AUTH_ENV_VARS) {
+            env[key] = undefined;
+        }
+    }
+    return env;
+}
+// Billing-accurate premium-request count, as reported by the Copilot CLI
+// on its stderr summary block. Format example:
+//
+//   Changes   +2 -0
+//   Requests  4 Premium (112s)
+//   Tokens    ↑ ...
+//
+// Copilot bills by Premium requests, not raw model invocations, and a
+// multi-tool-use session is usually billed as 1. Parsing this line is
+// the only way to get a number that matches the user's actual bill.
+// Returns undefined when the marker is absent (e.g. auth failure).
+const COPILOT_REQUEST_LINE_RE = /^\s*Requests\s+(\d+)\s+Premium\b/m;
+function parseCopilotRequestCount(stderr) {
+    if (!stderr)
+        return undefined;
+    const m = stderr.match(COPILOT_REQUEST_LINE_RE);
+    if (!m)
+        return undefined;
+    const n = parseInt(m[1], 10);
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+// Copilot CLI sometimes exits 0 even on fatal errors like invalid model
+// names or auth failures. These patterns on stderr indicate the session
+// never ran at all.
+const FATAL_STDERR_PATTERNS = [
+    /Model ".*" from --model flag is not available/i,
+    /Error:.*not available/i,
+    /Authentication failed/i,
+    /token.*(?:invalid|expired|lacking)/i,
+];
+function isScopeNoise(line) {
+    return SCOPE_NOISE_PATTERNS.some(p => p.test(line));
+}
+// Exported for direct testing without spawning real subprocesses
+function hasFatalStderrError(stderr) {
+    return FATAL_STDERR_PATTERNS.some(p => p.test(stderr));
+}
+class CopilotAdapter {
+    name = 'copilot';
+    supportsPersistentInteractive = true;
+    persistentSessions = new Map();
+    async spawn(opts) {
+        const persistent = await this.tryPersistent(opts);
+        if (persistent)
+            return persistent;
+        const startTime = Date.now();
+        const args = ['-p', opts.prompt];
+        if (opts.model) {
+            args.push('--model', opts.model);
+        }
+        // --allow-all covers tools, paths, and URLs so the subprocess
+        // never blocks waiting for interactive approval on stdin.
+        args.push('--allow-all');
+        if (opts.copilotAgent) {
+            args.push('--agent', opts.copilotAgent);
+        }
+        const result = await (0, process_supervisor_1.supervisedSpawn)({
+            command: 'copilot',
+            args,
+            cwd: opts.workdir,
+            // Copilot CLI authenticates via gh's local keyring, not env-var API keys.
+            // It needs the full user environment (XDG_CONFIG_HOME, DBUS_SESSION_BUS_ADDRESS,
+            // keyring paths, etc.) to locate stored credentials. Restricting the env
+            // like we do for API-key-based adapters breaks auth silently.
+            env: copilotChildEnv(),
+            logPrefix: opts.logPrefix,
+            stallTimeoutMs: opts.timeout ?? STALL_TIMEOUT_MS,
+            onLine: opts.onAgentLine ? (line) => opts.onAgentLine(line) : undefined,
+        });
+        const durationMs = Date.now() - startTime;
+        // Copilot prints scope-enforcement messages on stderr when an agent tries
+        // to access paths outside its sandbox. These add no diagnostic value to
+        // verification or fatal-error parsing, so strip them from the captured
+        // stderr before downstream consumers see it. Live streaming via logPrefix
+        // may still surface them in real time, which is the correct UX.
+        const filteredStderr = result.stderr
+            .split('\n')
+            .filter((l) => !isScopeNoise(l))
+            .join('\n');
+        // Copilot CLI exits 0 for certain fatal errors (e.g. invalid model name)
+        // that produce no stdout. Detect these and correct the exit code so the
+        // orchestrator treats the session as failed rather than empty-but-successful.
+        let exitCode = result.exitCode;
+        if (exitCode === 0 && !result.stdout.trim() && hasFatalStderrError(filteredStderr)) {
+            exitCode = 1;
+        }
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, filteredStderr, exitCode);
+        return {
+            stdout: result.stdout,
+            stderr: filteredStderr,
+            exitCode,
+            durationMs,
+            executionMode: 'cold-start',
+            premiumRequestsConsumed: parseCopilotRequestCount(filteredStderr),
+            ...(fatalError ? { fatalError } : {}),
+        };
+    }
+    async shutdown() {
+        await Promise.all(Array.from(this.persistentSessions.values()).map(session => session.shutdown()));
+        this.persistentSessions.clear();
+    }
+    async tryPersistent(opts) {
+        if (!shouldAttemptPersistent(opts))
+            return undefined;
+        const startTime = Date.now();
+        const sessionKey = opts.persistentSessionId ?? `${opts.workdir}:${opts.model ?? 'default'}:${opts.copilotAgent ?? ''}`;
+        const args = ['--allow-all', '--no-ask-user', '--stream', 'on'];
+        if (opts.model)
+            args.push('--model', opts.model);
+        if (opts.copilotAgent)
+            args.push('--agent', opts.copilotAgent);
+        let session = this.persistentSessions.get(sessionKey);
+        if (!session || session.unavailable) {
+            session = new persistent_session_1.PersistentInteractiveSession({
+                command: 'copilot',
+                args,
+                cwd: opts.workdir,
+                env: {
+                    ...scrubCopilotHostileTokens(process.env),
+                    GIT_AUTHOR_NAME: 'swarm-orchestrator',
+                    GIT_AUTHOR_EMAIL: 'swarm@localhost',
+                    GIT_COMMITTER_NAME: 'swarm-orchestrator',
+                    GIT_COMMITTER_EMAIL: 'swarm@localhost',
+                    COPILOT_ALLOW_ALL: 'true',
+                },
+                onLine: (line) => opts.onAgentLine?.(`[copilot:persistent] ${line}`),
+            });
+            this.persistentSessions.set(sessionKey, session);
+        }
+        const result = await session.send(opts.prompt, opts.persistentTurnTimeoutMs ?? opts.timeout ?? STALL_TIMEOUT_MS);
+        if (result.exitCode === 0) {
+            return {
+                ...result,
+                executionMode: 'persistent-interactive',
+                premiumRequestsConsumed: parseCopilotRequestCount(result.stderr),
+            };
+        }
+        const fatalError = (0, fatal_error_classifier_1.classifyFatalAgentError)(result.stdout, result.stderr, result.exitCode);
+        const reason = session.reason ?? (result.stderr || 'persistent interactive mode failed');
+        this.persistentSessions.delete(sessionKey);
+        await session.shutdown();
+        // Same short-circuit rationale as in codex / claude adapters: a fatal
+        // account-level error makes the cold-start fallback equally doomed.
+        if (opts.executionMode === 'persistent-interactive' || fatalError) {
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+                durationMs: Date.now() - startTime,
+                executionMode: 'persistent-interactive',
+                fallbackReason: reason,
+                ...(fatalError ? { fatalError } : {}),
+            };
+        }
+        return undefined;
+    }
+}
+exports.CopilotAdapter = CopilotAdapter;
+function shouldAttemptPersistent(opts) {
+    if (opts.executionMode === 'persistent-interactive')
+        return true;
+    return opts.executionMode === 'auto' && process.env.SWARM_ENABLE_PERSISTENT_INTERACTIVE === '1';
+}

package/dist/src/adapters/fatal-error-classifier.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Fatal-error classification for agent CLI failures.
+ *
+ * An agent run can fail in two distinct ways:
+ *
+ *   1. Recoverable: the agent ran but produced a bad patch. The orchestrator's
+ *      replan and repair loops can usefully retry.
+ *
+ *   2. Unrecoverable: the agent never ran (or refused to run) because of an
+ *      account-level condition such as a usage-limit hit, an expired
+ *      subscription, or a missing API key. No amount of replanning will
+ *      change that, and each replan still consumes the per-instance budget.
+ *
+ * This module turns the second case into a structured signal so the
+ * orchestrator can short-circuit instead of burning the 10-minute
+ * dependency-wait window per replan step.
+ *
+ * Patterns are matched against the union of stdout + stderr because the
+ * three CLIs we wrap split error reporting differently:
+ *   - codex prints `ERROR: You've hit your usage limit. Upgrade to Pro ...`
+ *     on stderr.
+ *   - claude prints rate-limit / auth errors with a `429` or `401` token in
+ *     either stream depending on transport.
+ *   - copilot prints `gh: authentication required` on stderr and `403`
+ *     bodies on stdout.
+ *
+ * Patterns are intentionally narrow. False positives here would suppress
+ * legitimate retries on transient errors, which is worse than the current
+ * 10-minute wait it's trying to avoid.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyFatalAgentError = classifyFatalAgentError;
+// Order matters: more specific patterns first. The first match wins.
+const PATTERNS = [
+    // Codex CLI usage-limit message. Verbatim from `codex exec` stderr when an
+    // OpenAI account hits its plan ceiling — the only actionable response is
+    // "wait until <reset time> or upgrade", neither of which the orchestrator
+    // can do mid-sweep. See smoke run 2026-04-28-codex stderr.
+    { kind: 'usage-limit', pattern: /you'?ve hit your usage limit/i },
+    { kind: 'usage-limit', pattern: /upgrade to (pro|plus|team)\b/i },
+    { kind: 'usage-limit', pattern: /quota.*(exceed|exhaust)/i },
+    { kind: 'usage-limit', pattern: /monthly limit reached/i },
+    // Auth: missing/invalid credentials. The agent CLI cannot recover by
+    // retrying with the same credentials.
+    { kind: 'auth', pattern: /\b401\s+unauthorized\b/i },
+    { kind: 'auth', pattern: /\b403\s+forbidden\b/i },
+    { kind: 'auth', pattern: /authentication\s+(required|failed)/i },
+    { kind: 'auth', pattern: /invalid api[_-]?key/i },
+    { kind: 'auth', pattern: /api[_-]?key.*(missing|not found|not set)/i },
+    { kind: 'auth', pattern: /not (logged in|authenticated)/i },
+    // Rate limit with a retry-after window we cannot wait through within a
+    // smoke task budget. Matches "try again at HH:MM (PM|AM)" from codex and
+    // "rate limit reached.*retry-after: \d{4,}" from anthropic-style payloads.
+    { kind: 'rate-limit-extended', pattern: /try again at \d{1,2}:\d{2}\s*(am|pm)/i },
+    { kind: 'rate-limit-extended', pattern: /retry-after:\s*\d{4,}/i },
+];
+/**
+ * Inspect agent CLI output for unrecoverable error signatures.
+ *
+ * @param stdout combined stdout from the agent process. Pass an empty string when unavailable.
+ * @param stderr combined stderr from the agent process. Pass an empty string when unavailable.
+ * @param exitCode process exit code; only consulted to gate detection (zero exit means the
+ *   agent reported success, and we do not classify a successful run as fatal).
+ * @returns a FatalAgentError when a known pattern matches, otherwise undefined.
+ */
+function classifyFatalAgentError(stdout, stderr, exitCode) {
+    if (exitCode === 0)
+        return undefined;
+    const haystack = `${stderr ?? ''}\n${stdout ?? ''}`;
+    if (!haystack.trim())
+        return undefined;
+    for (const { kind, pattern } of PATTERNS) {
+        const match = haystack.match(pattern);
+        if (!match)
+            continue;
+        const lineStart = haystack.lastIndexOf('\n', match.index ?? 0) + 1;
+        const lineEndRaw = haystack.indexOf('\n', (match.index ?? 0) + match[0].length);
+        const lineEnd = lineEndRaw === -1 ? haystack.length : lineEndRaw;
+        const evidence = haystack.slice(lineStart, lineEnd).trim().slice(0, 240);
+        return {
+            kind,
+            message: evidence || match[0],
+            evidence,
+        };
+    }
+    return undefined;
+}