@telora/daemon 0.14.2 → 0.14.3

package/dist/strategy-completion-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-completion-event.js","sourceRoot":"","sources":["../src/strategy-completion-event.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAa7D,2EAA2E;AAE3E;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,GAA2B;IACrE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC;IAE9E,MAAM,CAAC,iBAAiB,EAAE,aAAa,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC3D,qBAAqB,CAAC,UAAU,CAAC;QACjC,iBAAiB,CAAC,UAAU,CAAC;KAC9B,CAAC,CAAC;IAEH,6CAA6C;IAC7C,MAAM,WAAW,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAC9C,gBAAgB,CAAC,CAAC,CAAC,eAAe,IAAI,EAAE,CAAC,CAC1C,CAAC;IACF,IAAI,WAAW,EAAE,CAAC;QAChB,OAAO,CAAC,GAAG,CACT,oDAAoD,YAAY,uBAAuB,CACxF,CAAC;QACF,SAAS,CAAC,cAAc,GAAG,eAAe,CAAC;QAC3C,aAAa,CAAC,UAAU,CAAC,CAAC;QAC1B,OAAO;IACT,CAAC;IAED,6DAA6D;IAC7D,MAAM,qBAAqB,GAAG,IAAI,GAAG,CACnC,iBAAiB;SACd,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,uBAAuB,CAAC,CAAC,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;SAC7D,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAClB,CAAC;IAEF,IAAI,qBAAqB,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QACrC,OAAO,CAAC,GAAG,CACT,qDAAqD,YAAY,uBAAuB,CACzF,CAAC;QACF,SAAS,CAAC,cAAc,GAAG,eAAe,CAAC;QAC3C,aAAa,CAAC,UAAU,CAAC,CAAC;QAC1B,OAAO;IACT,CAAC;IAED,sDAAsD;IACtD,MAAM,aAAa,GAAG,aAAa,CAAC,IAAI,CACtC,CAAC,CAAC,EAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAClF,CAAC;IAEF,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,OAAO,CAAC,GAAG,CACT,sEAAsE,YAAY,OAAO;YACzF,+DAA+D,CAChE,CAAC;QACF,SAAS,CAAC,cAAc,GAAG,eAAe,CAAC;QAC3C,aAAa,CAAC,UAAU,CAAC,CAAC;QAC1B,OAAO;IACT,CAAC;IAED,kEAAkE;IAClE,8EAA8E;IAC9E,OAAO,CAAC,GAAG,CACT,iDAAiD,YAAY,uBAAuB,CACrF,CAAC;IACF,MAAM,OAAO,GAAG,gBAAgB,CAAC,iBAAiB,EAAE,aAAa,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAE/F,wBAAwB;IACxB,KAAK,MAAM,CAAC,IAAI,iBAAiB,EAAE,CAAC;QAClC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACrC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,sBAAsB,CAAC,CAAC;IACjE,CAAC;IAED,kBAAkB,CAAC,KAAK,EAAE,CAAC;IAC3B,WAAW,CAAC,IAAI,CAAC,KAAM,EAAE,OAAO,CAAC,CAAC;AACpC,CAAC"}

package/dist/strategy-executor.d.ts

@@ -13,9 +13,12 @@
  * 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
+ * - strategy-team-state.ts          -- active teams map, config derivation
+ * - strategy-merge.ts               -- branch merge logic
+ * - strategy-completion.ts          -- post-execution completion handling
+ * - strategy-spawn-helpers.ts       -- log streams, stream handlers, process close
+ * - strategy-team-lifecycle.ts      -- terminate, wait, detect deactivated, merge checks
+ * - strategy-completion-event.ts    -- completion event handler
  */
 import type { DaemonConfig, AgentRole, PipelineConfig } from './types.js';
 import { type ResourceGovernor } from '@telora/daemon-core';
@@ -24,6 +27,8 @@ export { getActiveTeams, hasActiveTeam, getActiveTeamCount, } from './strategy-t
 export { mergeStrategyBranch, } from './strategy-merge.js';
 export { handleTeamCompletion, advanceDeliveryStatuses, isStatusTerminal, isStatusAgentActionable, } from './strategy-completion.js';
 export type { TeamCompletionParams } from './strategy-completion.js';
+export { terminateTeam, waitForTeamExit, terminateAllTeams, detectDeactivatedStrategies, checkAndMergeCompletedDeliveries, } from './strategy-team-lifecycle.js';
+export type { CompletionEventContext } from './strategy-completion-event.js';
 /** Inject the resource governor for global concurrency limiting. */
 export declare function initGovernor(gov: ResourceGovernor): void;
 /**
@@ -47,46 +52,4 @@ export interface SpawnStrategyTeamParams {
  * and issues, builds a task DAG, and coordinates worker execution.
  */
 export declare function spawnStrategyTeam(params: SpawnStrategyTeamParams): Promise<void>;
