swarm-orchestrator 7.0.0-alpha.0

package/dist/src/orchestrator/replan-runner.js

@@ -0,0 +1,258 @@
+"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.executeReplan = executeReplan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plan_generator_1 = require("../plan-generator");
+const repair_agent_1 = __importDefault(require("../repair-agent"));
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('orchestrator');
+/**
+ * WARNING: This function mutates context.plan by assignment.
+ *
+ * After executeReplan returns, context.plan points to a different
+ * ExecutionPlan object than it did before the call. Any code that
+ * cached context.plan or context.plan.steps before the call is
+ * now holding a stale reference.
+ *
+ * The wave scheduler (wave-scheduler-loop.ts) handles this by
+ * re-reading context.plan.steps on every loop iteration. Do not
+ * change this function's mutation behavior without updating the
+ * scheduler's invariant comment and test.
+ *
+ * Behavior: retries failed steps on new branches with a "-retryN"
+ * suffix (preserving completed work), then appends and runs any
+ * `replanPayload.addSteps`, finally merging their successful
+ * branches to main so subsequent quality-gate re-checks see the
+ * remediation changes.
+ *
+ * @param host - orchestrator surface providing workingDir, resolveAgent,
+ *   switchBranch, createAgentBranch, executeStepInSwarm, mergeWaveBranches
+ * @param context - mutable replan context; `context.plan` may be reassigned
+ * @param replanPayload - retries and add-steps to execute
+ * @param agents - available agent map
+ * @param options - orchestrator options (model, onProgress)
+ */
+async function executeReplan(host, context, replanPayload, agents, options) {
+    logger.info('\n🔄 Executing replan...');
+    const maxRetries = options?.maxRetries ?? 3;
+    // initialize replan state
+    context.replanState = {
+        triggeredAt: new Date().toISOString(),
+        payload: replanPayload,
+        retryBranches: new Map()
+    };
+    // update knowledge base with replan event
+    context.knowledgeBase?.addOrUpdatePattern({
+        category: 'failure_mode',
+        insight: `replan triggered for steps: ${replanPayload.retrySteps.join(', ')}`,
+        confidence: 'high',
+        evidence: [`replan at ${context.replanState.triggeredAt}`],
+        impact: 'medium'
+    });
+    // execute retries for each failed step using the repair agent
+    for (const stepNumber of replanPayload.retrySteps) {
+        const step = context.plan.steps.find(s => s.stepNumber === stepNumber);
+        if (!step) {
+            logger.warn(`  replan: step ${stepNumber} not found, skipping`);
+            continue;
+        }
+        const agent = host.resolveAgent(agents, step.agentName);
+        if (!agent) {
+            logger.warn(`  replan: agent ${step.agentName} not found, skipping`);
+            continue;
+        }
+        // get current retry count
+        const resultIndex = context.results.findIndex(r => r.stepNumber === stepNumber);
+        const result = context.results[resultIndex];
+        const retryCount = (result?.retryCount || 0) + 1;
+        if (retryCount > maxRetries) {
+            logger.error(`  step ${stepNumber} exceeded max retries (${maxRetries}), skipping`);
+            continue;
+        }
+        logger.info(`  🔧 Spawning repair agent for step ${stepNumber} (${agent.name}) - attempt ${retryCount}`);
+        // create retry branch with suffix
+        const retryBranchName = `swarm/${context.executionId}/step-${stepNumber}-${agent.name.toLowerCase()}-retry${retryCount}`;
+        // track retry branch
+        if (!context.replanState.retryBranches.has(stepNumber)) {
+            context.replanState.retryBranches.set(stepNumber, []);
+        }
+        context.replanState.retryBranches.get(stepNumber).push(retryBranchName);
+        // reset result status
+        if (result) {
+            result.status = 'pending';
+            result.retryCount = retryCount;
+            result.branchName = retryBranchName;
+            delete result.error;
+            delete result.sessionResult;
+            delete result.verificationResult;
+        }
+        try {
+            // switch to main branch before creating retry branch
+            await host.switchBranch(context.mainBranch);
+            await host.createAgentBranch(retryBranchName, context.mainBranch);
+            // Build repair context from the failed step's results
+            const stepDir = path.join(context.runDir, 'steps', `step-${stepNumber}`);
+            const transcriptPath = path.join(stepDir, 'share.md');
+            const verificationReportPath = path.join(context.runDir, 'verification', `step-${stepNumber}-verification.md`);
+            const failedChecks = [];
+            let rootCause = 'Verification checks failed';
+            if (result?.verificationResult) {
+                const repairAgentHelper = new repair_agent_1.default(host.workingDir, maxRetries);
+                const extracted = repairAgentHelper.extractFailedChecks(result.verificationResult);
+                failedChecks.push(...extracted);
+                // Derive root cause from check types (includes outcome-based checks)
+                const hasTestFailure = result.verificationResult.checks.some(c => !c.passed && (c.type === 'test' || c.type === 'test_exec'));
+                const hasBuildFailure = result.verificationResult.checks.some(c => !c.passed && (c.type === 'build' || c.type === 'build_exec'));
+                const hasCommitFailure = result.verificationResult.checks.some(c => !c.passed && c.type === 'commit');
+                const hasNoDiff = result.verificationResult.checks.some(c => !c.passed && c.type === 'git_diff');
+                const hasMissingFiles = result.verificationResult.checks.some(c => !c.passed && c.type === 'file_existence');
+                if (hasMissingFiles)
+                    rootCause = 'Expected files were not created';
+                else if (hasTestFailure)
+                    rootCause = 'Tests not executed or failed';
+                else if (hasBuildFailure)
+                    rootCause = 'Build not executed or failed';
+                else if (hasNoDiff)
+                    rootCause = 'Agent made no code changes';
+                else if (hasCommitFailure)
+                    rootCause = 'No commits made';
+            }
+            const repairContext = {
+                stepNumber,
+                agentName: agent.name,
+                originalTask: step.task,
+                transcriptPath,
+                verificationReportPath,
+                branchName: retryBranchName,
+                failedChecks,
+                rootCause,
+                retryCount,
+                failureContext: result.verificationResult?.failureContext,
+            };
+            const repairAgent = new repair_agent_1.default(host.workingDir, maxRetries);
+            const sessionOpts = {
+                allowAllTools: true,
+                ...(options?.model && { model: options.model })
+            };
+            const repairResult = await repairAgent.attemptRepair(repairContext, sessionOpts, {
+                requireTests: /\b(test suite|unit test|integration test|e2e test|write tests)\b/i.test(step.task),
+                requireBuild: /\b(npm build|run build|compile|bundle|webpack)\b/i.test(step.task),
+                requireCommits: false
+            });
+            // Log repair cost
+            logger.info(`  📊 Repair cost: ~${repairResult.estimatedTokenCost} tokens, ${repairResult.attempts} attempt(s), ${Math.round(repairResult.totalDurationMs / 1000)}s`);
+            // Save repair result to run directory
+            const repairResultPath = path.join(context.runDir, `repair-step-${stepNumber}.json`);
+            fs.writeFileSync(repairResultPath, JSON.stringify(repairResult, null, 2), 'utf8');
+            if (repairResult.success) {
+                if (result) {
+                    result.status = 'completed';
+                    result.endTime = new Date().toISOString();
+                }
+                logger.info(`  ✅ Repair succeeded for step ${stepNumber} after ${repairResult.attempts} attempt(s)`);
+            }
+            else {
+                // Repair failed - fall back to standard re-execution as last resort
+                logger.warn(`  ⚠️  Repair agent failed; falling back to full re-execution for step ${stepNumber}`);
+                const retryStep = { ...step, task: `[RETRY ${retryCount}] ${step.task}` };
+                await host.executeStepInSwarm(retryStep, agent, context, options);
+                logger.info(`  ✅ Fallback retry succeeded for step ${stepNumber}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            logger.error(`  ❌ Retry ${retryCount} failed for step ${stepNumber}: ${err.message}`);
+        }
+    }
+    // append and execute any new steps
+    if (replanPayload.addSteps && replanPayload.addSteps.length > 0) {
+        const generator = new plan_generator_1.PlanGenerator(Array.from(agents.values()));
+        const completed = context.results.filter(r => r.status === 'completed').map(r => r.stepNumber);
+        const revised = generator.revisePlan(context.plan, replanPayload, completed);
+        const oldMax = Math.max(...context.plan.steps.map(s => s.stepNumber));
+        const newSteps = revised.steps.filter((s) => s.stepNumber > oldMax);
+        context.plan = revised;
+        for (const s of newSteps) {
+            context.results.push({
+                stepNumber: s.stepNumber,
+                agentName: s.agentName,
+                status: 'pending'
+            });
+        }
+        logger.info(`  ➕ Replan added ${newSteps.length} new step(s)`);
+        // Notify listeners immediately so totalSteps and progress state update
+        // before the replan steps start executing
+        options?.onProgress?.(context, `replan-added:${newSteps.length}`);
+        // Execute added steps in parallel when they have no mutual dependencies
+        const replanPromises = newSteps.map(async (added) => {
+            const agent = host.resolveAgent(agents, added.agentName);
+            if (!agent) {
+                logger.warn(`  replan: agent ${added.agentName} not found for step ${added.stepNumber}, skipping`);
+                return;
+            }
+            logger.info(`  🧩 Executing added step ${added.stepNumber} (${agent.name})`);
+            try {
+                await host.executeStepInSwarm(added, agent, context, options);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`  ❌ Replan step ${added.stepNumber} failed: ${msg}`);
+            }
+        });
+        await Promise.allSettled(replanPromises);
+        // Merge completed replan branches to main so quality gate re-checks
+        // see the remediation changes. Without this, replan work stays on
+        // unmerged branches and gate re-runs read stale code.
+        const completedReplan = newSteps
+            .map(s => context.results.find(r => r.stepNumber === s.stepNumber))
+            .filter((r) => !!r && r.status === 'completed' && !!r.branchName);
+        if (completedReplan.length > 0) {
+            context.contextBroker.forceReleaseStaleLocks();
+            await host.mergeWaveBranches(completedReplan, context, options);
+        }
+    }
+    // save replan state to run directory
+    const replanPath = path.join(context.runDir, 'replan-state.json');
+    fs.writeFileSync(replanPath, JSON.stringify({
+        ...context.replanState,
+        retryBranches: Object.fromEntries(context.replanState.retryBranches)
+    }, null, 2), 'utf8');
+    logger.info('  📝 Replan state saved');
+}

package/dist/src/orchestrator/step-executor.js

@@ -0,0 +1,391 @@
+"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.executeStepInSwarm = executeStepInSwarm;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const adapters_1 = require("../adapters");
+const commit_quality_analyzer_1 = require("../commit-quality-analyzer");
+const deployment_handler_1 = require("../deployment-handler");
+const hook_generator_1 = require("../hook-generator");
+const prompt_builder_1 = require("../prompt-builder");
+const session_executor_1 = __importDefault(require("../session-executor"));
+const spinner_1 = require("../spinner");
+const defaults_1 = require("../defaults");
+const worktree_reserved_paths_1 = require("../worktree-reserved-paths");
+const live_status_1 = require("../cli/live-status");
+const fatal_run_error_1 = require("./fatal-run-error");
+/**
+ * Human-readable label for a CLI agent tool, used in fallback transcript headers.
+ */
+function transcriptToolLabel(tool) {
+    switch (tool) {
+        case 'codex': return 'Codex';
+        case 'claude-code': return 'Claude Code';
+        case 'claude-code-teams': return 'Claude Code Teams';
+        case 'copilot': return 'Copilot';
+        default: return tool.charAt(0).toUpperCase() + tool.slice(1);
+    }
+}
+/**
+ * Execute a single step end-to-end: wait for deps, create worktree,
+ * build prompt, run the agent session, commit
+ * uncommitted work, verify, record context / cost / metrics, optional
+ * deployment on success, rollback on failure.
+ *
+ * Mutates `context.results[<stepNumber>]` in place for status,
+ * branchName, timestamps, sessionResult, verificationResult, and error.
+ * Pushes to `context.stepCostRecords` when cost tracking is active.
+ *
+ * Throws on verification failure so the scheduler can mark the step
+ * failed; a ContextEntry is still added to the broker on failure so
+ * downstream waiters don't hang.
+ *
+ * @param host - orchestrator surface (workingDir, shareParser,
+ *   verifier, createAgentWorktree)
+ * @param step - the plan step to execute
+ * @param agent - the agent assigned to this step
+ * @param context - mutable execution context
+ * @param options - execution options (model, cliAgent, hooks, etc.)
+ */
+async function executeStepInSwarm(host, step, agent, context, options) {
+    const resultIndex = context.results.findIndex(r => r.stepNumber === step.stepNumber);
+    const result = context.results[resultIndex];
+    if (!result) {
+        throw new Error(`Result for step ${step.stepNumber} not found`);
+    }
+    try {
+        // wait for dependencies with spinner feedback
+        if (step.dependencies.length > 0) {
+            const depSpinner = new spinner_1.Spinner(`Step ${step.stepNumber} — Waiting for dependencies (${step.dependencies.join(', ')})...`, { style: 'pulse', prefix: '  ' });
+            depSpinner.start();
+            try {
+                const satisfied = await context.contextBroker.waitForDependencies(step.dependencies, defaults_1.DEFAULT_DEPENDENCY_WAIT_MS);
+                if (!satisfied) {
+                    depSpinner.fail(`Step ${step.stepNumber} — Dependencies timeout`);
+                    throw new Error('Dependencies timeout after 10 minutes');
+                }
+                depSpinner.succeed(`Step ${step.stepNumber} — Dependencies ready`);
+            }
+            catch (depError) {
+                depSpinner.fail(`Step ${step.stepNumber} — Dependency failed`);
+                throw depError;
+            }
+        }
+        // Track step execution
+        context.metricsCollector?.trackStep(step.stepNumber, agent.name);
+        // create per-agent branch and worktree for true parallel isolation
+        const branchName = `swarm/${context.executionId}/step-${step.stepNumber}-${agent.name.toLowerCase()}`;
+        result.branchName = branchName;
+        result.status = 'running';
+        result.startTime = new Date().toISOString();
+        // Notify progress: step is now running
+        options?.onProgress?.(context, `step-running:${step.stepNumber}`);
+        // Use git worktree so each agent has its own isolated working directory
+        const stepRepoDir = step.repo || host.workingDir;
+        const worktreePath = await host.createAgentWorktree(branchName, context.mainBranch, context.runDir, step.stepNumber, stepRepoDir);
+        const liveStatus = (0, live_status_1.getLiveStatus)();
+        const liveStepId = `step-${step.stepNumber}`;
+        const liveLabel = `step-${step.stepNumber} ${agent.name}`;
+        // Capture baseline SHA before agent execution for outcome-based verification
+        const baseSha = (0, child_process_1.execSync)('git rev-parse HEAD', { cwd: worktreePath, encoding: 'utf8' }).trim();
+        // build enhanced prompt with dependency context
+        const strictIsolation = options?.strictIsolation ?? false;
+        const dependencyContext = context.contextBroker.getDependencyContext(step.dependencies, strictIsolation);
+        const enhancedPrompt = (0, prompt_builder_1.buildSwarmPrompt)(step, agent, { ...context, targetProjectRoot: host.workingDir }, dependencyContext);
+        // Inner fleet toggle: prefix prompt with /fleet for parallel sub-agent dispatch
+        const finalPrompt = options?.useInnerFleet
+            ? `/fleet ${enhancedPrompt}`
+            : enhancedPrompt;
+        // execute session on agent branch - IN THE WORKTREE DIRECTORY
+        const stepDir = path.join(context.runDir, 'steps', `step-${step.stepNumber}`);
+        const transcriptPath = path.join(stepDir, 'share.md');
+        // Ensure step directory exists before session runs
+        if (!fs.existsSync(stepDir)) {
+            fs.mkdirSync(stepDir, { recursive: true });
+        }
+        // Create a session executor for this worktree
+        // Per-step cliAgent takes priority; falls back to run-level option; defaults to copilot
+        const adapterName = step.cliAgent || options?.cliAgent || 'copilot';
+        const stepAdapter = (0, adapters_1.resolveAdapter)(adapterName);
+        const worktreeExecutor = new session_executor_1.default(worktreePath, stepAdapter);
+        // Route agent stdout/stderr lines through LiveStatus.print so they appear
+        // above the live block, prefixed with `step-N ›` (dim). When LiveStatus is
+        // inactive (CI / non-TTY where it was never started, or piped output), the
+        // print falls through to a plain stdout write, so behavior degrades.
+        const dimOpen = process.stdout.isTTY && !process.env.NO_COLOR ? '\x1b[2m' : '';
+        const dimClose = process.stdout.isTTY && !process.env.NO_COLOR ? '\x1b[22m' : '';
+        const linePrefix = `${dimOpen}${liveStepId} ›${dimClose}`;
+        const actionRe = /^\s*●\s+(.+?)\s*$/;
+        const sessionOptions = {
+            allowAllTools: true,
+            shareToFile: transcriptPath,
+            executionMode: 'auto',
+            persistentSessionId: `${context.executionId}:${adapterName}:${worktreePath}`,
+            onAgentLine: (line) => {
+                // Always update the live action from `●` markers so the user sees what
+                // the agent is currently doing. Only print the full narration line when
+                // --stream-agent is set; otherwise the firehose stays in the run
+                // transcript at runs/<id>/steps/step-N/share.md.
+                const match = actionRe.exec(line);
+                if (match) {
+                    liveStatus.setAction(liveStepId, match[1]);
+                }
+                if (options?.streamAgent) {
+                    liveStatus.print(`${linePrefix} ${line}`);
+                }
+            },
+            ...(options?.model && { model: options.model }),
+        };
+        // Generate per-step hooks for scope enforcement and evidence capture
+        // Hooks default to on unless explicitly disabled via --no-hooks
+        let generatedHooks;
+        if (options?.hooksEnabled !== false) {
+            const hookGen = new hook_generator_1.HookGenerator();
+            generatedHooks = hookGen.generateStepHooks({
+                step,
+                agent,
+                executionId: context.executionId,
+                runDir: context.runDir,
+                stepBranch: branchName,
+                workingDir: worktreePath,
+                existingTestFiles: context.baselineSnapshot?.testFiles || [],
+            });
+            // Hooks are auto-loaded by Copilot CLI from <gitRoot>/.github/hooks/
+        }
+        // only call the agent if we don't already have a session result
+        if (!result.sessionResult) {
+            liveStatus.addStep(liveStepId, liveLabel);
+            const sessionResult = await worktreeExecutor.executeSession(finalPrompt, sessionOptions);
+            result.sessionResult = sessionResult;
+            // Account-level fatal error: usage-limit, auth, or extended rate-limit.
+            // No replan or repair can recover, so abort the run before the
+            // verification + replan loop wastes the per-instance budget. The
+            // catch block at the bottom of this function records the failure
+            // and signals the broker so any waiting dependents unblock.
+            if (sessionResult.fatalError) {
+                throw new fatal_run_error_1.FatalRunError(sessionResult.fatalError, {
+                    stepNumber: step.stepNumber,
+                    agentName: agent.name,
+                });
+            }
+            // Non-zero exit code does not mean the agent failed its task.
+            // Claude Code often exits non-zero after completing file changes
+            // (e.g., cleanup command fails, permission prompt at exit). The
+            // verification pipeline below judges whether the work is acceptable;
+            // surface the exit code as a non-fatal note via the live block action.
+            if (!sessionResult.success) {
+                liveStatus.setAction(liveStepId, `non-zero exit ${sessionResult.exitCode}; checking work`);
+            }
+        }
+        // Clean up hook files after session completes (evidence log in runDir persists)
+        if (generatedHooks) {
+            const hookGen = new hook_generator_1.HookGenerator();
+            hookGen.cleanupHooks(generatedHooks.hooksFilePath);
+        }
+        // Check if transcript was created, create fallback if not
+        if (!fs.existsSync(transcriptPath)) {
+            const toolLabel = transcriptToolLabel(options?.cliAgent || 'copilot');
+            const fallbackContent = `# ${toolLabel} Session Transcript\n\nSession output:\n\`\`\`\n${result.sessionResult?.output || 'No output captured'}\n\`\`\`\n`;
+            fs.writeFileSync(transcriptPath, fallbackContent, 'utf8');
+        }
+        // parse transcript for context
+        const transcriptContent = fs.readFileSync(transcriptPath, 'utf8');
+        const shareIndex = host.shareParser.parse(transcriptContent);
+        // Track commits from this step
+        if (shareIndex.gitCommits) {
+            shareIndex.gitCommits.forEach(() => {
+                context.metricsCollector?.trackCommit(agent.name);
+            });
+            // Analyze commit quality for anti-patterns
+            await (0, commit_quality_analyzer_1.analyzeCommitQuality)(shareIndex.gitCommits, step.stepNumber, agent.name);
+        }
+        // Commit any uncommitted work the agent left behind.
+        // Some adapters (e.g. Codex) modify files without committing;
+        // the git_diff verification check only sees committed changes.
+        try {
+            const status = (0, child_process_1.execSync)('git status --porcelain', { cwd: worktreePath, encoding: 'utf8' }).trim();
+            if (status) {
+                // Exclude orchestrator-reserved and build-artifact paths from per-step commits.
+                // Bare `git add -A` captures orchestrator state written to runs/, plans/,
+                // .quickfix/, node_modules/, __pycache__, etc., bloating commit diffs with
+                // noise unrelated to the agent's actual work (smoke5c failure mode, issue #27).
+                // gitPathspecExcludes() mirrors the Python-side capture exclusion from
+                // worktree_reserved_paths.py so both sides stay in sync. See PR 2.
+                const excludes = (0, worktree_reserved_paths_1.gitPathspecExcludes)();
+                (0, child_process_1.execSync)(`git add -A -- . ${excludes.map(e => `'${e}'`).join(' ')}`, { cwd: worktreePath, stdio: 'pipe' });
+                (0, child_process_1.execSync)(`git commit -m "auto-commit uncommitted work from step ${step.stepNumber} (${agent.name})"`, { cwd: worktreePath, stdio: 'pipe', env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+            }
+        }
+        catch {
+            // Commit may fail if working tree is truly clean or in detached HEAD; non-fatal
+        }
+        // Verification phase: surface as a sub-action on the step's live line.
+        // When LiveStatus is inactive (non-TTY where it never started, tests),
+        // fall back to the legacy spinner so progress is still visible.
+        liveStatus.setAction(liveStepId, 'verifying work');
+        const verifySpinner = liveStatus.isTTY()
+            ? null
+            : new spinner_1.Spinner(`Step ${step.stepNumber} — Verifying work...`, { style: 'dots', prefix: '  ' });
+        verifySpinner?.start();
+        const verificationResult = await host.verifier.verifyStep(step.stepNumber, agent.name, transcriptPath, {
+            // only require tests if task explicitly mentions testing/test suite
+            requireTests: /\b(test suite|unit test|integration test|e2e test|write tests)\b/i.test(step.task),
+            // only require build if task explicitly mentions build process (not "build an app")
+            requireBuild: /\b(npm build|run build|compile|bundle|webpack)\b/i.test(step.task),
+            // commits are desired but not blocking for demo
+            requireCommits: false
+        }, shareIndex, generatedHooks?.evidenceLogPath, { workdir: worktreePath, baseSha });
+        result.verificationResult = verificationResult;
+        // Track verification result
+        context.metricsCollector?.trackVerification(verificationResult.passed);
+        // generate and commit verification report
+        const reportPath = path.join(context.runDir, 'verification', `step-${step.stepNumber}-verification.md`);
+        await host.verifier.generateVerificationReport(verificationResult, reportPath);
+        if (verificationResult.passed) {
+            verifySpinner?.stop();
+            liveStatus.finishStep(liveStepId, 'done', 'verified');
+            // add to shared context BEFORE advisory gates so replan steps can depend on this step
+            context.contextBroker.addStepContext({
+                stepNumber: step.stepNumber,
+                agentName: agent.name,
+                timestamp: new Date().toISOString(),
+                data: {
+                    filesChanged: shareIndex.changedFiles,
+                    outputsSummary: step.expectedOutputs.join(', '),
+                    branchName,
+                    commitShas: shareIndex.gitCommits.map(c => c.sha || 'unknown'),
+                    verificationPassed: verificationResult.passed,
+                    transcript: transcriptPath
+                }
+            });
+            await host.verifier.commitVerificationReport(reportPath, step.stepNumber, agent.name, true);
+            // Quality gates run only in the final pass (after all branches merged) to avoid
+            // spawning extra Copilot sessions mid-execution. The final gates block handles
+            // auto-remediation for every gate type, making per-step checks redundant.
+            // optional deployment for deployment-focused steps when --confirm-deploy is set
+            const isDeploymentStep = /\b(deploy|deployment|vercel|netlify)\b/i.test(step.task);
+            if (isDeploymentStep && options?.confirmDeploy) {
+                await (0, deployment_handler_1.executeOptionalDeployment)(host.workingDir, step, agent, {
+                    runDir: context.runDir,
+                    executionId: context.executionId,
+                    results: context.results,
+                    deployments: context.deployments,
+                }, {
+                    ...(options.confirmDeploy !== undefined && { confirmDeploy: options.confirmDeploy }),
+                    ...(options.enableExternal !== undefined && { enableExternal: options.enableExternal }),
+                    ...(options.dryRun !== undefined && { dryRun: options.dryRun }),
+                });
+            }
+        }
+        else {
+            // verification failed - attempt rollback
+            verifySpinner?.stop();
+            liveStatus.setAction(liveStepId, 'verification failed; rolling back');
+            const rollbackResult = await host.verifier.rollback(step.stepNumber, branchName, shareIndex.changedFiles, context.mainBranch);
+            const rollbackNote = rollbackResult.success
+                ? `verification failed · rolled back ${rollbackResult.filesRestored.length} file${rollbackResult.filesRestored.length === 1 ? '' : 's'}`
+                : 'verification failed';
+            liveStatus.finishStep(liveStepId, 'failed', rollbackNote);
+            throw new Error('Step failed verification - see verification report');
+        }
+        // context was already added before advisory gates block
+        result.status = 'completed';
+        result.endTime = new Date().toISOString();
+        // Record actual cost for this step
+        if (context.costEstimator && context.stepCostRecords) {
+            const stepEstimate = context.costEstimate?.perStep.find(s => s.stepNumber === step.stepNumber);
+            const durationMs = result.startTime && result.endTime
+                ? new Date(result.endTime).getTime() - new Date(result.startTime).getTime()
+                : 0;
+            // D5: Use instrumented request count from adapter when available.
+            // The adapter parses the actual CLI output for request markers
+            // (e.g. Copilot's "Requests N Premium" stderr summary).
+            // Fall back to 1 only when the adapter could not determine the count.
+            const instrumentedRequests = result.sessionResult?.premiumRequestsConsumed;
+            const actualRequests = typeof instrumentedRequests === 'number' ? instrumentedRequests : 1;
+            context.costEstimator.recordActual(step.stepNumber, stepEstimate?.estimatedPremiumRequests ?? 1, actualRequests, 0);
+            context.stepCostRecords.push({
+                stepNumber: step.stepNumber,
+                agentName: agent.name,
+                estimatedPremiumRequests: stepEstimate?.estimatedPremiumRequests ?? 1,
+                actualPremiumRequests: actualRequests,
+                retryCount: 0,
+                promptTokens: stepEstimate?.estimatedPromptTokens ?? 0,
+                fleetMode: !!options?.useInnerFleet,
+                durationMs,
+            });
+        }
+        // Notify progress: step completed
+        options?.onProgress?.(context, `step-done:${step.stepNumber}`);
+        // The per-branch merge confirmation ("✅ Merged swarm/...") is
+        // already emitted by BranchMerger. No need to announce the step's
+        // completion a third time after the verification spinner.
+    }
+    catch (error) {
+        const err = error;
+        result.status = 'failed';
+        result.error = err.message;
+        result.endTime = new Date().toISOString();
+        // Signal completion even for failed steps so dependent replan steps
+        // don't hang forever in waitForDependencies. The replan step can
+        // check context.results to see the step failed and adapt.
+        context.contextBroker.addStepContext({
+            stepNumber: step.stepNumber,
+            agentName: agent.name,
+            timestamp: new Date().toISOString(),
+            data: {
+                filesChanged: [],
+                outputsSummary: 'step failed verification',
+                branchName: result.branchName || '',
+                commitShas: [],
+                verificationPassed: false,
+                transcript: path.join(context.runDir, 'steps', `step-${step.stepNumber}`, 'share.md')
+            }
+        });
+        // Notify progress: step failed
+        options?.onProgress?.(context, `step-failed:${step.stepNumber}`);
+        // Move the step out of the live block with a failure marker. finishStep
+        // is idempotent on an already-finished step (it returns silently when the
+        // id is gone), so calling it here covers both fail-before-verify and
+        // verify-already-finished paths.
+        (0, live_status_1.getLiveStatus)().finishStep(`step-${step.stepNumber}`, 'failed', err.message);
+        throw error;
+    }
+}