@telora/daemon 0.12.33

package/dist/strategy-executor.js

@@ -0,0 +1,775 @@
+/**
+ * Strategy executor - manages Agent Team lifecycle per strategy.
+ *
+ * Replaces the per-delivery agent spawning model. When a strategy has
+ * an assigned agent role and queued deliveries, the executor spawns
+ * a single Agent Team (one lead agent process) scoped to the entire strategy.
+ *
+ * The lead agent:
+ * 1. Reads all deliveries + issues for the strategy
+ * 2. Builds a task DAG with dependencies
+ * 3. Spawns worker teammates to execute issues in parallel
+ * 4. Advances delivery stages as their issues complete
+ * 5. Terminates when all work is done; fresh team spawned for new work
+ *
+ * This module is the orchestration entry point. Pure logic is extracted to:
+ * - strategy-team-state.ts  -- active teams map, config derivation
+ * - strategy-merge.ts       -- branch merge logic
+ * - strategy-completion.ts  -- post-execution completion handling
+ */
+import { spawn } from 'node:child_process';
+import { mkdirSync, existsSync, createWriteStream } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createSession, updateSession, getReadyStrategies, } from './supabase.js';
+import { createWorktree, runGitSync } from './git.js';
+import { installAuditPreCommitHook } from './audit-hooks.js';
+import { getStrategyWorktree, setStrategyWorktree } from './strategy-worktree-state.js';
+import { withRetry, StreamJsonParser, sendMessage, productLabel } from '@telora/daemon-core';
+import { recordActivity, setNarration, clearNarration } from './heartbeat.js';
+import { CompletionDetector } from './completion-detector.js';
+import { formatEventForLog } from '@telora/daemon-core';
+import { ActivityTracker } from './activity-tracker.js';
+import { buildStrategyTeamPrompt, buildWakeMessage, buildReviewDirective } from './strategy-prompt-builder.js';
+import { getStrategyDeliveries, getStrategyIssues, getProductContextForStrategy, getProductDeploymentProfileSnapshot, updateStrategyClaudeSessionId } from './queries/strategies.js';
+import { buildSpawnEnvironment } from './spawn-environment.js';
+import { sanitizeGitSegment } from './git-utils.js';
+import { configForProduct, findProduct } from './config.js';
+// ── Re-exports from extracted modules (backward compatibility) ───────
+export { getActiveTeams, hasActiveTeam, getActiveTeamCount, } from './strategy-team-state.js';
+export { mergeStrategyBranch, } from './strategy-merge.js';
+export { handleTeamCompletion, advanceDeliveryStatuses, TERMINAL_DELIVERY_STATUSES, TEAM_WORK_STATUSES, } from './strategy-completion.js';
+// ── Imports from extracted modules (used internally) ─────────────────
+import { getActiveTeams, deriveExecutionConfig, } from './strategy-team-state.js';
+import { mergeStrategyBranch, escalateMergeConflict } from './strategy-merge.js';
+import { handleTeamCompletion, TERMINAL_DELIVERY_STATUSES, TEAM_WORK_STATUSES, } from './strategy-completion.js';
+// ── Resource governor (optional, injected by StrategyEngine) ─────────
+let governor = null;
+/** Inject the resource governor for global concurrency limiting. */
+export function initGovernor(gov) {
+    governor = gov;
+}
+/**
+ * Handle a 'complete' event from the CompletionDetector.
+ *
+ * Queries current delivery and issue state to decide whether to:
+ * - Terminate the team (all deliveries terminal or no open issues remain), or
+ * - Send a mid-strategy handoff message with remaining work.
+ *
+ * Extracted from the inline event callback in spawnStrategyTeam to eliminate
+ * deep nesting inside an async Promise chain inside an event listener.
+ */
+async function handleCompletionEvent(ctx) {
+    const { strategyId, strategyName, teamState, completionDetector, proc } = ctx;
+    const [currentDeliveries, currentIssues] = await Promise.all([
+        getStrategyDeliveries(strategyId),
+        getStrategyIssues(strategyId),
+    ]);
+    // If all deliveries are terminal, shut down.
+    // In review mode, in_review deliveries are the team's active work -- not terminal.
+    const effectiveTerminal = teamState.reviewMode
+        ? new Set([...TERMINAL_DELIVERY_STATUSES].filter(s => s !== 'in_review'))
+        : TERMINAL_DELIVERY_STATUSES;
+    const allTerminal = currentDeliveries.every(d => effectiveTerminal.has(d.executionStatus ?? ''));
+    if (allTerminal) {
+        console.log(`[strategy-executor] All deliveries terminal for "${strategyName}" -- terminating team`);
+        teamState.shutdownReason = 'work_complete';
+        terminateTeam(strategyId);
+        return;
+    }
+    // Check if there are actionable deliveries with open issues.
+    // In review mode, in_review deliveries are the team's work.
+    const actionableStatuses = teamState.reviewMode
+        ? new Set(['queued', 'coding', 'in_review'])
+        : new Set(['queued', 'coding']);
+    const actionableDeliveryIds = new Set(currentDeliveries
+        .filter(d => actionableStatuses.has(d.executionStatus ?? ''))
+        .map(d => d.id));
+    if (actionableDeliveryIds.size === 0) {
+        console.log(`[strategy-executor] No actionable deliveries for "${strategyName}" -- terminating team`);
+        teamState.shutdownReason = 'work_complete';
+        terminateTeam(strategyId);
+        return;
+    }
+    const OPEN_ISSUE_STATUSES = new Set(['To Do', 'In Progress', 'Blocked', 'In Review']);
+    const hasOpenIssues = currentIssues.some(i => actionableDeliveryIds.has(i.deliveryId) && OPEN_ISSUE_STATUSES.has(i.status));
+    if (!hasOpenIssues) {
+        console.log(`[strategy-executor] Actionable deliveries have no open issues for "${strategyName}" -- ` +
+            `terminating team. Auto-advance will handle verify transition.`);
+        teamState.shutdownReason = 'work_complete';
+        terminateTeam(strategyId);
+        return;
+    }
+    // Mid-strategy handoff: actionable work with open issues remains.
+    // Send work immediately and reset the completion detector for the next cycle.
+    console.log(`[strategy-executor] Mid-strategy handoff for "${strategyName}" -- sending new work`);
+    const message = buildWakeMessage(currentDeliveries, currentIssues, teamState.knownDeliveryIds);
+    // Update tracking state
+    for (const d of currentDeliveries) {
+        teamState.knownDeliveryIds.add(d.id);
+        teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
+    }
+    completionDetector.reset();
+    sendMessage(proc.stdin, message);
+}
+// ── Team spawning ────────────────────────────────────────────────────
+/**
+ * Generate branch name for strategy-level work.
+ */
+export function generateStrategyBranchName(role, strategyName, strategyId) {
+    const sanitizedRoleName = sanitizeGitSegment(role.name);
+    const shortId = strategyId.slice(0, 8);
+    const sanitizedStrategyName = sanitizeGitSegment(strategyName);
+    return `agent/${sanitizedRoleName}/${sanitizedStrategyName}-${shortId}`;
+}
+/**
+ * Build Claude Code CLI arguments for the team lead.
+ */
+function buildTeamLeadArgs(config, pipelineConfig, reviewMode = false, resumeSessionId) {
+    const args = [];
+    // --resume must come early, before --input-format stream-json
+    if (resumeSessionId) {
+        args.push('--resume', resumeSessionId);
+    }
+    args.push('--dangerously-skip-permissions');
+    args.push('--setting-sources', 'project,local');
+    args.push('--input-format', 'stream-json');
+    args.push('--output-format', 'stream-json');
+    args.push('--verbose');
+    // Enable in-process teammate mode for the team lead
+    args.push('--teammate-mode', 'in-process');
+    if (config.mcpConfigPath) {
+        const absoluteMcpPath = resolve(config.mcpConfigPath);
+        args.push('--mcp-config', absoluteMcpPath);
+    }
+    // Reviews always use Sonnet; otherwise honour pipeline config
+    const model = reviewMode ? 'claude-sonnet-4-6' : pipelineConfig?.model;
+    if (model) {
+        args.push('--model', model);
+    }
+    return args;
+}
+/**
+ * Spawn a strategy team to execute all deliveries in a strategy.
+ *
+ * Creates a single Agent Team (lead process) that reads all deliveries
+ * and issues, builds a task DAG, and coordinates worker execution.
+ */
+export async function spawnStrategyTeam(params) {
+    const { config, strategyId, strategyName, role, pipelineConfig, readOnly = false, reviewMode = false, lastClaudeSessionId } = params;
+    const activeTeams = getActiveTeams();
+    // Prevent double-spawn
+    if (activeTeams.has(strategyId)) {
+        console.warn(`[strategy-executor] Team already active for strategy "${strategyName}", skipping spawn`);
+        return;
+    }
+    const executionConfig = deriveExecutionConfig(pipelineConfig);
+    const branchName = generateStrategyBranchName(role, strategyName, strategyId);
+    // Initialize team state
+    const teamState = {
+        strategyId,
+        strategyName,
+        roleId: role.id,
+        roleName: role.name,
+        organizationId: config.organizationId,
+        productId: config.productId,
+        executionConfig,
+        pipelineConfig,
+        startedAt: new Date(),
+        phase: 'initializing',
+        knownDeliveryIds: new Set(),
+        mergedDeliveryIds: new Set(),
+        shutdownReason: null,
+        deliveryStageIds: new Map(),
+        leadSessionId: null,
+        leadPid: null,
+        leadStdin: null,
+        branchName,
+        worktreePath: null,
+        resolvingMergeConflict: false,
+        readOnly,
+        reviewMode,
+        completionDetector: null,
+        claudeSessionId: null,
+    };
+    activeTeams.set(strategyId, teamState);
+    const currentProduct = config.products.find(p => p.id === config.productId);
+    const productTag = config.products.length > 1 && currentProduct ? ` [${productLabel(currentProduct)}]` : '';
+    console.log(`[strategy-executor] Spawning team for strategy "${strategyName}"${readOnly ? ' [READ-ONLY]' : ''}${productTag}`);
+    console.log(`  Role: ${role.name}`);
+    console.log(`  Model: ${reviewMode ? 'claude-sonnet-4-6' : (pipelineConfig?.model ?? '(CLI default)')}`);
+    console.log(`  Max workers: ${executionConfig.maxWorkers}`);
+    console.log(`  Branch: ${branchName}`);
+    if (config.products.length > 1) {
+        console.log(`  Product: ${currentProduct ? productLabel(currentProduct) : config.productId.slice(0, 8)}`);
+        console.log(`  Repo: ${config.repoPath}`);
+    }
+    // Fetch all deliveries, issues, product context, and deployment profile for the strategy
+    let deliveries;
+    let issues;
+    let productContextDocs;
+    let deploymentProfileSnapshot;
+    try {
+        [deliveries, issues, productContextDocs, deploymentProfileSnapshot] = await Promise.all([
+            getStrategyDeliveries(strategyId),
+            getStrategyIssues(strategyId),
+            getProductContextForStrategy(config.productId, strategyId),
+            getProductDeploymentProfileSnapshot(config.productId).catch((err) => {
+                console.debug(`[strategy-executor] Could not fetch deployment profile snapshot (non-fatal):`, err.message);
+                return null;
+            }),
+        ]);
+    }
+    catch (err) {
+        console.error(`[strategy-executor] Failed to fetch context for strategy "${strategyName}":`, err.message);
+        activeTeams.delete(strategyId);
+        return;
+    }
+    // Pre-spawn guard: enforce rank-ordered execution.
+    // Walk deliveries in priority_rank order (already sorted by API).
+    // A delivery is actionable only if all lower-ranked deliveries are non-blocking.
+    // Skipped in review mode -- review teams are spawned for verify-only strategies.
+    const nonBlockingStatuses = new Set(['done', 'cancelled', 'verify', 'in_review', 'iterating']);
+    const actionableStatuses = new Set(['queued', 'coding']);
+    let nextActionable = null;
+    if (!reviewMode) {
+        for (const d of deliveries) {
+            const status = d.executionStatus ?? '';
+            if (nonBlockingStatuses.has(status))
+                continue;
+            if (actionableStatuses.has(status)) {
+                nextActionable = d;
+            }
+            else {
+                // Blocking status (planning, iterating, paused) prevents subsequent deliveries
+                console.log(`[strategy-executor] Delivery "${d.name}" (rank ${d.priorityRank}) ` +
+                    `is in "${status}" state -- blocking subsequent deliveries in strategy "${strategyName}"`);
+            }
+            break;
+        }
+        if (!nextActionable || !actionableStatuses.has(nextActionable.executionStatus ?? '')) {
+            console.log(`[strategy-executor] No actionable (queued/coding) deliveries for strategy "${strategyName}" -- skipping spawn`);
+            activeTeams.delete(strategyId);
+            return;
+        }
+    }
+    const actionableDeliveries = reviewMode
+        ? deliveries.filter(d => d.executionStatus === 'in_review')
+        : deliveries.filter(d => actionableStatuses.has(d.executionStatus ?? ''));
+    // Track known deliveries, pre-populate already-completed ones
+    for (const d of deliveries) {
+        teamState.knownDeliveryIds.add(d.id);
+        teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
+        if (d.executionStatus === 'verify' || d.executionStatus === 'in_review' || d.executionStatus === 'done') {
+            teamState.mergedDeliveryIds.add(d.id);
+        }
+    }
+    console.log(`  Deliveries: ${deliveries.length} (${actionableDeliveries.length} queued)`);
+    console.log(`  Issues: ${issues.length}`);
+    // Ensure log directory exists
+    if (!existsSync(config.logDir)) {
+        mkdirSync(config.logDir, { recursive: true, mode: 0o700 });
+    }
+    // Reuse persistent strategy worktree (created by ensureStrategyWorktrees in poll loop)
+    let worktreePath;
+    const existingWorktree = getStrategyWorktree(strategyId);
+    if (existingWorktree) {
+        worktreePath = existingWorktree.worktreePath;
+        // Rebase onto integration to pick up latest changes from other strategies
+        const rebaseResult = runGitSync(['rebase', config.integrationBranch], worktreePath);
+        if (!rebaseResult.success) {
+            runGitSync(['rebase', '--abort'], worktreePath);
+            console.warn(`[strategy-executor] Rebase failed for "${strategyName}", continuing with existing state`);
+        }
+        console.log(`  Worktree (reused): ${worktreePath}`);
+    }
+    else {
+        // Fallback: worktree doesn't exist yet (race condition or first poll)
+        console.warn(`[strategy-executor] No persistent worktree for "${strategyName}", creating inline`);
+        try {
+            worktreePath = await createWorktree(config, branchName);
+            setStrategyWorktree(strategyId, {
+                strategyId,
+                strategyName,
+                worktreePath,
+                branchName,
+                createdAt: new Date(),
+                hasQaDevServer: false,
+            });
+            console.log(`  Worktree (created inline): ${worktreePath}`);
+            // Install audit pre-commit hook for read-only strategies
+            if (readOnly) {
+                installAuditPreCommitHook(worktreePath);
+                console.log(`  Installed audit pre-commit hook (read-only mode)`);
+            }
+        }
+        catch (err) {
+            console.error(`[strategy-executor] Failed to create worktree for strategy "${strategyName}":`, err instanceof Error ? err.message : String(err));
+            activeTeams.delete(strategyId);
+            return;
+        }
+    }
+    teamState.worktreePath = worktreePath;
+    // Create session record for the team lead
+    let session;
+    try {
+        session = await createSession({
+            organizationId: config.organizationId,
+            roleId: role.id,
+            issueId: null,
+            strategyId,
+            branchName,
+            sessionType: reviewMode ? 'review' : 'coding',
+        });
+        teamState.leadSessionId = session.id;
+    }
+    catch (err) {
+        console.error(`[strategy-executor] Failed to create session for strategy "${strategyName}":`, err.message);
+        // Worktree is strategy-owned and persists even if session creation fails
+        activeTeams.delete(strategyId);
+        return;
+    }
+    recordActivity();
+    // Build the team lead prompt with full strategy context
+    const prompt = buildStrategyTeamPrompt(role, {
+        strategyId,
+        strategyName,
+        organizationId: config.organizationId,
+        productId: config.productId,
+        deliveries,
+        issues,
+        executionConfig,
+        pipelineConfig,
+        productContextDocs,
+        deploymentProfileSnapshot,
+        readOnly,
+    });
+    // Log file paths
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const logPrefix = `strategy-${branchName.replace(/\//g, '-')}-${timestamp}`;
+    const stdoutPath = join(config.logDir, `${logPrefix}.stdout.log`);
+    const stderrPath = join(config.logDir, `${logPrefix}.stderr.log`);
+    const jsonlPath = join(config.logDir, `${logPrefix}.stream.jsonl`);
+    // Open log files
+    const stdoutLogStream = createWriteStream(stdoutPath, { mode: 0o600 });
+    const stderrStream = createWriteStream(stderrPath, { mode: 0o600 });
+    const jsonlStream = createWriteStream(jsonlPath, { mode: 0o600 });
+    // Attach error handlers to prevent unhandled 'error' events from crashing the daemon
+    stdoutLogStream.on('error', (err) => {
+        console.warn(`[strategy-executor] stdout log stream error for "${strategyName}": ${err.message}`);
+    });
+    stderrStream.on('error', (err) => {
+        console.warn(`[strategy-executor] stderr log stream error for "${strategyName}": ${err.message}`);
+    });
+    jsonlStream.on('error', (err) => {
+        console.warn(`[strategy-executor] jsonl log stream error for "${strategyName}": ${err.message}`);
+    });
+    // Build args and env
+    // Pass lastClaudeSessionId for resume support (never for review teams)
+    const resumeId = reviewMode ? null : (lastClaudeSessionId ?? null);
+    const args = buildTeamLeadArgs(config, pipelineConfig, reviewMode, resumeId);
+    if (resumeId) {
+        console.log(`[strategy-executor] Resuming Claude session ${resumeId} for "${strategyName}"`);
+    }
+    const spawnEnv = buildSpawnEnvironment(config, {
+        orgId: config.organizationId,
+        strategyId,
+        sessionId: session.id,
+    });
+    // Update session to starting
+    await updateSession(session.id, {
+        status: 'starting',
+        started_at: new Date().toISOString(),
+        stdout_path: stdoutPath,
+        stderr_path: stderrPath,
+    });
+    // Acquire governor slot (if governor is configured)
+    if (governor) {
+        try {
+            await governor.acquireSlot('strategy');
+        }
+        catch (err) {
+            console.warn(`[strategy-executor] Governor denied slot for "${strategyName}":`, err.message);
+            // Mark session as failed so it doesn't linger in `starting` status
+            await updateSession(session.id, {
+                status: 'failed',
+                exit_reason: 'Governor denied slot',
+                ended_at: new Date().toISOString(),
+            }).catch(updateErr => {
+                console.warn(`[strategy-executor] Failed to update session after governor denial:`, updateErr.message);
+            });
+            activeTeams.delete(strategyId);
+            return;
+        }
+    }
+    // Spawn the team lead process
+    const proc = spawn(config.claudeCodePath, args, {
+        cwd: worktreePath,
+        env: spawnEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    teamState.leadPid = proc.pid ?? null;
+    teamState.leadStdin = proc.stdin;
+    teamState.phase = 'executing';
+    // Set up stream parsing
+    const streamParser = new StreamJsonParser();
+    const completionDetector = new CompletionDetector();
+    streamParser.attach(proc.stdout);
+    completionDetector.attach(streamParser);
+    teamState.completionDetector = completionDetector;
+    // Attach activity tracker for live activity snapshots
+    const activityTracker = new ActivityTracker(session.id);
+    activityTracker.onNarration((text) => setNarration(strategyId, text));
+    activityTracker.attach(streamParser);
+    // Write raw NDJSON lines to jsonl log file
+    streamParser.on('event', (event) => {
+        jsonlStream.write(JSON.stringify(event) + '\n');
+    });
+    // Write human-readable lines to stdout log
+    streamParser.on('event', (event) => {
+        const line = formatEventForLog(event);
+        if (line) {
+            stdoutLogStream.write(line + '\n');
+        }
+    });
+    // Track session state from stream events
+    streamParser.on('init', (event) => {
+        console.log(`  [strategy-team] Session initialized (model: ${event.model}, tools: ${event.tools.length})`);
+        teamState.claudeSessionId = event.session_id;
+        // Persist session ID for --resume support on re-spawn
+        updateStrategyClaudeSessionId(strategyId, event.session_id).catch((err) => {
+            console.warn(`[strategy-executor] Failed to persist Claude session ID for "${strategyName}":`, err.message);
+        });
+    });
+    streamParser.on('teammate', (event) => {
+        if (event.subtype === 'teammate_spawned') {
+            console.log(`  [strategy-team] Worker spawned: ${event.agent_name}`);
+        }
+        else if (event.subtype === 'teammate_completed') {
+            const status = event.is_error ? 'FAILED' : 'completed';
+            console.log(`  [strategy-team] Worker ${status}: ${event.agent_name}`);
+        }
+    });
+    streamParser.on('result', (result) => {
+        const cost = result.total_cost_usd?.toFixed(4) ?? '?';
+        console.log(`  [strategy-team] Result: ${result.is_error ? 'ERROR' : 'Success'}: ${result.num_turns} turns, $${cost}`);
+    });
+    // Stderr pipes to log
+    proc.stderr?.pipe(stderrStream);
+    // Send prompt via stdin
+    sendMessage(proc.stdin, prompt);
+    // In review mode, immediately send the review directive after the initial prompt
+    if (reviewMode) {
+        const reviewDeliveries = deliveries.filter(d => d.executionStatus === 'in_review');
+        if (reviewDeliveries.length > 0) {
+            const reviewDirective = buildReviewDirective(reviewDeliveries, issues);
+            sendMessage(proc.stdin, reviewDirective);
+        }
+    }
+    // Update session to running
+    await updateSession(session.id, {
+        status: 'running',
+        pid: proc.pid,
+    });
+    console.log(`[strategy-executor] Team lead spawned for "${strategyName}" (PID: ${proc.pid}, session: ${session.id})${reviewMode ? ' [REVIEW MODE]' : ''}`);
+    // Handle completion -- check for more work or terminate.
+    // No idle phase: if actionable work remains, send it immediately (mid-strategy
+    // handoff). If all work is done, terminate. A fresh team is spawned if new
+    // deliveries arrive later (~$0.50-1.00 exploration cost, but clean context).
+    completionDetector.on('complete', (info) => {
+        console.log(`[strategy-executor] Team lead for "${strategyName}" completed work cycle: ` +
+            `${info.turnCount} turns, $${info.totalCostUsd.toFixed(4)}`);
+        handleCompletionEvent({ strategyId, strategyName, teamState, completionDetector, proc }).catch(err => {
+            console.warn(`[strategy-executor] Failed to check delivery state for "${strategyName}":`, err.message);
+            // Fallback: terminate to avoid idle money burn.
+            terminateTeam(strategyId);
+        });
+    });
+    // Handle process exit
+    const spawnedAt = Date.now();
+    proc.on('close', async (code, signal) => {
+        console.log(`[strategy-executor] Team lead for "${strategyName}" exited (code: ${code}, signal: ${signal})`);
+        // Detect --resume failure: if the process exits quickly with a non-zero
+        // code and --resume was used, retry without resume. This handles cases
+        // where the session file was cleaned up, corrupted, or incompatible.
+        const RESUME_FAILURE_THRESHOLD_MS = 15_000;
+        const elapsedMs = Date.now() - spawnedAt;
+        if (resumeId && code !== 0 && code !== null && elapsedMs < RESUME_FAILURE_THRESHOLD_MS) {
+            console.warn(`[strategy-executor] Resume failed for "${strategyName}" (exited in ${elapsedMs}ms), retrying without resume`);
+            // Release governor slot and clean up minimal state
+            governor?.releaseSlot('strategy');
+            completionDetector.destroy();
+            stdoutLogStream.end();
+            stderrStream.end();
+            jsonlStream.end();
+            // Clean up session and team state
+            try {
+                await updateSession(session.id, {
+                    status: 'failed',
+                    exit_reason: `Resume failed (code ${code}), retrying without resume`,
+                    ended_at: new Date().toISOString(),
+                });
+            }
+            catch (updateErr) {
+                console.warn('[strategy-executor] Failed to update session after resume failure:', updateErr.message);
+            }
+            teamState.phase = 'terminated';
+            activeTeams.delete(strategyId);
+            // Re-spawn without --resume
+            await spawnStrategyTeam({ ...params, lastClaudeSessionId: null });
+            return;
+        }
+        // Release governor slot (if governor is configured)
+        governor?.releaseSlot('strategy');
+        // Null out stdin so post-exit merge logic falls through to the
+        // fallback resolution agent instead of sending messages to a dead process.
+        teamState.leadStdin = null;
+        // Final activity flush before cleanup
+        try {
+            await activityTracker.finalFlush();
+        }
+        catch (err) {
+            console.warn('[strategy-executor] activityTracker.finalFlush failed:', err.message);
+        }
+        // Clean up streams
+        completionDetector.destroy();
+        stdoutLogStream.end();
+        stderrStream.end();
+        jsonlStream.end();
+        recordActivity();
+        await handleTeamCompletion({
+            config,
+            teamState,
+            sessionId: session.id,
+            code,
+            signal,
+        });
+    });
+    proc.on('error', async (err) => {
+        console.error(`[strategy-executor] Team lead for "${strategyName}" error:`, err.message);
+        // Release governor slot (if governor is configured)
+        governor?.releaseSlot('strategy');
+        try {
+            await withRetry(() => updateSession(session.id, {
+                status: 'failed',
+                exit_reason: `Process error: ${err.message}`,
+                ended_at: new Date().toISOString(),
+            }), { maxAttempts: 3, baseDelayMs: 1000, label: 'session-update-error' });
+        }
+        catch (updateErr) {
+            console.warn(`[strategy-executor] Failed to update session after retries:`, updateErr.message);
+        }
+        completionDetector.destroy();
+        stdoutLogStream.end();
+        stderrStream.end();
+        jsonlStream.end();
+        // Worktree is strategy-owned — do not remove on team error
+        teamState.phase = 'terminated';
+        activeTeams.delete(strategyId);
+    });
+}
+// ── Team lifecycle management ────────────────────────────────────────
+/**
+ * Terminate a strategy team.
+ *
+ * Sends a deactivation message via stdin (if open) before SIGTERM
+ * to allow the team lead to process the shutdown gracefully.
+ */
+export function terminateTeam(strategyId) {
+    const activeTeams = getActiveTeams();
+    const team = activeTeams.get(strategyId);
+    if (!team || !team.leadPid)
+        return false;
+    // Warn if terminating while conflict resolution is in progress
+    if (team.resolvingMergeConflict) {
+        console.warn(`[strategy-executor] Terminating team "${team.strategyName}" while merge conflict resolution is in progress`);
+    }
+    console.log(`[strategy-executor] Terminating team for strategy "${team.strategyName}" (phase: ${team.phase})`);
+    team.phase = 'shutting_down';
+    clearNarration(strategyId);
+    try {
+        // Send a deactivation message first to let the team lead process it
+        if (team.leadStdin) {
+            sendMessage(team.leadStdin, 'Pipeline deactivated. Exit now.');
+            // Close stdin after a short delay to let the message be processed
+            setTimeout(() => {
+                try {
+                    team.leadStdin?.end();
+                }
+                catch (e) {
+                    console.debug('[strategy-executor] stdin.end() failed (may already be closed):', e.message);
+                }
+            }, 5000);
+        }
+        // SIGTERM to the lead process -- it should clean up workers
+        process.kill(team.leadPid, 'SIGTERM');
+        // Escalate to SIGKILL after timeout
+        setTimeout(() => {
+            if (activeTeams.has(strategyId) && team.leadPid) {
+                try {
+                    process.kill(team.leadPid, 'SIGKILL');
+                }
+                catch (e) {
+                    console.debug('[strategy-executor] SIGKILL failed (process may have exited):', e.message);
+                }
+            }
+        }, 30000);
+        return true;
+    }
+    catch (e) {
+        console.debug(`[strategy-executor] terminateTeam: process may have already exited:`, e.message);
+        return false;
+    }
+}
+/**
+ * Wait for a team's process to exit (leave activeTeams).
+ *
+ * Polls activeTeams until the strategy is no longer present,
+ * which happens when handleTeamCompletion runs on the 'close' event.
+ * If the timeout expires, sends SIGKILL and waits briefly.
+ *
+ * @param strategyId - Strategy to wait for
+ * @param timeoutMs - Max wait time in ms (default 30s)
+ * @returns true if team exited within timeout, false if forced
+ */
+export async function waitForTeamExit(strategyId, timeoutMs = 30000) {
+    const activeTeams = getActiveTeams();
+    const team = activeTeams.get(strategyId);
+    if (!team)
+        return true; // Already gone
+    const deadline = Date.now() + timeoutMs;
+    const pollMs = 500;
+    while (Date.now() < deadline) {
+        if (!activeTeams.has(strategyId))
+            return true;
+        await new Promise(resolve => setTimeout(resolve, pollMs));
+    }
+    // Timeout expired — escalate to SIGKILL
+    if (team.leadPid) {
+        console.warn(`[strategy-executor] Team "${team.strategyName}" did not exit within ${timeoutMs}ms, sending SIGKILL`);
+        try {
+            process.kill(team.leadPid, 'SIGKILL');
+        }
+        catch { /* process may already be gone */ }
+        // Brief wait for SIGKILL to take effect
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    return !activeTeams.has(strategyId);
+}
+/**
+ * Terminate all active teams.
+ */
+export function terminateAllTeams() {
+    const activeTeams = getActiveTeams();
+    for (const strategyId of activeTeams.keys()) {
+        terminateTeam(strategyId);
+    }
+}
+/**
+ * Detect strategies that have been deactivated (agent role removed)
+ * and shut down their active teams.
+ */
+export async function detectDeactivatedStrategies(config) {
+    const activeTeams = getActiveTeams();
+    if (activeTeams.size === 0)
+        return;
+    try {
+        // Aggregate ready strategies across all configured products
+        const allReadyStrategies = [];
+        for (const product of config.products) {
+            const strategies = await getReadyStrategies(config.organizationId, product.id);
+            allReadyStrategies.push(...strategies);
+        }
+        const activeStrategyIds = new Set(allReadyStrategies.map(s => s.strategy_id));
+        for (const [strategyId, team] of activeTeams) {
+            if (!activeStrategyIds.has(strategyId) && team.phase !== 'shutting_down' && team.phase !== 'terminated') {
+                console.log(`[strategy-executor] Strategy "${team.strategyName}" deactivated -- shutting down team`);
+                terminateTeam(strategyId);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`[strategy-executor] Failed to check for deactivated strategies:`, err.message);
+    }
+}
+/**
+ * Check active teams for newly completed deliveries and merge
+ * the strategy branch to integration incrementally.
+ *
+ * Called from the poll loop. For each active team, queries delivery
+ * statuses and triggers a merge when any delivery reaches verify/done
+ * that hasn't already been merged mid-flight.
+ *
+ * After processing merges, checks if ALL active deliveries are terminal
+ * and merged. If so, terminates the team proactively since no more work
+ * remains. The strategy stays active in the DB -- if new deliveries
+ * arrive later, the next poll cycle spawns a fresh team.
+ */
+export async function checkAndMergeCompletedDeliveries(config) {
+    const activeTeams = getActiveTeams();
+    if (activeTeams.size === 0)
+        return;
+    for (const [strategyId, team] of activeTeams) {
+        // Only check teams that are actively executing
+        if (team.phase !== 'executing')
+            continue;
+        // Skip merge attempts while team lead is resolving a merge conflict
+        if (team.resolvingMergeConflict) {
+            console.log(`[strategy-executor] Skipping merge check for "${team.strategyName}" -- conflict resolution in progress`);
+            continue;
+        }
+        // Use product-scoped config for this team's merge operations
+        const teamProduct = findProduct(config, team.productId);
+        const teamConfig = teamProduct ? configForProduct(config, teamProduct) : config;
+        try {
+            const deliveries = await getStrategyDeliveries(strategyId);
+            // Find deliveries in verify/done that we haven't merged for yet
+            const newlyCompleted = deliveries.filter(d => (d.executionStatus === 'verify' || d.executionStatus === 'done')
+                && !team.mergedDeliveryIds.has(d.id));
+            if (newlyCompleted.length > 0) {
+                const completedNames = newlyCompleted.map(d => d.name).join(', ');
+                console.log(`[strategy-executor] ${newlyCompleted.length} delivery(ies) completed mid-flight for "${team.strategyName}": ${completedNames} -- merging to integration`);
+                // One merge covers all completed deliveries (same branch)
+                const mergeResult = await mergeStrategyBranch(teamConfig, team, team.leadSessionId ?? '', team.branchName);
+                if (mergeResult.mergeSucceeded) {
+                    // Track merged deliveries (git state already reported by mergeStrategyBranch)
+                    for (const d of newlyCompleted) {
+                        team.mergedDeliveryIds.add(d.id);
+                    }
+                }
+                else {
+                    console.warn(`[strategy-executor] Mid-flight merge failed for "${team.strategyName}": ${mergeResult.exitReason}`);
+                    // Escalate merge conflict for each unmerged delivery
+                    for (const d of newlyCompleted) {
+                        escalateMergeConflict({
+                            organizationId: team.organizationId,
+                            sessionId: team.leadSessionId ?? '',
+                            deliveryId: d.id,
+                            deliveryName: d.name,
+                            branchName: team.branchName,
+                            integrationBranch: config.integrationBranch,
+                            mergeError: mergeResult.exitReason,
+                        }).catch(err => console.warn(`[strategy-executor] escalateMergeConflict failed for ${d.id}:`, err.message));
+                    }
+                    // Don't mark as merged -- will retry next poll. Team continues working.
+                }
+            }
+            // ── All-done detection ──────────────────────────────────────
+            // If any delivery is queued or running, the team still has work.
+            // In review mode, in_review deliveries are the team's active work.
+            // Otherwise the team is idle, waiting for the daemon to push new work.
+            const teamWork = deliveries.filter(d => TEAM_WORK_STATUSES.has(d.executionStatus ?? '')
+                || (team.reviewMode && d.executionStatus === 'in_review'));
+            if (teamWork.length > 0) {
+                console.log(`[strategy-executor] ${teamWork.length} delivery(ies) still queued/running for "${team.strategyName}" -- team continues`);
+                continue;
+            }
+            // No queued/running deliveries -- team is idle, completion detector
+            // handles the actual idle transition. Log for observability.
+            console.log(`[strategy-executor] All deliveries complete for "${team.strategyName}" -- team is idle`);
+        }
+        catch (err) {
+            console.warn(`[strategy-executor] Failed to check completed deliveries for "${team.strategyName}":`, err.message);
+        }
+    }
+}
+//# sourceMappingURL=strategy-executor.js.map