@coralai/sps-cli 0.48.1 → 0.49.1

package/dist/engines/ExecutionEngine.js

@@ -1,766 +0,0 @@
-import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { RuntimeStore } from '../core/runtimeStore.js';
-import { resolveGitlabProjectId, resolveWorkflowTransport } from '../core/config.js';
-import { resolveWorktreePath } from '../core/paths.js';
-import { readQueue } from '../core/queue.js';
-import { buildPhasePrompt, DEVELOPMENT_PROMPT_FILE, } from '../core/taskPrompts.js';
-import { Logger } from '../core/logger.js';
-const SKIP_LABELS = ['BLOCKED', 'NEEDS-FIX', 'CONFLICT', 'WAITING-CONFIRMATION', 'STALE-RUNTIME'];
-/** All labels that should be cleaned when a card re-enters the pipeline */
-const CLEANUP_LABELS = [...SKIP_LABELS, 'CLAIMED'];
-export class ExecutionEngine {
-    ctx;
-    taskBackend;
-    repoBackend;
-    workerManager;
-    pipelineAdapter;
-    notifier;
-    log;
-    runtimeStore;
-    constructor(ctx, taskBackend, repoBackend, workerManager, pipelineAdapter, notifier) {
-        this.ctx = ctx;
-        this.taskBackend = taskBackend;
-        this.repoBackend = repoBackend;
-        this.workerManager = workerManager;
-        this.pipelineAdapter = pipelineAdapter;
-        this.notifier = notifier;
-        this.log = new Logger('pipeline', ctx.projectName, ctx.paths.logsDir);
-        this.runtimeStore = new RuntimeStore(ctx);
-    }
-    async tick(opts = {}) {
-        const actions = [];
-        const result = {
-            project: this.ctx.projectName,
-            component: 'pipeline',
-            status: 'ok',
-            exitCode: 0,
-            actions,
-            recommendedActions: [],
-            details: {},
-        };
-        let actionsThisTick = 0;
-        const maxActions = this.ctx.config.MAX_ACTIONS_PER_TICK;
-        try {
-            actions.push(...await this.reconcilePmStatesWithRuntime());
-            // 1. Process Inprogress cards (detect completion → move to QA)
-            //    This runs first to free slots before launching new workers.
-            //    Completion detection does NOT consume action quota — it's a
-            //    prerequisite for freeing slots, not a new forward action.
-            const inprogressCards = await this.listRuntimeAwareInprogressCards();
-            for (const card of inprogressCards) {
-                if (this.shouldSkip(card))
-                    continue;
-                const checkResult = await this.checkInprogressCard(card, opts);
-                if (checkResult) {
-                    actions.push(checkResult);
-                    // NOTE: intentionally not incrementing actionsThisTick here.
-                    // Completion detection frees slots for new launches and should
-                    // never block subsequent prepare/launch steps in the same tick.
-                }
-            }
-            // 2. Process Backlog cards (prepare: branch + worktree + move to Todo)
-            //    Prepare does NOT consume launch quota — it only sets up the
-            //    environment. This allows prepare + launch to happen in a single tick.
-            //    However, we limit prepares to available capacity: only prepare as
-            //    many cards as there are idle slots + remaining launch quota. This
-            //    prevents cards piling up in Todo when workers can't launch.
-            const backlogCards = await this.taskBackend.listByState(this.pipelineAdapter.states.backlog);
-            const currentState = this.runtimeStore.readState();
-            const idleSlots = Object.values(currentState.workers).filter(w => w.status === 'idle').length;
-            const todoCards0 = await this.taskBackend.listByState(this.pipelineAdapter.states.ready);
-            const todoCount = todoCards0.filter(c => !this.shouldSkip(c)).length;
-            const prepareLimit = Math.max(0, idleSlots - todoCount);
-            let preparedThisTick = 0;
-            for (const card of backlogCards) {
-                if (preparedThisTick >= prepareLimit)
-                    break;
-                // Auto-clean auxiliary labels on Backlog cards — if a card was manually
-                // moved back to Planning/Backlog, stale labels should not block it.
-                await this.cleanAuxiliaryLabels(card);
-                if (this.shouldSkip(card)) {
-                    actions.push({ action: 'skip', entity: `seq:${card.seq}`, result: 'skip', message: 'Has auxiliary state label' });
-                    continue;
-                }
-                const prepareResult = await this.prepareCard(card, opts);
-                actions.push(prepareResult);
-                if (prepareResult.result === 'ok')
-                    preparedThisTick++;
-            }
-            // 3. Process Todo cards (launch: claim + context + worker + move to Inprogress)
-            //    This is the only step that consumes action quota — it starts
-            //    resource-intensive AI workers that need system capacity.
-            //    Sort by pipeline_order to respect card priority (#5 skip bug fix).
-            let todoCards = await this.taskBackend.listByState(this.pipelineAdapter.states.ready);
-            const pipelineOrder = readQueue(this.ctx.paths.pipelineOrderFile);
-            if (pipelineOrder.length > 0) {
-                todoCards = todoCards.sort((a, b) => {
-                    const aIdx = pipelineOrder.indexOf(parseInt(a.seq, 10));
-                    const bIdx = pipelineOrder.indexOf(parseInt(b.seq, 10));
-                    // Cards in pipeline_order come first, in order; others after
-                    if (aIdx >= 0 && bIdx >= 0)
-                        return aIdx - bIdx;
-                    if (aIdx >= 0)
-                        return -1;
-                    if (bIdx >= 0)
-                        return 1;
-                    return parseInt(a.seq, 10) - parseInt(b.seq, 10);
-                });
-            }
-            let launchedThisTick = 0;
-            const failedSlots = new Set(); // track slots that failed launch this tick
-            for (const card of todoCards) {
-                if (actionsThisTick >= maxActions)
-                    break;
-                if (this.shouldSkip(card)) {
-                    actions.push({ action: 'skip', entity: `seq:${card.seq}`, result: 'skip', message: 'Has auxiliary state label' });
-                    continue;
-                }
-                // Stagger is handled by ResourceLimiter.enforceStagger() inside launchCard
-                const launchResult = await this.launchCard(card, opts, failedSlots);
-                actions.push(launchResult);
-                if (launchResult.result === 'ok') {
-                    actionsThisTick++;
-                    launchedThisTick++;
-                }
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Pipeline tick failed: ${msg}`);
-            result.status = 'fail';
-            result.exitCode = 1;
-            result.details = { error: msg };
-        }
-        // Check for any failures
-        if (actions.some((a) => a.result === 'fail') && result.status === 'ok') {
-            result.status = 'fail';
-            result.exitCode = 1;
-        }
-        return result;
-    }
-    /**
-     * Launch a single card (for `sps worker launch <project> <seq>`).
-     * Assumes card is in Todo state with branch/worktree already prepared.
-     */
-    async launchSingle(seq, opts = {}) {
-        const result = {
-            project: this.ctx.projectName,
-            component: 'worker-launch',
-            status: 'ok',
-            exitCode: 0,
-            actions: [],
-            recommendedActions: [],
-            details: {},
-        };
-        const card = await this.taskBackend.getBySeq(seq);
-        if (!card) {
-            result.status = 'fail';
-            result.exitCode = 1;
-            result.details = { error: `Card seq:${seq} not found` };
-            return result;
-        }
-        // If card is in Backlog, do prepare first
-        if (card.state === this.pipelineAdapter.states.backlog) {
-            const prepareAction = await this.prepareCard(card, opts);
-            result.actions.push(prepareAction);
-            if (prepareAction.result === 'fail') {
-                result.status = 'fail';
-                result.exitCode = 1;
-                return result;
-            }
-            // Reload card after prepare
-            const updated = await this.taskBackend.getBySeq(seq);
-            if (!updated || updated.state !== this.pipelineAdapter.states.ready) {
-                result.status = 'fail';
-                result.exitCode = 1;
-                result.details = { error: `Card not in ${this.pipelineAdapter.states.ready} after prepare` };
-                return result;
-            }
-        }
-        if (card.state !== this.pipelineAdapter.states.ready && card.state !== this.pipelineAdapter.states.backlog) {
-            result.status = 'fail';
-            result.exitCode = 2;
-            result.details = { error: `Card seq:${seq} is in ${card.state}, expected ${this.pipelineAdapter.states.backlog} or ${this.pipelineAdapter.states.ready}` };
-            return result;
-        }
-        const launchAction = await this.launchCard(card, opts);
-        result.actions.push(launchAction);
-        if (launchAction.result === 'fail') {
-            result.status = 'fail';
-            result.exitCode = 1;
-        }
-        return result;
-    }
-    shouldSkip(card) {
-        return SKIP_LABELS.some((label) => card.labels.includes(label));
-    }
-    async listRuntimeAwareInprogressCards() {
-        const cards = await this.taskBackend.listByState(this.pipelineAdapter.states.active);
-        const bySeq = new Map(cards.map(card => [card.seq, card]));
-        const state = this.runtimeStore.readState();
-        for (const [seq, lease] of Object.entries(state.leases)) {
-            const slot = lease.slot ? state.workers[lease.slot] || null : null;
-            if (this.derivePmStateFromLease(lease, slot) !== this.pipelineAdapter.states.active || bySeq.has(seq))
-                continue;
-            const card = await this.taskBackend.getBySeq(seq);
-            if (card)
-                bySeq.set(seq, card);
-        }
-        return Array.from(bySeq.values()).sort((a, b) => parseInt(a.seq, 10) - parseInt(b.seq, 10));
-    }
-    async reconcilePmStatesWithRuntime() {
-        const state = this.runtimeStore.readState();
-        const actions = [];
-        for (const [seq, lease] of Object.entries(state.leases)) {
-            const slot = lease.slot ? state.workers[lease.slot] || null : null;
-            const targetState = this.derivePmStateFromLease(lease, slot);
-            if (!targetState)
-                continue;
-            const card = await this.taskBackend.getBySeq(seq);
-            if (!card || card.state === targetState)
-                continue;
-            try {
-                await this.taskBackend.move(seq, targetState);
-                this.log.info(`Reconciled seq ${seq} ${card.state} → ${targetState} to match runtime state`);
-                actions.push({
-                    action: 'pm-reconcile',
-                    entity: `seq:${seq}`,
-                    result: 'ok',
-                    message: `${card.state} → ${targetState}`,
-                });
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                this.log.warn(`Failed to reconcile PM state for seq ${seq}: ${msg}`);
-                actions.push({
-                    action: 'pm-reconcile',
-                    entity: `seq:${seq}`,
-                    result: 'skip',
-                    message: msg,
-                });
-            }
-        }
-        return actions;
-    }
-    derivePmStateFromLease(lease, slot) {
-        const s = this.pipelineAdapter.states;
-        if (lease.phase === 'queued' || lease.phase === 'preparing') {
-            return s.ready;
-        }
-        if (lease.phase === 'coding') {
-            return s.active;
-        }
-        if (lease.phase === 'waiting_confirmation'
-            && lease.pmStateObserved !== s.review
-            && slot?.status !== 'merging'
-            && slot?.status !== 'resolving') {
-            return s.active;
-        }
-        if (['merging', 'resolving_conflict', 'closing'].includes(lease.phase)) {
-            return s.review;
-        }
-        if (lease.phase === 'waiting_confirmation' && lease.pmStateObserved === s.review) {
-            return s.review;
-        }
-        return null;
-    }
-    isRuntimeOwnedSlot(slot) {
-        return !!slot && slot.status !== 'idle';
-    }
-    /**
-     * Remove auxiliary state labels (STALE-RUNTIME, NEEDS-FIX, etc.) from a card.
-     * Called when a card re-enters Backlog — indicates human intent to retry,
-     * so stale labels from previous runs should not block it.
-     */
-    async cleanAuxiliaryLabels(card) {
-        for (const label of CLEANUP_LABELS) {
-            if (card.labels.includes(label)) {
-                try {
-                    await this.taskBackend.removeLabel(card.seq, label);
-                    card.labels = card.labels.filter(l => l !== label);
-                    this.log.ok(`Removed stale label "${label}" from seq ${card.seq}`);
-                }
-                catch {
-                    this.log.warn(`Failed to remove label "${label}" from seq ${card.seq}`);
-                }
-            }
-        }
-    }
-    // ─── Inprogress Phase (detect completion → Done) ────────────────
-    /**
-     * Check an Inprogress card: verify worker is still running or handled by exit callback.
-     *
-     * The Supervisor exit callback triggers CompletionJudge → PostActions automatically,
-     * so this method only needs to:
-     * - Update heartbeat if worker is still running
-     * - Confirm completion if PostActions already processed it
-     */
-    async checkInprogressCard(card, opts) {
-        const seq = card.seq;
-        const state = this.runtimeStore.readState();
-        const lease = state.leases[seq] || null;
-        const slotName = this.findRuntimeSlotName(state, seq, lease);
-        if (!slotName) {
-            // Slot already released (PostActions handled it via exit callback)
-            return null;
-        }
-        // Use WorkerManager.inspect() to check worker state
-        const snapshots = this.workerManager.inspect({ project: this.ctx.projectName, taskId: seq });
-        const snapshot = snapshots[0];
-        if (snapshot && (snapshot.state === 'running' || snapshot.state === 'starting')) {
-            // Worker still running — update heartbeat
-            try {
-                this.runtimeStore.updateState('pipeline-heartbeat', (freshState) => {
-                    if (freshState.workers[slotName]) {
-                        freshState.workers[slotName].lastHeartbeat = new Date().toISOString();
-                    }
-                });
-            }
-            catch { /* non-fatal */ }
-            return null;
-        }
-        if (snapshot && (snapshot.state === 'waiting_input' || snapshot.state === 'needs_confirmation')) {
-            // Worker waiting for input — log and wait
-            this.log.info(`seq ${seq}: worker in state ${snapshot.state}`);
-            return null;
-        }
-        if (snapshot && snapshot.state === 'completed') {
-            // WM exit callback handled completion
-            this.log.ok(`seq ${seq}: Completed (handled by WM exit callback)`);
-            return { action: 'complete', entity: `seq:${seq}`, result: 'ok', message: 'Completed via WM exit callback' };
-        }
-        if (snapshot && snapshot.state === 'failed') {
-            // WM exit callback handled failure
-            this.log.info(`seq ${seq}: Failed (handled by WM exit callback)`);
-            return { action: 'complete', entity: `seq:${seq}`, result: 'fail', message: 'Failed via WM exit callback' };
-        }
-        // No snapshot found — WM already processed and released the slot
-        const freshState = this.runtimeStore.readState();
-        if (!freshState.workers[slotName] || freshState.workers[slotName].status === 'idle') {
-            this.log.ok(`seq ${seq}: Completed (WM already processed)`);
-            return { action: 'complete', entity: `seq:${seq}`, result: 'ok', message: 'Completed (WM processed)' };
-        }
-        // Still active in state but no snapshot — MonitorEngine/Recovery handles
-        return null;
-    }
-    // ─── Prepare Phase (Backlog → Todo) ─────────────────────────────
-    /**
-     * Prepare a Backlog card: create branch, create worktree, move to Todo.
-     * Steps 1-3 per 01 §4.3.
-     */
-    async prepareCard(card, opts) {
-        const seq = card.seq;
-        const branchName = this.buildBranchName(card);
-        const worktreePath = resolveWorktreePath(this.ctx.projectName, seq, this.ctx.config.WORKTREE_DIR);
-        if (opts.dryRun) {
-            this.log.info(`[dry-run] Would prepare seq ${seq}: branch=${branchName} worktree=${worktreePath}`);
-            return { action: 'prepare', entity: `seq:${seq}`, result: 'ok', message: 'dry-run' };
-        }
-        // Step 1: Create branch
-        try {
-            await this.repoBackend.ensureBranch(this.ctx.paths.repoDir, branchName, this.ctx.mergeBranch);
-            this.log.ok(`Step 1: Branch ${branchName} created for seq ${seq}`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 1 failed (branch) for seq ${seq}: ${msg}`);
-            this.logEvent('prepare-branch', seq, 'fail', { error: msg });
-            return { action: 'prepare', entity: `seq:${seq}`, result: 'fail', message: `Branch creation failed: ${msg}` };
-        }
-        // Step 2: Create worktree
-        try {
-            await this.repoBackend.ensureWorktree(this.ctx.paths.repoDir, branchName, worktreePath);
-            this.log.ok(`Step 2: Worktree created for seq ${seq} at ${worktreePath}`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 2 failed (worktree) for seq ${seq}: ${msg}`);
-            this.logEvent('prepare-worktree', seq, 'fail', { error: msg });
-            // Rollback: cleanup branch (best effort, branch may have existed before)
-            return { action: 'prepare', entity: `seq:${seq}`, result: 'fail', message: `Worktree creation failed: ${msg}` };
-        }
-        // Step 3: Move card to Todo
-        try {
-            await this.taskBackend.move(seq, this.pipelineAdapter.states.ready);
-            this.log.ok(`Step 3: Moved seq ${seq} ${this.pipelineAdapter.states.backlog} → ${this.pipelineAdapter.states.ready}`);
-            this.logEvent('prepare', seq, 'ok');
-            if (this.notifier) {
-                await this.notifier.send(`ℹ️ [${this.ctx.projectName}] seq:${seq} environment ready (${this.pipelineAdapter.states.backlog} → ${this.pipelineAdapter.states.ready})`).catch(() => { });
-            }
-            return { action: 'prepare', entity: `seq:${seq}`, result: 'ok', message: `${this.pipelineAdapter.states.backlog} → ${this.pipelineAdapter.states.ready}` };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 3 failed (move) for seq ${seq}: ${msg}`);
-            this.logEvent('prepare-move', seq, 'fail', { error: msg });
-            // Rollback: cleanup branch + worktree would be ideal but risky; log for manual cleanup
-            return { action: 'prepare', entity: `seq:${seq}`, result: 'fail', message: `Move to ${this.pipelineAdapter.states.ready} failed: ${msg}` };
-        }
-    }
-    // ─── Launch Phase (Todo → Inprogress) ────────────────────────────
-    /**
-     * Launch a Todo card: claim slot, build context, start worker, move to Inprogress.
-     * Steps 4-7 per 01 §4.3.
-     */
-    async launchCard(card, opts, failedSlots = new Set()) {
-        const seq = card.seq;
-        const branchName = this.buildBranchName(card);
-        const worktreePath = resolveWorktreePath(this.ctx.projectName, seq, this.ctx.config.WORKTREE_DIR);
-        const workflowTransport = resolveWorkflowTransport(this.ctx.config);
-        if (opts.dryRun) {
-            this.log.info(`[dry-run] Would launch seq ${seq}`);
-            return { action: 'launch', entity: `seq:${seq}`, result: 'ok', message: 'dry-run' };
-        }
-        // Step 5: PM claim (kept in Engine — PM backend awareness)
-        try {
-            await this.taskBackend.claim(seq, `pending-wm`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.warn(`PM claim for seq ${seq} failed (non-fatal): ${msg}`);
-        }
-        // Step 5b: Build development prompt (in-memory, archive to .sps/)
-        let prompt;
-        try {
-            prompt = this.buildDevelopmentPrompt(card, worktreePath);
-            this.log.ok(`Step 5: Task context built for seq ${seq}`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 5 failed (context) for seq ${seq}: ${msg}`);
-            this.logEvent('launch-context', seq, 'fail', { error: msg });
-            return { action: 'launch', entity: `seq:${seq}`, result: 'fail', message: `Context build failed: ${msg}` };
-        }
-        // Step 6: Launch worker via WorkerManager.run()
-        const logsDir = this.ctx.config.raw.LOGS_DIR || `/tmp/sps-${this.ctx.projectName}`;
-        const runRequest = {
-            taskId: String(card.seq),
-            cardId: String(card.seq),
-            project: this.ctx.projectName,
-            phase: 'development',
-            prompt,
-            cwd: worktreePath,
-            branch: branchName,
-            targetBranch: this.ctx.mergeBranch,
-            tool: (this.pipelineAdapter.developStage.agent || this.ctx.config.WORKER_TOOL),
-            transport: 'acp-sdk',
-            outputFile: resolve(logsDir, `${this.ctx.projectName}-worker-${card.seq}-${Date.now()}.jsonl`),
-            timeoutSec: this.ctx.config.WORKER_LAUNCH_TIMEOUT_S,
-            maxRetries: this.ctx.config.WORKER_RESTART_LIMIT,
-            completionStrategy: this.pipelineAdapter.developStage.completion,
-        };
-        let response;
-        try {
-            response = await this.workerManager.run(runRequest);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 6 failed (WM.run) for seq ${seq}: ${msg}`);
-            failedSlots.add(`wm-error-${seq}`);
-            this.logEvent('launch-worker', seq, 'fail', { error: msg });
-            return { action: 'launch', entity: `seq:${seq}`, result: 'fail', message: `Worker launch failed: ${msg}` };
-        }
-        if (!response.accepted) {
-            this.log.warn(`WM rejected seq ${seq}: ${response.rejectReason}`);
-            return {
-                action: 'launch',
-                entity: `seq:${seq}`,
-                result: response.rejectReason === 'resource_exhausted' ? 'skip' : 'fail',
-                message: `WM rejected: ${response.rejectReason}`,
-            };
-        }
-        const slotName = response.slot;
-        this.log.ok(`Step 6: WM launched worker for seq ${seq} (slot=${slotName}, pid=${response.pid ?? 'n/a'})`);
-        if (this.notifier) {
-            await this.notifier.send(`▶️ [${this.ctx.projectName}] seq:${seq} worker started (${slotName})`).catch(() => { });
-        }
-        // Step 7: Move card to Inprogress
-        try {
-            await this.taskBackend.move(seq, this.pipelineAdapter.states.active);
-            // Update active card state
-            this.runtimeStore.updateState('pipeline-launch', (freshState) => {
-                if (freshState.activeCards[seq]) {
-                    freshState.activeCards[seq].state = this.pipelineAdapter.states.active;
-                    if (freshState.leases[seq]) {
-                        freshState.leases[seq].pmStateObserved = this.pipelineAdapter.states.active;
-                        if (freshState.leases[seq].phase === 'preparing' || freshState.leases[seq].phase === 'queued') {
-                            freshState.leases[seq].phase = 'coding';
-                        }
-                        freshState.leases[seq].lastTransitionAt = new Date().toISOString();
-                    }
-                }
-            });
-            this.log.ok(`Step 7: Moved seq ${seq} ${this.pipelineAdapter.states.ready} → ${this.pipelineAdapter.states.active}`);
-            this.logEvent('launch', seq, 'ok', { worker: slotName });
-            return { action: 'launch', entity: `seq:${seq}`, result: 'ok', message: `${this.pipelineAdapter.states.ready} → ${this.pipelineAdapter.states.active} (${slotName})` };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Step 7 failed (move) for seq ${seq}: ${msg}`);
-            // Rollback: cancel worker via WM (handles kill + resource release)
-            try {
-                await this.workerManager.cancel({ taskId: String(card.seq), project: this.ctx.projectName, reason: 'anomaly' });
-            }
-            catch { /* best effort */ }
-            this.releaseSlot(slotName, seq);
-            this.logEvent('launch-move', seq, 'fail', { error: msg });
-            return { action: 'launch', entity: `seq:${seq}`, result: 'fail', message: `Move to ${this.pipelineAdapter.states.active} failed: ${msg}` };
-        }
-    }
-    /**
-     * @deprecated Phase 1 transitional — WM's internal exit callback handles ACP inspection.
-     * Kept for edge-case fallback; will be removed when WM fully owns ACP lifecycle.
-     */
-    async checkAcpInprogressCard(card, slotName) {
-        const seq = card.seq;
-        const state = this.runtimeStore.readState();
-        const slot = state.workers[slotName];
-        if (!slot)
-            return null;
-        // Use WorkerManager.inspect() for normalized worker state
-        const snapshots = this.workerManager.inspect({ project: this.ctx.projectName, taskId: seq });
-        const snapshot = snapshots[0];
-        if (snapshot && (snapshot.state === 'running' || snapshot.state === 'starting')) {
-            // Worker still active — update heartbeat
-            this.runtimeStore.updateState('pipeline-acp-heartbeat', (freshState) => {
-                const freshSlot = freshState.workers[slotName];
-                if (freshSlot) {
-                    freshSlot.lastHeartbeat = new Date().toISOString();
-                }
-            });
-            return null;
-        }
-        if (snapshot && snapshot.state === 'waiting_input') {
-            this.log.info(`seq ${seq}: worker waiting for input`);
-            return null;
-        }
-        if (snapshot && snapshot.state === 'needs_confirmation') {
-            this.log.warn(`seq ${seq}: worker needs confirmation`);
-            return null;
-        }
-        if (snapshot && snapshot.state === 'completed') {
-            this.log.ok(`seq ${seq}: ACP run completed (via WM)`);
-            return {
-                action: 'complete',
-                entity: `seq:${seq}`,
-                result: 'ok',
-                message: `${resolveWorkflowTransport(this.ctx.config).toUpperCase()} run completed`,
-            };
-        }
-        if (snapshot && snapshot.state === 'failed') {
-            this.log.info(`seq ${seq}: ACP run failed (via WM)`);
-            return {
-                action: 'complete',
-                entity: `seq:${seq}`,
-                result: 'fail',
-                message: `${resolveWorkflowTransport(this.ctx.config).toUpperCase()} run failed`,
-            };
-        }
-        // No snapshot — session lost or already cleaned up
-        this.runtimeStore.updateState('pipeline-acp-lost', (freshState) => {
-            const lostSlot = freshState.workers[slotName];
-            if (lostSlot) {
-                lostSlot.sessionState = 'offline';
-                lostSlot.remoteStatus = 'lost';
-                lostSlot.lastEventAt = new Date().toISOString();
-                lostSlot.lastHeartbeat = new Date().toISOString();
-            }
-        });
-        this.log.warn(`seq ${seq}: ACP session lost — no WM snapshot found`);
-        return {
-            action: 'complete',
-            entity: `seq:${seq}`,
-            result: 'fail',
-            message: 'ACP session lost',
-        };
-    }
-    findRuntimeSlotName(state, seq, lease) {
-        if (lease?.slot && state.workers[lease.slot])
-            return lease.slot;
-        const slotEntry = Object.entries(state.workers).find(([, worker]) => worker.seq === parseInt(seq, 10) && worker.status !== 'idle');
-        return slotEntry?.[0] || null;
-    }
-    getRetryCount(state, seq) {
-        return state.leases[seq]?.retryCount ?? state.activeCards[seq]?.retryCount ?? 0;
-    }
-    // ─── Helpers ─────────────────────────────────────────────────────
-    /**
-     * Build branch name from card: feature/<seq>-<slug>
-     */
-    buildBranchName(card) {
-        const slug = card.name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-|-$/g, '')
-            .slice(0, 40);
-        return `feature/${card.seq}-${slug}`;
-    }
-    /**
-     * Write task-specific prompt to worktree.
-     *
-     * CLAUDE.md and AGENTS.md are managed by `sps doctor --fix` and committed
-     * to the repo — worktrees inherit them automatically via git.
-     *
-     * The prompt file includes the project rules (from CLAUDE.md) followed by
-     * the task-specific details. This ensures that when a session is reused
-     * (WORKER_SESSION_REUSE=true), the worker always receives the latest
-     * project rules via the prompt — even though /clear + cd does not
-     * trigger Claude/Codex to re-read CLAUDE.md from disk.
-     */
-    /**
-     * Build the shared prompt context used by both development and integration phases.
-     * Loads skill profiles, project rules, and knowledge from the worktree.
-     */
-    buildPromptContext(card, worktreePath) {
-        const branchName = this.buildBranchName(card);
-        const skillContent = this.loadSkillProfiles(card);
-        const claudeMdPath = resolve(worktreePath, 'CLAUDE.md');
-        const agentsMdPath = resolve(worktreePath, 'AGENTS.md');
-        const workerTool = this.pipelineAdapter.developStage.agent || this.ctx.config.WORKER_TOOL;
-        let projectRules = '';
-        if (existsSync(claudeMdPath)) {
-            projectRules = readFileSync(claudeMdPath, 'utf-8').trim();
-        }
-        if (existsSync(agentsMdPath)) {
-            const agentsRules = readFileSync(agentsMdPath, 'utf-8').trim();
-            projectRules = projectRules ? `${projectRules}\n\n${agentsRules}` : agentsRules;
-        }
-        if (!projectRules) {
-            const expectedFile = workerTool === 'codex' ? 'AGENTS.md' : 'CLAUDE.md';
-            this.log.warn(`${expectedFile} not found in worktree — run: sps doctor ${this.ctx.projectName} --fix`);
-        }
-        const knowledge = this.loadProjectKnowledge(worktreePath);
-        return {
-            taskSeq: card.seq,
-            taskTitle: card.name,
-            taskDescription: card.desc || '(no description)',
-            cardId: card.id,
-            worktreePath,
-            branchName,
-            targetBranch: this.ctx.mergeBranch,
-            mergeMode: this.ctx.mrMode,
-            gitlabProjectId: resolveGitlabProjectId(this.ctx.config),
-            skillContent,
-            projectRules,
-            knowledge,
-        };
-    }
-    /**
-     * Generate development prompt and archive to .sps/ for debugging.
-     * Returns the prompt string directly — no disk file dependency.
-     */
-    buildDevelopmentPrompt(card, worktreePath) {
-        const ctx = this.buildPromptContext(card, worktreePath);
-        const prompt = buildPhasePrompt({ ...ctx, phase: 'development' });
-        // Archive to .sps/ for debugging (non-blocking)
-        try {
-            const spsDir = resolve(worktreePath, '.sps');
-            if (!existsSync(spsDir))
-                mkdirSync(spsDir, { recursive: true });
-            writeFileSync(resolve(spsDir, DEVELOPMENT_PROMPT_FILE), prompt);
-        }
-        catch { /* archive failure should never block worker launch */ }
-        return prompt;
-    }
-    /**
-     * Release a worker slot and remove card from active cards.
-     * Used for launch failure rollback.
-     */
-    releaseSlot(slotName, seq) {
-        try {
-            this.runtimeStore.updateState('pipeline-release', (state) => {
-                this.runtimeStore.releaseTaskProjection(state, seq, { dropLease: true });
-            });
-            this.taskBackend.releaseClaim(seq).catch(() => { });
-        }
-        catch {
-            this.log.warn(`Failed to release slot ${slotName} for seq ${seq}`);
-        }
-    }
-    // ─── Skill Profile Loading (label-driven) ─────────────────────
-    /**
-     * Load skill profiles based on card labels (skill:xxx) or project default.
-     * Returns combined profile content for prompt injection.
-     */
-    loadSkillProfiles(card) {
-        // 1. Extract skill:xxx labels from card
-        let skills = card.labels
-            .filter(l => l.startsWith('skill:'))
-            .map(l => l.slice('skill:'.length));
-        // 2. Stage-level profile from pipeline YAML (overrides project default)
-        if (skills.length === 0 && this.pipelineAdapter.developStage.profile) {
-            skills = this.pipelineAdapter.developStage.profile.split(',').map(s => s.trim()).filter(Boolean);
-        }
-        // 3. Fallback to project default
-        if (skills.length === 0) {
-            const defaultSkills = this.ctx.config.raw.DEFAULT_WORKER_SKILLS;
-            if (defaultSkills) {
-                skills = defaultSkills.split(',').map(s => s.trim()).filter(Boolean);
-            }
-        }
-        if (skills.length === 0)
-            return '';
-        // Don't inject full profile content — agent loads skills on demand
-        // via ~/.claude/skills/ or ~/.codex/skills/ (symlinked from ~/.coral/skills/).
-        // Just tell the agent which skills to activate.
-        this.log.ok(`Skill labels: ${skills.join(', ')}`);
-        return `# Required Skills\n\nThis task requires the following skills: ${skills.join(', ')}.\nLoad the dev-worker skill and read the corresponding references.`;
-    }
-    // ─── Project Knowledge Loading (truncated) ────────────────────
-    /**
-     * Load recent project knowledge from docs/DECISIONS.md and docs/CHANGELOG.md.
-     * Truncates to recent entries to keep prompt size manageable.
-     */
-    loadProjectKnowledge(worktreePath) {
-        const sections = ['# Project Knowledge (from previous tasks)'];
-        let hasContent = false;
-        // Recent decisions (last 10 sections)
-        const decisionsPath = resolve(worktreePath, 'docs', 'DECISIONS.md');
-        if (existsSync(decisionsPath)) {
-            const content = readFileSync(decisionsPath, 'utf-8');
-            const recent = this.extractRecentSections(content, 10);
-            if (recent) {
-                sections.push('## Recent Decisions\n' + recent);
-                hasContent = true;
-            }
-        }
-        // Recent changelog (last 5 sections)
-        const changelogPath = resolve(worktreePath, 'docs', 'CHANGELOG.md');
-        if (existsSync(changelogPath)) {
-            const content = readFileSync(changelogPath, 'utf-8');
-            const recent = this.extractRecentSections(content, 5);
-            if (recent) {
-                sections.push('## Recent Changes\n' + recent);
-                hasContent = true;
-            }
-        }
-        return hasContent ? sections.join('\n\n') : '';
-    }
-    /**
-     * Extract the last N ## sections from a markdown file.
-     */
-    extractRecentSections(content, maxSections) {
-        const lines = content.split('\n');
-        const sectionStarts = [];
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].startsWith('## ')) {
-                sectionStarts.push(i);
-            }
-        }
-        if (sectionStarts.length === 0)
-            return content.trim();
-        const start = sectionStarts[Math.max(0, sectionStarts.length - maxSections)];
-        return lines.slice(start).join('\n').trim();
-    }
-    logEvent(action, seq, result, meta) {
-        this.log.event({
-            component: 'pipeline',
-            action,
-            entity: `seq:${seq}`,
-            result,
-            meta,
-        });
-    }
-}
-//# sourceMappingURL=ExecutionEngine.js.map