-/**
- * 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 declare function terminateTeam(strategyId: string): boolean;
-/**
- * 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 declare function waitForTeamExit(strategyId: string, timeoutMs?: number): Promise<boolean>;
-/**
- * Terminate all active teams.
- */
-export declare function terminateAllTeams(): void;
-/**
- * Detect strategies that have been deactivated (agent role removed)
- * and shut down their active teams.
- */
-export declare function detectDeactivatedStrategies(config: DaemonConfig): Promise<void>;
-/**
- * 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 declare function checkAndMergeCompletedDeliveries(config: DaemonConfig): Promise<void>;
 //# sourceMappingURL=strategy-executor.d.ts.map

package/dist/strategy-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strategy-executor.d.ts","sourceRoot":"","sources":["../src/strategy-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EAET,cAAc,EACf,MAAM,YAAY,CAAC;AAUpB,OAAO,EAA0D,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAcpH,OAAO,yBAAyB,CAAC;AAKjC,OAAO,EACL,cAAc,EACd,aAAa,EACb,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAElC,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAkBrE,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAExD;AA8UD;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK5G;AA+BD,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAmZf;AAID;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CA2CzD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,SAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAsB7F;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAKxC;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,IAAI,CAAC,CA2Ff"}
+{"version":3,"file":"strategy-executor.d.ts","sourceRoot":"","sources":["../src/strategy-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EAET,cAAc,EACf,MAAM,YAAY,CAAC;AASpB,OAAO,EAAwC,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAUlG,OAAO,yBAAyB,CAAC;AAuBjC,OAAO,EACL,cAAc,EACd,aAAa,EACb,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,0BAA0B,CAAC;AAElC,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,2BAA2B,EAC3B,gCAAgC,GACjC,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAM7E,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAExD;AAwCD;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK5G;AA+BD,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAmZf"}

package/dist/strategy-executor.js

@@ -13,104 +13,48 @@
  * 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
+ * - strategy-team-state.ts          -- active teams map, config derivation
+ * - strategy-merge.ts               -- branch merge logic
+ * - strategy-completion.ts          -- post-execution completion handling
+ * - strategy-spawn-helpers.ts       -- log streams, stream handlers, process close
+ * - strategy-team-lifecycle.ts      -- terminate, wait, detect deactivated, merge checks
+ * - strategy-completion-event.ts    -- completion event handler
  */
 import { spawn } from 'node:child_process';
-import { mkdirSync, existsSync, createWriteStream } from 'node:fs';
-import { join } from 'node:path';
-import { createSession, updateSession, getReadyStrategies, getActiveStrategies, } from './supabase.js';
+import { mkdirSync, existsSync } from 'node:fs';
+import { createSession, updateSession, getActiveStrategies, } from './supabase.js';
 import { createWorktree, runGitSync, repoHasCommits } 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 } from './strategy-prompt-builder.js';
+import { withRetry, sendMessage, productLabel } from '@telora/daemon-core';
+import { recordActivity } from './heartbeat.js';
+import { buildStrategyTeamPrompt } from './strategy-prompt-builder.js';
 import { buildRoleFrameworkPrompt } from './team-prompt-base.js';
-import { getStrategyDeliveries, getStrategyIssues, getProductContextForStrategy, getProductDeploymentProfileSnapshot, updateStrategyClaudeSessionId, fetchStrategyWorkflow } from './queries/strategies.js';
+import { getStrategyDeliveries, getStrategyIssues, getProductContextForStrategy, getProductDeploymentProfileSnapshot, fetchStrategyWorkflow } from './queries/strategies.js';
 import { buildSpawnEnvironment } from './spawn-environment.js';
 import { sanitizeGitSegment } from './git-utils.js';
 import { recordStrategyTeardown } from './spawn-cooldown.js';
 import { consumePendingSpawnDirective, assembleDirectiveContent } from './directive-executor.js';
-import { OPEN_ISSUE_STATUSES } from './constants.js';
 import { resolveAssemblyRecipe } from './assembly-engine.js';
 import './assembly-resolvers.js';
-import { configForProduct, findProduct } from './config.js';
-// ── Re-exports from extracted modules (backward compatibility) ───────
+import { isStatusAgentActionable, isStatusBlocking } from './stage-classifier.js';
+// ── Imports from extracted modules ──────────────────────────────────────
+import { getActiveTeams, deriveExecutionConfig, } from './strategy-team-state.js';
+import { setupTeamLogStreams, attachStreamHandlers, handleTeamProcessClose, } from './strategy-spawn-helpers.js';
+import { terminateTeam, } from './strategy-team-lifecycle.js';
+import { handleCompletionEvent, } from './strategy-completion-event.js';
+// ── Re-exports for backward compatibility ───────────────────────────────
 export { getActiveTeams, hasActiveTeam, getActiveTeamCount, } from './strategy-team-state.js';
 export { mergeStrategyBranch, } from './strategy-merge.js';
 export { handleTeamCompletion, advanceDeliveryStatuses, isStatusTerminal, isStatusAgentActionable, } 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, } from './strategy-completion.js';
