@telora/factory 0.4.5

package/dist/instance-phase-dispatch.js

@@ -0,0 +1,674 @@
+/**
+ * Factory instance phase dispatch -- orchestrates designing, planning,
+ * building, and review phases.
+ *
+ * Contains the phase handler functions that drive instances through
+ * their lifecycle stages. Imports from instance-state-machine (leaf)
+ * and instance-completion, but NOT from instance-poll-loop.
+ */
+import { updateInstanceStatus } from './queries/instances.js';
+import { getInstanceWorkUnits, updateWorkUnitStatus, createWorkUnits } from './queries/work-units.js';
+import { deleteExecutionUnitsByInstance } from './queries/execution-units.js';
+import { createCycleEvaluation } from './queries/cycle-evaluations.js';
+import { createFactoryEscalation } from './queries/escalations.js';
+import { updateStrategyExecutionStatus } from './queries/strategies.js';
+import { createFactorySession, updateFactorySession } from './queries/sessions.js';
+import { runPlanningPhase, generateBranchName } from './planning.js';
+import { runStrategyDesignPhase } from './strategy-design.js';
+import { createFactoryWorktree } from './git-factory.js';
+import { configForFactoryProduct, findFactoryProduct } from './product-config.js';
+import { runSchedulerCycle, createSchedulerDeps } from './scheduler.js';
+import { spawnUnitSession, terminateAllUnits, terminateUnitSession } from './unit-session.js';
+import { checkResourceLimits } from './resource-limits.js';
+import { checkAndEscalateIfStuck, escalateInstanceState, } from './escalation.js';
+import { runCompletionGate } from './completion-gate.js';
+import { advancePipeline, getNodeLabel } from './pipeline-traversal.js';
+import { collectMetrics } from './pipeline-metrics.js';
+import { randomUUID } from 'node:crypto';
+import { transitionInstanceStatus, handleInstanceFailure, } from './instance-state-machine.js';
+import { runCompletionSequence, detectStrategyCompletion, checkInstanceCompletion, } from './instance-completion.js';
+// ============================================================================
+// Module-level config reference
+// ============================================================================
+/** Module-level config, set by setPhaseDispatchConfig. */
+let config = null;
+/** Optional resource governor for global concurrency control across engines. */
+let governor = null;
+/**
+ * Set the module-level config for phase dispatch functions.
+ * Called by the poll loop when starting.
+ */
+export function setPhaseDispatchConfig(factoryConfig) {
+    config = factoryConfig;
+}
+/**
+ * Set the module-level governor for phase dispatch functions.
+ * Called by the poll loop when the governor is set.
+ */
+export function setPhaseDispatchGovernor(gov) {
+    governor = gov;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+export function getCurrentNodeTemplateType(state) {
+    if (!state.pipelineGraph || !state.currentPipelineNodeId)
+        return null;
+    const node = state.pipelineGraph.nodes.find((n) => n.id === state.currentPipelineNodeId);
+    return node?.templateType ?? null;
+}
+// ============================================================================
+// Phase handlers
+// ============================================================================
+/**
+ * Run the designing phase for an instance.
+ *
+ * Creates a git worktree, spawns Claude Code to decompose the specification
+ * into bounded strategies, validates and persists them, then transitions
+ * to "planning".
+ */
+export async function runDesigning(state) {
+    if (!config) {
+        handleInstanceFailure(state, 'Config not initialized -- cannot run designing');
+        return;
+    }
+    // Review nodes skip design/planning -- they run the completion gate directly
+    // and use gap results to drive the pipeline advance decision.
+    // Terminal nodes mean the pipeline is done -- complete the instance directly.
+    const nodeTemplateType = getCurrentNodeTemplateType(state);
+    if (nodeTemplateType === 'review') {
+        await runReviewGateAndAdvance(state);
+        return;
+    }
+    if (nodeTemplateType === 'terminal') {
+        await runCompletionSequence(state, config, governor);
+        return;
+    }
+    console.log(`[factory] Designing phase started for instance ${state.instanceId}`);
+    // Step 1: Create git worktree (shared with subsequent planning phase)
+    // Use product-scoped config so worktrees land in the correct product repo
+    if (!state.worktreePath) {
+        const productEntry = findFactoryProduct(config, state.productId);
+        const productConfig = productEntry ? configForFactoryProduct(config, productEntry) : config;
+        const branchName = generateBranchName(state.blueprint.name, state.instanceId);
+        try {
+            const worktreePath = createFactoryWorktree(productConfig.repoPath, productConfig.factoryWorktreeDir, branchName);
+            console.log(`[factory] Worktree created for designing: ${worktreePath} (branch: ${branchName})`);
+            await updateInstanceStatus(state.instanceId, 'designing', {
+                branchName,
+                worktreePath,
+            });
+            state.branchName = branchName;
+            state.worktreePath = worktreePath;
+        }
+        catch (err) {
+            await handleInstanceFailure(state, `Failed to create worktree: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+    }
+    // Step 2: Run strategy design phase (audit -> prompt -> generate -> validate -> persist)
+    // Track the designing phase as a planner session for telemetry
+    const designSession = await createFactorySession({
+        instanceId: state.instanceId,
+        sessionType: 'planner',
+    });
+    await updateFactorySession(designSession.id, {
+        status: 'running',
+        startedAt: new Date().toISOString(),
+    });
+    const result = await runStrategyDesignPhase(state, config, governor);
+    // Build session update fields including token/cost data (TEL-6)
+    const designSessionFields = {
+        status: result.success ? 'completed' : 'failed',
+        endedAt: new Date().toISOString(),
+    };
+    if (result.tokenUsage) {
+        const sessionTokens = result.tokenUsage.inputTokens + result.tokenUsage.outputTokens;
+        designSessionFields.tokenCount = sessionTokens;
+        if (result.tokenUsage.totalCostUsd !== null) {
+            designSessionFields.costEstimate = result.tokenUsage.totalCostUsd;
+        }
+        // Aggregate into instance-level token counter
+        state.tokensUsed += sessionTokens;
+        await updateInstanceStatus(state.instanceId, state.status, {
+            tokensUsed: state.tokensUsed,
+        });
+    }
+    await updateFactorySession(designSession.id, designSessionFields);
+    if (!result.success) {
+        await transitionInstanceStatus(state, 'failed', `Designing failed: ${result.error ?? 'unknown'}`);
+        return;
+    }
+    // Step 3: Transition to planning
+    await transitionInstanceStatus(state, 'planning');
+    // Clear review gap context after it has been injected into the design prompt
+    state.reviewGaps = undefined;
+    // Kick off planning immediately
+    runPlanning(state).catch((error) => {
+        console.error(`[factory] Planning failed for instance ${state.instanceId}:`, error.message);
+        handleInstanceFailure(state, `Planning failed: ${error.message}`);
+    });
+}
+/**
+ * Execute the Review pipeline node.
+ *
+ * Review nodes skip the full design/plan/build cycle. Instead they:
+ * 1. Run the completion gate against all work produced so far
+ * 2. Use gap counts to populate pipeline edge metrics
+ * 3. Advance the pipeline (back to Engineering if gaps, to Done if clean)
+ * 4. Store gap details in state.reviewGaps so the next Engineering cycle
+ *    can constrain its scope to closing those gaps only
+ */
+export async function runReviewGateAndAdvance(state) {
+    if (!config) {
+        handleInstanceFailure(state, 'Config not initialized -- cannot run review gate');
+        return;
+    }
+    // Run the completion gate to get actual gap metrics (only when enabled)
+    let gateResult = null;
+    if (state.blueprint.completionGateEnabled) {
+        console.log(`[factory] Review node: running completion gate for instance ${state.instanceId}`);
+        try {
+            const workUnits = await getInstanceWorkUnits(state.instanceId);
+            gateResult = await runCompletionGate(state, config, workUnits, governor);
+            if (gateResult) {
+                console.log(`[factory] Review gate: ${gateResult.passed ? 'passed' : 'failed'}, ` +
+                    `${gateResult.gaps.length} gap(s) found (confidence: ${gateResult.confidence})`);
+            }
+        }
+        catch (err) {
+            console.warn(`[factory] Review gate error (non-fatal, proceeding with gap_count=0): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Persist the gate evaluation
+        if (gateResult) {
+            try {
+                state.completionGateIterations++;
+                await createCycleEvaluation(state.instanceId, state.completionGateIterations, gateResult);
+            }
+            catch (persistErr) {
+                console.warn(`[factory] Failed to persist review cycle evaluation (non-fatal): ` +
+                    `${persistErr instanceof Error ? persistErr.message : String(persistErr)}`);
+            }
+        }
+    }
+    else {
+        console.log(`[factory] Review node: completion gate disabled on blueprint -- skipping AI review for instance ${state.instanceId}`);
+    }
+    // Compute gap_count (critical gaps only) for pipeline edge evaluation
+    const criticalGaps = gateResult ? gateResult.gaps.filter((g) => g.severity === 'critical') : [];
+    const gapCount = criticalGaps.length;
+    // Assemble pipeline advance metrics
+    const workUnitsForMetrics = await getInstanceWorkUnits(state.instanceId).catch(() => []);
+    const completedUnits = workUnitsForMetrics.filter((u) => u.status === 'completed');
+    const wallClockMs = state.startedAt ? Date.now() - state.startedAt.getTime() : 0;
+    const metrics = collectMetrics({
+        cycleCount: state.completionGateIterations,
+        deliveryCompletionPct: workUnitsForMetrics.length > 0
+            ? (completedUnits.length / workUnitsForMetrics.length) * 100
+            : 0,
+        wallClockMinutes: wallClockMs / 60_000,
+        gapCount,
+        gapSeverity: criticalGaps.length > 0 ? 'critical' : gateResult?.gaps.length ? 'important' : 'low',
+    });
+    const advanceResult = advancePipeline(state, metrics);
+    switch (advanceResult.outcome) {
+        case 'advanced': {
+            const nextNodeId = advanceResult.nextNodeId;
+            const nextNodeTemplateType = state.pipelineGraph.nodes.find((n) => n.id === nextNodeId)?.templateType;
+            // If the next node is terminal, treat it as completion rather than
+            // starting a new design/build cycle.
+            if (nextNodeTemplateType === 'terminal') {
+                const nodeLabel = getNodeLabel(state.pipelineGraph, nextNodeId);
+                console.log(`[factory] Review: pipeline advanced to terminal node "${nodeLabel}" -- ` +
+                    `completing instance ${state.instanceId}`);
+                await runCompletionSequence(state, config, governor);
+                break;
+            }
+            // Store gap context so the next Engineering designing phase can constrain scope
+            if (gateResult && gateResult.gaps.length > 0) {
+                state.reviewGaps = gateResult.gaps.map((g) => ({
+                    area: g.area,
+                    description: g.description,
+                    severity: g.severity,
+                    suggestedFix: g.suggestedFix,
+                }));
+                console.log(`[factory] Review found ${gateResult.gaps.length} gap(s) -- ` +
+                    `advancing to Engineering with gap constraints`);
+            }
+            // Advance to next pipeline node (typically Engineering)
+            terminateAllUnits(state);
+            await deleteExecutionUnitsByInstance(state.instanceId);
+            state.currentPipelineNodeId = nextNodeId;
+            state.executionUnits.clear();
+            state.completionGateIterations = 0;
+            const nodeLabel = getNodeLabel(state.pipelineGraph, nextNodeId);
+            // Engineering nodes skip strategy redesign -- go directly to planning
+            if (nextNodeTemplateType === 'engineering') {
+                state.status = 'planning';
+                await updateInstanceStatus(state.instanceId, 'planning', {
+                    currentPipelineNodeId: nextNodeId,
+                });
+                console.log(`[factory] Review: pipeline advanced to engineering node "${nodeLabel}" ` +
+                    `(${nextNodeId}) -- skipping design, starting planning for instance ${state.instanceId}`);
+                runPlanning(state).catch((error) => {
+                    console.error(`[factory] Planning failed after review advance for instance ${state.instanceId}:`, error.message);
+                    handleInstanceFailure(state, `Planning failed after review: ${error.message}`);
+                });
+            }
+            else {
+                state.status = 'designing';
+                await updateInstanceStatus(state.instanceId, 'designing', {
+                    currentPipelineNodeId: nextNodeId,
+                });
+                console.log(`[factory] Review: pipeline advanced to node "${nodeLabel}" ` +
+                    `(${nextNodeId}) for instance ${state.instanceId}`);
+                runDesigning(state).catch((error) => {
+                    console.error(`[factory] Designing failed after review advance for instance ${state.instanceId}:`, error.message);
+                    handleInstanceFailure(state, `Designing failed after review: ${error.message}`);
+                });
+            }
+            break;
+        }
+        case 'completed': {
+            // Pipeline reached terminal node -- finalize instance
+            console.log(`[factory] Review: pipeline complete at terminal node for instance ${state.instanceId}`);
+            state.status = 'completed';
+            await runCompletionSequence(state, config, governor);
+            break;
+        }
+        case 'no_match': {
+            // No edge conditions matched -- escalate
+            terminateAllUnits(state);
+            const nodeLabel = getNodeLabel(state.pipelineGraph, state.currentPipelineNodeId);
+            console.warn(`[factory] Review: pipeline stuck at "${nodeLabel}" for instance ${state.instanceId}. Escalating.`);
+            await createFactoryEscalation(state.instanceId, `Pipeline stuck at Review node "${nodeLabel}": no outgoing edge conditions matched`, `Review pipeline edge conditions for node "${nodeLabel}" and either add a fallback edge or manually advance the instance.`);
+            state.status = 'paused';
+            await updateInstanceStatus(state.instanceId, 'paused');
+            break;
+        }
+        default:
+            break;
+    }
+}
+/**
+ * Run the planning phase for an instance.
+ *
+ * Creates a git worktree, spawns Claude Code to generate a work plan,
+ * validates and persists work units, then transitions to "building".
+ */
+export async function runPlanning(state) {
+    if (!config) {
+        handleInstanceFailure(state, 'Config not initialized -- cannot run planning');
+        return;
+    }
+    console.log(`[factory] Planning phase started for instance ${state.instanceId}`);
+    // Track the planning phase as a planner session for telemetry
+    const planSession = await createFactorySession({
+        instanceId: state.instanceId,
+        sessionType: 'planner',
+    });
+    await updateFactorySession(planSession.id, {
+        status: 'running',
+        startedAt: new Date().toISOString(),
+    });
+    const result = await runPlanningPhase(state, config, governor);
+    // Build session update fields including token/cost data (TEL-6)
+    const planSessionFields = {
+        status: result.success ? 'completed' : 'failed',
+        endedAt: new Date().toISOString(),
+    };
+    if (result.tokenUsage) {
+        const sessionTokens = result.tokenUsage.inputTokens + result.tokenUsage.outputTokens;
+        planSessionFields.tokenCount = sessionTokens;
+        if (result.tokenUsage.totalCostUsd !== null) {
+            planSessionFields.costEstimate = result.tokenUsage.totalCostUsd;
+        }
+        // Aggregate into instance-level token counter
+        state.tokensUsed += sessionTokens;
+        await updateInstanceStatus(state.instanceId, state.status, {
+            tokensUsed: state.tokensUsed,
+        });
+    }
+    await updateFactorySession(planSession.id, planSessionFields);
+    if (!result.success) {
+        await transitionInstanceStatus(state, 'failed', `Planning failed: ${result.error ?? 'unknown'}`);
+    }
+}
+// ============================================================================
+// Building phase monitoring
+// ============================================================================
+/**
+ * Detect in_progress or gate_fix_pending strategies that have no execution
+ * unit assigned (orphaned after a session crash). Reset them to pending
+ * and their in_progress work units to ready so the scheduler re-assigns them.
+ */
+async function resetOrphanedStrategies(state) {
+    let strategies;
+    try {
+        const { getStrategiesByFactoryInstance } = await import('./strategy-design.js');
+        strategies = await getStrategiesByFactoryInstance(state.instanceId);
+    }
+    catch {
+        return;
+    }
+    // Build set of strategy IDs that have a live execution unit
+    const activeStrategyIds = new Set();
+    for (const unit of state.executionUnits.values()) {
+        if (unit.assignedStrategyId && (unit.status === 'assigned' || unit.status === 'running')) {
+            activeStrategyIds.add(unit.assignedStrategyId);
+        }
+    }
+    const orphanStatuses = new Set(['in_progress', 'gate_fix_pending']);
+    for (const strategy of strategies) {
+        if (!strategy.executionStatus || !orphanStatuses.has(strategy.executionStatus))
+            continue;
+        if (activeStrategyIds.has(strategy.id))
+            continue;
+        // Orphaned: strategy is in_progress/gate_fix_pending but no unit is working on it
+        console.warn(`[factory] Orphaned strategy "${strategy.name}" (${strategy.id.slice(0, 8)}) ` +
+            `is ${strategy.executionStatus} with no live session -- resetting to pending`);
+        await updateStrategyExecutionStatus(strategy.id, 'pending', { gateFixStartedAt: null });
+        // Reset in_progress work units to ready so the new session gets them dispatched
+        const workUnits = await getInstanceWorkUnits(state.instanceId);
+        const orphanedUnits = workUnits.filter((wu) => wu.strategyId === strategy.id &&
+            wu.status === 'in_progress' &&
+            !wu.infrastructureOwned);
+        for (const wu of orphanedUnits) {
+            await updateWorkUnitStatus(wu.id, 'ready');
+        }
+        if (orphanedUnits.length > 0) {
+            console.log(`[factory] Reset ${orphanedUnits.length} in_progress work unit(s) to ready ` +
+                `for strategy "${strategy.name}"`);
+        }
+    }
+}
+/**
+ * Spawn unit sessions for a list of scheduler assignments.
+ *
+ * Extracted to avoid duplication between the regular scheduler cycle and
+ * the post-gate follow-up cycle in checkBuilding.
+ */
+async function spawnAssignedSessions(assignments, state) {
+    if (!config)
+        return;
+    const { getStrategiesByFactoryInstance } = await import('./strategy-design.js');
+    const strategies = await getStrategiesByFactoryInstance(state.instanceId);
+    const strategiesById = new Map(strategies.map((s) => [s.id, s]));
+    for (const assignment of assignments) {
+        const unitState = state.executionUnits.get(assignment.unitId);
+        if (!unitState) {
+            console.warn(`[factory] Assigned unit ${assignment.unitId} not found in state -- skipping spawn`);
+            continue;
+        }
+        const dbStrategy = strategiesById.get(assignment.strategyId);
+        if (!dbStrategy) {
+            console.warn(`[factory] Assigned strategy ${assignment.strategyId} not found -- skipping spawn`);
+            continue;
+        }
+        // Update in-memory unit state to reflect the assignment
+        unitState.assignedStrategyId = assignment.strategyId;
+        unitState.assignedAt = new Date();
+        unitState.status = 'assigned';
+        const strategyCtx = {
+            strategyId: dbStrategy.id,
+            strategyName: dbStrategy.name,
+            dependsOn: dbStrategy.dependsOn,
+        };
+        try {
+            const adapter = await spawnUnitSession(unitState, strategyCtx, state, config, governor);
+            // Seed an infrastructure-owned gate verification work unit for this strategy
+            // before dispatching agent work. This unit is resolved by the engine after gates run.
+            await seedGateWorkUnit(state.instanceId, assignment.strategyId);
+            // Dispatch strategy work units to the session
+            const workUnits = await getInstanceWorkUnits(state.instanceId);
+            const strategyWorkUnits = workUnits.filter((wu) => wu.strategyId === assignment.strategyId &&
+                (wu.status === 'ready' || wu.status === 'pending') &&
+                !wu.infrastructureOwned);
+            if (strategyWorkUnits.length > 0) {
+                adapter.dispatchWork(strategyWorkUnits, state);
+                // Track dispatch time and dispatched unit IDs for timeout watchdog
+                unitState.dispatchedAt = new Date();
+                unitState.dispatchedWorkUnitIds = new Set(strategyWorkUnits.map((wu) => wu.id));
+                // Mark work units as in_progress
+                for (const wu of strategyWorkUnits) {
+                    updateWorkUnitStatus(wu.id, 'in_progress').catch((err) => {
+                        console.error(`[factory] Failed to mark work unit ${wu.id} as in_progress:`, err.message);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[factory] Failed to spawn session for unit ${unitState.slotIndex} ` +
+                `(strategy "${dbStrategy.name}"): ${err.message}`);
+            // Reset unit back to idle so the scheduler can retry
+            unitState.status = 'idle';
+            unitState.assignedStrategyId = null;
+            unitState.assignedAt = null;
+        }
+    }
+}
+/**
+ * Check on an instance in the building phase.
+ *
+ * Runs resource limit checks, the DAG-aware scheduler to assign strategies
+ * to execution units, spawns sessions for newly assigned units, monitors
+ * running unit health, evaluates strategy-level gates, and checks for
+ * instance completion.
+ */
+export async function checkBuilding(state) {
+    if (!config)
+        return;
+    // Update wall_clock_elapsed_seconds on every poll cycle (TEL-6).
+    const elapsedSeconds = Math.floor((Date.now() - state.startedAt.getTime()) / 1000);
+    await updateInstanceStatus(state.instanceId, 'building', {
+        wallClockElapsedSeconds: elapsedSeconds,
+    });
+    // Check resource limits first -- always pause (never fail directly)
+    const limitResult = await checkResourceLimits(state);
+    if (limitResult.exceeded) {
+        terminateAllUnits(state);
+        await escalateInstanceState(state, 'resource_limit_exceeded', limitResult.reason);
+        return;
+    }
+    // Check for stuck work units -- escalate or fail based on blueprint triggers
+    const wasEscalated = await checkAndEscalateIfStuck(state, () => transitionInstanceStatus(state, 'failed', 'Builder stuck: repeated gate failures with same error pattern'));
+    if (wasEscalated)
+        return;
+    // --- Orphan detection: reset in_progress strategies with no live session ---
+    // When a session dies mid-work the strategy stays in_progress but the unit
+    // is released to idle. Reset the strategy to pending (and its work units to
+    // ready) so the scheduler can re-assign it.
+    await resetOrphanedStrategies(state);
+    // --- Scheduler: assign ready strategies to idle execution units ---
+    const deps = createSchedulerDeps();
+    const cycleResult = await runSchedulerCycle(state.instanceId, deps);
+    if (cycleResult.assignments.length > 0) {
+        await spawnAssignedSessions(cycleResult.assignments, state);
+    }
+    // --- Health monitoring: detect orphaned running units ---
+    for (const unit of state.executionUnits.values()) {
+        if (unit.status === 'running' && !unit.pid) {
+            // Unit is marked running but has no process handle (orphaned state)
+            console.warn(`[factory] Unit ${unit.slotIndex} is running with no pid -- resetting to idle`);
+            unit.status = 'idle';
+            unit.assignedStrategyId = null;
+            unit.assignedAt = null;
+            unit.stdin = null;
+        }
+    }
+    // --- Operational watchdogs: assignment, dispatch, and signal silence ---
+    try {
+        const { runWatchdogs } = await import('./watchdogs.js');
+        await runWatchdogs(state);
+    }
+    catch (err) {
+        console.warn(`[factory] Watchdog check error (non-fatal): ${err.message}`);
+    }
+    // --- Gate fix timeout enforcement ---
+    await checkGateFixTimeouts(state);
+    // --- Per-strategy completion detection ---
+    // Check if all work units for any in_progress strategy are terminal
+    await detectStrategyCompletion(state);
+    // --- Strategy-level gate evaluation ---
+    let gatesPassedThisCycle = false;
+    try {
+        const { evaluateStrategyGates } = await import('./strategy-gating.js');
+        gatesPassedThisCycle = await evaluateStrategyGates(state, config, governor);
+    }
+    catch (err) {
+        console.warn(`[factory] Strategy gate evaluation error (non-fatal): ${err.message}`);
+    }
+    // If a strategy just passed gates, it eagerly released its unit back to idle.
+    // Run a second scheduler cycle immediately to assign any newly eligible
+    // downstream strategies without waiting for the next 30s poll.
+    if (gatesPassedThisCycle) {
+        const followUpDeps = createSchedulerDeps();
+        const followUpResult = await runSchedulerCycle(state.instanceId, followUpDeps);
+        if (followUpResult.assignments.length > 0) {
+            console.log(`[factory] Post-gate scheduler: assigning ${followUpResult.assignments.length} ` +
+                `downstream strategy/ies immediately`);
+            await spawnAssignedSessions(followUpResult.assignments, state);
+        }
+    }
+    // --- Cycle summary ---
+    logCycleSummary(state);
+    // --- Instance completion check ---
+    await checkInstanceCompletion(state, config, runDesigning, runPlanning);
+}
+/**
+ * Log a compact cycle summary showing execution unit and strategy states.
+ */
+export function logCycleSummary(state) {
+    const units = [...state.executionUnits.values()];
+    const idle = units.filter((u) => u.status === 'idle').length;
+    const assigned = units.filter((u) => u.status === 'assigned').length;
+    const running = units.filter((u) => u.status === 'running').length;
+    const terminated = units.filter((u) => u.status === 'terminated').length;
+    const assignments = units
+        .filter((u) => u.assignedStrategyId)
+        .map((u) => `slot${u.slotIndex}=${u.assignedStrategyId.slice(0, 8)}`)
+        .join(', ');
+    console.log(`[factory] Cycle: units=${idle}i/${assigned}a/${running}r/${terminated}t` +
+        (assignments ? ` | ${assignments}` : '') +
+        ` | tokens=${state.tokensUsed}`);
+}
+// ============================================================================
+// Infrastructure-owned gate work unit seeding
+// ============================================================================
+/**
+ * Seed an infrastructure-owned "Gate verification" work unit for a strategy.
+ *
+ * Called before the first agent prompt is dispatched for a strategy. The unit
+ * is created with `infrastructureOwned: true` so agents cannot claim it.
+ * It will be resolved to completed or failed by the engine after gate
+ * evaluation runs (see resolveGateWorkUnit).
+ *
+ * The cycle number is determined by looking at existing work units for the
+ * strategy and using the max cycle number found (or 1 if none exist).
+ */
+async function seedGateWorkUnit(instanceId, strategyId) {
+    try {
+        // Determine cycle number from existing work units for this strategy
+        const existingUnits = await getInstanceWorkUnits(instanceId);
+        const strategyUnits = existingUnits.filter((u) => u.strategyId === strategyId);
+        const cycleNumber = strategyUnits.length > 0
+            ? Math.max(...strategyUnits.map((u) => u.cycleNumber))
+            : 1;
+        // Check if a gate verification unit already exists for this strategy and cycle
+        const existing = strategyUnits.find((u) => u.infrastructureOwned && u.cycleNumber === cycleNumber);
+        if (existing) {
+            console.log(`[factory] Gate verification unit already exists for strategy ${strategyId.slice(0, 8)} ` +
+                `cycle ${cycleNumber} -- skipping seed`);
+            return;
+        }
+        await createWorkUnits(instanceId, [{
+                id: randomUUID(),
+                title: 'Gate verification',
+                description: 'Infrastructure-managed gate verification. This work unit is automatically ' +
+                    'created and resolved by the factory engine. Do not modify.',
+                sortOrder: 9999,
+                blockedBy: [],
+                cycleNumber,
+                strategyId,
+                infrastructureOwned: true,
+            }]);
+        console.log(`[factory] Seeded gate verification unit for strategy ${strategyId.slice(0, 8)} ` +
+            `(cycle ${cycleNumber})`);
+    }
+    catch (err) {
+        // Non-fatal -- gate seeding failure should not block agent execution
+        console.warn(`[factory] Failed to seed gate verification unit for strategy ${strategyId.slice(0, 8)}: ` +
+            `${err.message}`);
+    }
+}
+// ============================================================================
+// Gate fix timeout enforcement
+// ============================================================================
+/**
+ * Check for strategies stuck in gate_fix_pending past their timeout.
+ *
+ * For each gate_fix_pending strategy with a configured gate_fix_timeout_ms,
+ * checks whether gate_fix_started_at + timeout has elapsed. On timeout,
+ * transitions the strategy to failed, creates an escalation, and terminates
+ * the unit session.
+ *
+ * Also warns about orphaned gate_fix_pending strategies that have no live
+ * unit session (the scheduler may reassign, so we don't auto-fail).
+ */
+/** @internal Exported for testing. */
+export async function checkGateFixTimeouts(state) {
+    const timeoutMs = state.blueprint.gateFixTimeoutMs;
+    let strategies;
+    try {
+        const { getStrategiesByFactoryInstance } = await import('./strategy-design.js');
+        strategies = await getStrategiesByFactoryInstance(state.instanceId);
+    }
+    catch {
+        return;
+    }
+    const gateFixStrategies = strategies.filter((s) => s.executionStatus === 'gate_fix_pending');
+    if (gateFixStrategies.length === 0)
+        return;
+    const now = Date.now();
+    for (const strategy of gateFixStrategies) {
+        // Detect orphaned gate_fix_pending (no live unit session)
+        const hasLiveUnit = [...state.executionUnits.values()].some((u) => u.assignedStrategyId === strategy.id && u.status === 'running');
+        if (!hasLiveUnit) {
+            console.warn(`[factory] Strategy "${strategy.name}" is gate_fix_pending but has no live unit session ` +
+                `-- scheduler may reassign`);
+        }
+        // Timeout enforcement (only if blueprint configures it)
+        if (timeoutMs && strategy.gateFixStartedAt) {
+            const startedAt = new Date(strategy.gateFixStartedAt).getTime();
+            const elapsed = now - startedAt;
+            if (elapsed >= timeoutMs) {
+                console.log(`[factory] Strategy "${strategy.name}" failed: gate fix timeout ` +
+                    `(${timeoutMs}ms) exceeded (elapsed: ${elapsed}ms)`);
+                try {
+                    await updateStrategyExecutionStatus(strategy.id, 'failed', { gateFixStartedAt: null });
+                    // Retrieve last gate feedback for context
+                    const lastFeedback = state.gateFailureFeedback.get(strategy.id) ?? 'no feedback available';
+                    const summary = `Strategy "${strategy.name}" exceeded gate fix timeout (${timeoutMs}ms, ` +
+                        `elapsed: ${elapsed}ms). Last gate feedback: ${lastFeedback.slice(0, 500)}`;
+                    await createFactoryEscalation(state.instanceId, 'gate_fix_timeout', summary);
+                }
+                catch (err) {
+                    console.error(`[factory] Failed to fail timed-out strategy ${strategy.id}:`, err.message);
+                }
+                // Terminate the unit session
+                for (const unit of state.executionUnits.values()) {
+                    if (unit.assignedStrategyId === strategy.id) {
+                        terminateUnitSession(unit);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+// ============================================================================
+// Resume recovery (re-export from state machine for poll loop use)
+// ============================================================================
+export { recoverResumedInstance } from './instance-state-machine.js';
+//# sourceMappingURL=instance-phase-dispatch.js.map