-import { isStatusTerminal, isStatusAgentActionable, isStatusBlocking } from './stage-classifier.js';
+export { terminateTeam, waitForTeamExit, terminateAllTeams, detectDeactivatedStrategies, checkAndMergeCompletedDeliveries, } from './strategy-team-lifecycle.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.
-    const allTerminal = currentDeliveries.every(d => isStatusTerminal(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.
-    const actionableDeliveryIds = new Set(currentDeliveries
-        .filter(d => isStatusAgentActionable(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;
-    }
-    // Check for open issues across actionable deliveries.
-    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);
-}
-// ── Private helpers for spawnStrategyTeam ─────────────────────────────
+// ── Private helpers ─────────────────────────────────────────────────────
 /**
  * Pre-spawn guard: enforce rank-ordered execution.
  *
@@ -140,148 +84,6 @@ function findActionableDeliveries(deliveries, strategyName) {
     }
     return deliveries.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
 }
-/**
- * Create log file paths and writable streams for a team's output.
- */
-function setupTeamLogStreams(logDir, branchName, strategyName) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const logPrefix = `strategy-${branchName.replace(/\//g, '-')}-${timestamp}`;
-    const stdoutPath = join(logDir, `${logPrefix}.stdout.log`);
-    const stderrPath = join(logDir, `${logPrefix}.stderr.log`);
-    const jsonlPath = join(logDir, `${logPrefix}.stream.jsonl`);
-    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}`);
-    });
-    return { stdoutPath, stderrPath, jsonlPath, stdoutLogStream, stderrStream, jsonlStream };
-}
-/**
- * Attach stream parser, completion detector, activity tracker, and event
- * handlers to the spawned team lead process.
- */
-function attachStreamHandlers(params) {
-    const { proc, teamState, strategyId, strategyName, sessionId, logs } = params;
-    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(sessionId);
-    activityTracker.onNarration((text) => setNarration(strategyId, text));
-    activityTracker.attach(streamParser);
-    // Write raw NDJSON lines to jsonl log file
-    streamParser.on('event', (event) => {
-        logs.jsonlStream.write(JSON.stringify(event) + '\n');
-    });
-    // Write human-readable lines to stdout log
-    streamParser.on('event', (event) => {
-        const line = formatEventForLog(event);
-        if (line) {
-            logs.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(logs.stderrStream);
-    return { completionDetector, activityTracker };
-}
-/**
- * Handle the team lead process 'close' event.
- *
- * Detects --resume failures and retries without resume, otherwise
- * runs normal cleanup (governor release, stream close, completion handling).
- */
-async function handleTeamProcessClose(ctx) {
-    const { code, signal, strategyName, strategyId, resumeId, spawnedAt, teamState, sessionId, config: cfg, completionDetector, activityTracker, logs, params: spawnParams, } = ctx;
-    const activeTeams = getActiveTeams();
-    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.
-    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();
-        logs.stdoutLogStream.end();
-        logs.stderrStream.end();
-        logs.jsonlStream.end();
-        // Clean up session and team state
-        try {
-            await updateSession(sessionId, {
-                status: 'failed',
-                exit_reason: `Resume failed (code ${code}), retrying without resume`,
-                exit_category: 'internal',
-                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({ ...spawnParams, 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();
-    logs.stdoutLogStream.end();
-    logs.stderrStream.end();
-    logs.jsonlStream.end();
-    recordActivity();
-    await handleTeamCompletion({
-        config: cfg,
-        teamState,
-        sessionId,
-        code,
-        signal,
-    });
-}
 // ── Team spawning ────────────────────────────────────────────────────
 /**
  * Generate branch name for strategy-level work.
@@ -653,7 +455,7 @@ export async function spawnStrategyTeam(params) {
         handleTeamProcessClose({
             code, signal, strategyName, strategyId, resumeId, spawnedAt,
             teamState, sessionId: session.id, config, completionDetector,
-            activityTracker, logs, params,
+            activityTracker, logs, params, governor, spawnStrategyTeam,
         }).catch(err => {
             console.error(`[strategy-executor] handleTeamProcessClose failed for "${strategyName}":`, err.message);
         });
@@ -682,207 +484,4 @@ export async function spawnStrategyTeam(params) {
         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 => !isStatusAgentActionable(d.executionStatus ?? '') && !isStatusBlocking(d.executionStatus ?? '')
-                && !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.
-            // Otherwise the team is idle, waiting for the daemon to push new work.
-            const teamWork = deliveries.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
-            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