@coralai/sps-cli 0.6.0

package/dist/engines/ExecutionEngine.d.ts

@@ -0,0 +1,65 @@
+import type { ProjectContext } from '../core/context.js';
+import type { TaskBackend } from '../interfaces/TaskBackend.js';
+import type { WorkerProvider } from '../interfaces/WorkerProvider.js';
+import type { RepoBackend } from '../interfaces/RepoBackend.js';
+import type { Notifier } from '../interfaces/Notifier.js';
+import type { CommandResult } from '../models/types.js';
+export declare class ExecutionEngine {
+    private ctx;
+    private taskBackend;
+    private workerProvider;
+    private repoBackend;
+    private notifier?;
+    private log;
+    constructor(ctx: ProjectContext, taskBackend: TaskBackend, workerProvider: WorkerProvider, repoBackend: RepoBackend, notifier?: Notifier | undefined);
+    tick(opts?: {
+        dryRun?: boolean;
+    }): Promise<CommandResult>;
+    /**
+     * Launch a single card (for `sps worker launch <project> <seq>`).
+     * Assumes card is in Todo state with branch/worktree already prepared.
+     */
+    launchSingle(seq: string, opts?: {
+        dryRun?: boolean;
+    }): Promise<CommandResult>;
+    private shouldSkip;
+    /**
+     * Check an Inprogress card: detect worker completion status and act.
+     * This is the critical Inprogress → QA bridge (01 §10.2).
+     *
+     * Detection chain (12 §2):
+     *   COMPLETED      → move card to QA
+     *   AUTO_CONFIRM   → auto-confirm prompt, continue next tick
+     *   NEEDS_INPUT    → mark WAITING-CONFIRMATION, notify
+     *   BLOCKED        → mark BLOCKED
+     *   ALIVE          → no action (worker still working)
+     *   DEAD           → mark STALE-RUNTIME (handled by MonitorEngine)
+     *   DEAD_EXCEEDED  → mark STALE-RUNTIME, notify
+     */
+    private checkInprogressCard;
+    /**
+     * Prepare a Backlog card: create branch, create worktree, move to Todo.
+     * Steps 1-3 per 01 §4.3.
+     */
+    private prepareCard;
+    /**
+     * Launch a Todo card: claim slot, build context, start worker, move to Inprogress.
+     * Steps 4-7 per 01 §4.3.
+     */
+    private launchCard;
+    /**
+     * Build branch name from card: feature/<seq>-<slug>
+     */
+    private buildBranchName;
+    /**
+     * Write worker rules and task prompt to worktree.
+     * Generates both CLAUDE.md (for Claude) and AGENTS.md (for Codex).
+     */
+    private buildTaskContext;
+    /**
+     * Release a worker slot, cleanup tmux session, remove card from active cards.
+     */
+    private releaseSlot;
+    private logEvent;
+}
+//# sourceMappingURL=ExecutionEngine.d.ts.map

package/dist/engines/ExecutionEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionEngine.d.ts","sourceRoot":"","sources":["../../src/engines/ExecutionEngine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAsC,MAAM,oBAAoB,CAAC;AAO5F,qBAAa,eAAe;IAIxB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,QAAQ,CAAC;IAPnB,OAAO,CAAC,GAAG,CAAS;gBAGV,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,WAAW,EACxB,QAAQ,CAAC,EAAE,QAAQ,YAAA;IAKvB,IAAI,CAAC,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,aAAa,CAAC;IAiFnE;;;OAGG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,aAAa,CAAC;IAuDxF,OAAO,CAAC,UAAU;IAMlB;;;;;;;;;;;;OAYG;YACW,mBAAmB;IAwIjC;;;OAGG;YACW,WAAW;IA6DzB;;;OAGG;YACW,UAAU;IAoJxB;;OAEG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IA+DxB;;OAEG;IACH,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,QAAQ;CASjB"}

package/dist/engines/ExecutionEngine.js

@@ -0,0 +1,603 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { readState, writeState } from '../core/state.js';
+import { resolveWorktreePath } from '../core/paths.js';
+import { Logger } from '../core/logger.js';
+const SKIP_LABELS = ['BLOCKED', 'NEEDS-FIX', 'CONFLICT', 'WAITING-CONFIRMATION', 'STALE-RUNTIME'];
+export class ExecutionEngine {
+    ctx;
+    taskBackend;
+    workerProvider;
+    repoBackend;
+    notifier;
+    log;
+    constructor(ctx, taskBackend, workerProvider, repoBackend, notifier) {
+        this.ctx = ctx;
+        this.taskBackend = taskBackend;
+        this.workerProvider = workerProvider;
+        this.repoBackend = repoBackend;
+        this.notifier = notifier;
+        this.log = new Logger('pipeline', ctx.projectName, ctx.paths.logsDir);
+    }
+    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 {
+            // 1. Process Inprogress cards (detect completion → move to QA)
+            //    This runs first to free slots before launching new workers.
+            const inprogressCards = await this.taskBackend.listByState('Inprogress');
+            for (const card of inprogressCards) {
+                if (this.shouldSkip(card))
+                    continue;
+                const checkResult = await this.checkInprogressCard(card, opts);
+                if (checkResult) {
+                    actions.push(checkResult);
+                    if (checkResult.result === 'ok')
+                        actionsThisTick++;
+                }
+            }
+            // 2. Process Backlog cards (prepare: branch + worktree + move to Todo)
+            const backlogCards = await this.taskBackend.listByState('Backlog');
+            for (const card of backlogCards) {
+                if (actionsThisTick >= maxActions)
+                    break;
+                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')
+                    actionsThisTick++;
+            }
+            // 3. Process Todo cards (launch: claim + context + worker + move to Inprogress)
+            //    Stagger launches to avoid overwhelming tmux/system with simultaneous Claude starts
+            const todoCards = await this.taskBackend.listByState('Todo');
+            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: wait 10s between worker launches to let each Claude settle
+                if (launchedThisTick > 0) {
+                    this.log.info(`Waiting 10s before next worker launch...`);
+                    await new Promise((r) => setTimeout(r, 10_000));
+                }
+                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 === '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 !== 'Todo') {
+                result.status = 'fail';
+                result.exitCode = 1;
+                result.details = { error: 'Card not in Todo after prepare' };
+                return result;
+            }
+        }
+        if (card.state !== 'Todo' && card.state !== 'Backlog') {
+            result.status = 'fail';
+            result.exitCode = 2;
+            result.details = { error: `Card seq:${seq} is in ${card.state}, expected Backlog or Todo` };
+            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));
+    }
+    // ─── Inprogress Phase (detect completion → QA) ──────────────────
+    /**
+     * Check an Inprogress card: detect worker completion status and act.
+     * This is the critical Inprogress → QA bridge (01 §10.2).
+     *
+     * Detection chain (12 §2):
+     *   COMPLETED      → move card to QA
+     *   AUTO_CONFIRM   → auto-confirm prompt, continue next tick
+     *   NEEDS_INPUT    → mark WAITING-CONFIRMATION, notify
+     *   BLOCKED        → mark BLOCKED
+     *   ALIVE          → no action (worker still working)
+     *   DEAD           → mark STALE-RUNTIME (handled by MonitorEngine)
+     *   DEAD_EXCEEDED  → mark STALE-RUNTIME, notify
+     */
+    async checkInprogressCard(card, opts) {
+        const seq = card.seq;
+        const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+        // Find this card's worker slot
+        const slotEntry = Object.entries(state.workers).find(([, w]) => w.seq === parseInt(seq, 10) && w.status === 'active');
+        if (!slotEntry) {
+            // No active slot — MonitorEngine handles orphan detection
+            return null;
+        }
+        const [slotName, slotState] = slotEntry;
+        const session = slotState.tmuxSession;
+        if (!session)
+            return null;
+        // Determine logDir for completion marker detection
+        const logDir = this.ctx.paths.logsDir;
+        const branch = slotState.branch || this.buildBranchName(card);
+        let workerStatus;
+        try {
+            workerStatus = await this.workerProvider.detectCompleted(session, logDir, branch);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.warn(`detectCompleted failed for seq ${seq}: ${msg}`);
+            return null;
+        }
+        switch (workerStatus) {
+            case 'COMPLETED': {
+                if (opts.dryRun) {
+                    this.log.info(`[dry-run] Would move seq ${seq} Inprogress → QA`);
+                    return { action: 'complete', entity: `seq:${seq}`, result: 'ok', message: 'dry-run: would move to QA' };
+                }
+                // Check if MR exists before moving to QA — worker may still be creating it
+                try {
+                    const mrStatus = await this.repoBackend.getMrStatus(branch);
+                    if (!mrStatus.exists) {
+                        this.log.info(`seq ${seq}: Worker completed but MR not yet created, waiting`);
+                        return null; // retry next tick
+                    }
+                }
+                catch {
+                    // Can't check MR — proceed anyway, closeout will handle it
+                }
+                // Move card to QA
+                try {
+                    await this.taskBackend.move(seq, 'QA');
+                    this.log.ok(`seq ${seq}: Worker completed, moved Inprogress → QA`);
+                    // Update state.json
+                    const freshState = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+                    if (freshState.activeCards[seq]) {
+                        freshState.activeCards[seq].state = 'QA';
+                        writeState(this.ctx.paths.stateFile, freshState, 'pipeline-complete');
+                    }
+                    this.logEvent('complete', seq, 'ok', { worker: slotName });
+                    if (this.notifier) {
+                        await this.notifier.sendSuccess(`[${this.ctx.projectName}] seq:${seq} worker completed, moved to QA`).catch(() => { });
+                    }
+                    return { action: 'complete', entity: `seq:${seq}`, result: 'ok', message: 'Inprogress → QA (worker completed)' };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    this.log.error(`Failed to move seq ${seq} to QA: ${msg}`);
+                    return { action: 'complete', entity: `seq:${seq}`, result: 'fail', message: `Move to QA failed: ${msg}` };
+                }
+            }
+            case 'AUTO_CONFIRM': {
+                // Non-destructive confirmation prompt → auto-confirm
+                this.log.info(`seq ${seq}: Worker waiting for non-destructive confirmation, auto-confirming`);
+                try {
+                    await this.workerProvider.sendFix(session, 'y');
+                    this.logEvent('auto-confirm', seq, 'ok');
+                    if (this.notifier) {
+                        await this.notifier.send(`[${this.ctx.projectName}] seq:${seq} auto-confirmed`, 'info').catch(() => { });
+                    }
+                }
+                catch {
+                    this.log.warn(`seq ${seq}: Auto-confirm failed`);
+                }
+                return { action: 'auto-confirm', entity: `seq:${seq}`, result: 'ok', message: 'Auto-confirmed non-destructive prompt' };
+            }
+            case 'NEEDS_INPUT': {
+                // Destructive confirmation → mark WAITING-CONFIRMATION, notify Boss
+                this.log.warn(`seq ${seq}: Worker waiting for destructive confirmation`);
+                try {
+                    await this.taskBackend.addLabel(seq, 'WAITING-CONFIRMATION');
+                }
+                catch { /* best effort */ }
+                if (this.notifier) {
+                    await this.notifier.sendWarning(`[${this.ctx.projectName}] seq:${seq} worker waiting for destructive confirmation`).catch(() => { });
+                }
+                this.logEvent('waiting-destructive', seq, 'ok');
+                return { action: 'mark-waiting', entity: `seq:${seq}`, result: 'ok', message: 'Destructive confirmation — waiting for human' };
+            }
+            case 'BLOCKED': {
+                this.log.warn(`seq ${seq}: Worker appears blocked`);
+                try {
+                    await this.taskBackend.addLabel(seq, 'BLOCKED');
+                }
+                catch { /* best effort */ }
+                this.logEvent('blocked', seq, 'ok');
+                return { action: 'mark-blocked', entity: `seq:${seq}`, result: 'ok', message: 'Worker blocked' };
+            }
+            case 'DEAD':
+            case 'DEAD_EXCEEDED': {
+                // Worker session died — MonitorEngine handles STALE-RUNTIME in detail
+                this.log.warn(`seq ${seq}: Worker session dead (${workerStatus})`);
+                return null; // defer to MonitorEngine
+            }
+            case 'ALIVE':
+            default:
+                // Worker still running — no action needed
+                // Update heartbeat
+                try {
+                    const freshState = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+                    if (freshState.workers[slotName]) {
+                        freshState.workers[slotName].lastHeartbeat = new Date().toISOString();
+                        writeState(this.ctx.paths.stateFile, freshState, 'pipeline-heartbeat');
+                    }
+                }
+                catch { /* non-fatal */ }
+                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);
+        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, 'Todo');
+            this.log.ok(`Step 3: Moved seq ${seq} Backlog → Todo`);
+            this.logEvent('prepare', seq, 'ok');
+            if (this.notifier) {
+                await this.notifier.send(`[${this.ctx.projectName}] seq:${seq} environment ready (Backlog → Todo)`, 'info').catch(() => { });
+            }
+            return { action: 'prepare', entity: `seq:${seq}`, result: 'ok', message: 'Backlog → Todo' };
+        }
+        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 Todo 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);
+        if (opts.dryRun) {
+            this.log.info(`[dry-run] Would launch seq ${seq}`);
+            return { action: 'launch', entity: `seq:${seq}`, result: 'ok', message: 'dry-run' };
+        }
+        // Step 4: Claim worker slot
+        // Exclude slots that failed launch this tick to prevent repeated failures
+        const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+        const idleSlots = Object.entries(state.workers)
+            .filter(([name, w]) => w.status === 'idle' && !failedSlots.has(name));
+        if (idleSlots.length === 0) {
+            this.log.warn(`No idle worker slot available for seq ${seq}`);
+            return { action: 'launch', entity: `seq:${seq}`, result: 'skip', message: 'No idle worker slot' };
+        }
+        // Prefer slot with live session (Claude still running → context reuse)
+        let slotEntry = idleSlots[0];
+        if (this.ctx.config.WORKER_SESSION_REUSE) {
+            for (const entry of idleSlots) {
+                const [name] = entry;
+                const sessionName = `${this.ctx.projectName}-${name}`;
+                try {
+                    const inspection = await this.workerProvider.inspect(sessionName);
+                    if (inspection.alive) {
+                        slotEntry = entry;
+                        this.log.info(`Preferring slot ${name} with live session`);
+                        break;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        const [slotName] = slotEntry;
+        const sessionName = `${this.ctx.projectName}-${slotName}`;
+        // Claim slot in state.json
+        state.workers[slotName] = {
+            status: 'active',
+            seq: parseInt(seq, 10),
+            branch: branchName,
+            worktree: worktreePath,
+            tmuxSession: sessionName,
+            claimedAt: new Date().toISOString(),
+            lastHeartbeat: new Date().toISOString(),
+        };
+        // Add to active cards
+        const conflictDomains = card.labels
+            .filter((l) => l.startsWith('conflict:'))
+            .map((l) => l.slice('conflict:'.length));
+        state.activeCards[seq] = {
+            seq: parseInt(seq, 10),
+            state: 'Todo',
+            worker: slotName,
+            mrUrl: null,
+            conflictDomains,
+            startedAt: new Date().toISOString(),
+        };
+        try {
+            writeState(this.ctx.paths.stateFile, state, 'pipeline-launch');
+            this.log.ok(`Step 4: Claimed slot ${slotName} for seq ${seq}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.error(`Step 4 failed (claim) for seq ${seq}: ${msg}`);
+            return { action: 'launch', entity: `seq:${seq}`, result: 'fail', message: `Claim slot failed: ${msg}` };
+        }
+        // Also claim in PM backend
+        try {
+            await this.taskBackend.claim(seq, slotName);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.warn(`PM claim for seq ${seq} failed (non-fatal): ${msg}`);
+        }
+        // Step 5: Build task context (CLAUDE.md + .jarvis_task_prompt.txt)
+        try {
+            this.buildTaskContext(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.releaseSlot(slotName, seq);
+            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
+        try {
+            await this.workerProvider.launch(sessionName, worktreePath);
+            // Wait for worker to be ready
+            const ready = await this.workerProvider.waitReady(sessionName, 90_000);
+            if (!ready) {
+                throw new Error('Worker did not become ready within timeout');
+            }
+            // Send task prompt
+            const promptFile = resolve(worktreePath, '.jarvis_task_prompt.txt');
+            await this.workerProvider.sendTask(sessionName, promptFile);
+            this.log.ok(`Step 6: Worker launched in session ${sessionName} for seq ${seq}`);
+            if (this.notifier) {
+                await this.notifier.sendSuccess(`[${this.ctx.projectName}] seq:${seq} worker started (${slotName})`).catch(() => { });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.error(`Step 6 failed (worker launch) for seq ${seq}: ${msg}`);
+            failedSlots.add(slotName);
+            this.releaseSlot(slotName, seq);
+            this.logEvent('launch-worker', seq, 'fail', { error: msg });
+            return { action: 'launch', entity: `seq:${seq}`, result: 'fail', message: `Worker launch failed: ${msg}` };
+        }
+        // Step 7: Move card to Inprogress
+        try {
+            await this.taskBackend.move(seq, 'Inprogress');
+            // Update active card state
+            const freshState = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+            if (freshState.activeCards[seq]) {
+                freshState.activeCards[seq].state = 'Inprogress';
+                writeState(this.ctx.paths.stateFile, freshState, 'pipeline-launch');
+            }
+            this.log.ok(`Step 7: Moved seq ${seq} Todo → Inprogress`);
+            this.logEvent('launch', seq, 'ok', { worker: slotName, session: sessionName });
+            return { action: 'launch', entity: `seq:${seq}`, result: 'ok', message: `Todo → Inprogress (${slotName})` };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log.error(`Step 7 failed (move) for seq ${seq}: ${msg}`);
+            // Rollback: stop worker, release slot
+            try {
+                await this.workerProvider.stop(sessionName);
+            }
+            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 Inprogress failed: ${msg}` };
+        }
+    }
+    // ─── 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 worker rules and task prompt to worktree.
+     * Generates both CLAUDE.md (for Claude) and AGENTS.md (for Codex).
+     */
+    buildTaskContext(card, worktreePath) {
+        if (!existsSync(worktreePath)) {
+            mkdirSync(worktreePath, { recursive: true });
+        }
+        const branchName = this.buildBranchName(card);
+        const workerRules = `# Task Rules (auto-generated, do not edit)
+
+## Scope
+- ONLY work in this directory: ${worktreePath}
+- Do NOT read or modify files outside this directory
+- Do NOT explore the system, home directory, or other projects
+
+## Workflow
+1. Read the task description below
+2. Implement the changes in this directory
+3. Self-test your changes
+4. git add, commit, and push to branch: ${branchName}
+5. Create a Merge Request targeting ${this.ctx.mergeBranch}
+6. Output "done" when finished
+
+## Commit Rules
+- Commit frequently (every meaningful change)
+- Push after each commit
+- Branch: ${branchName}
+- Use conventional commit messages (feat:, fix:, etc.)
+
+## MR Creation
+- Use git push first, then create MR via GitLab API:
+  curl -s -X POST -H "PRIVATE-TOKEN: $GITLAB_TOKEN" -H "Content-Type: application/json" \\
+    "$GITLAB_URL/api/v4/projects/${this.ctx.config.GITLAB_PROJECT_ID}/merge_requests" \\
+    -d '{"source_branch":"${branchName}","target_branch":"${this.ctx.mergeBranch}","title":"feat(${card.seq}): ${card.name}"}'
+
+## Forbidden
+- No PLAN.md, TODO.md, TASKLIST.md, ROADMAP.md, NOTES.md
+- No local planning files of any kind
+- No changes outside task scope
+- Do NOT explore ~/.projects or other system directories
+`;
+        // .jarvis_task_prompt.txt — task prompt
+        const taskPrompt = `Task ID: ${card.seq}
+Task: ${card.name}
+Branch: ${branchName}
+Card Full ID: ${card.id}
+
+Description:
+${card.desc || '(no description)'}
+
+Requirements:
+1. Implement the changes described above
+2. Self-test your changes
+3. git add, commit, and push to branch ${branchName}
+4. Create a Merge Request targeting ${this.ctx.mergeBranch}
+5. Say "done" when finished
+`;
+        // Write both CLAUDE.md (for Claude) and AGENTS.md (for Codex)
+        writeFileSync(resolve(worktreePath, 'CLAUDE.md'), workerRules);
+        writeFileSync(resolve(worktreePath, 'AGENTS.md'), workerRules);
+        writeFileSync(resolve(worktreePath, '.jarvis_task_prompt.txt'), taskPrompt);
+    }
+    /**
+     * Release a worker slot, cleanup tmux session, remove card from active cards.
+     */
+    releaseSlot(slotName, seq) {
+        try {
+            // Kill tmux session if it exists (cleanup from failed launch)
+            const sessionName = `${this.ctx.projectName}-${slotName}`;
+            this.workerProvider.stop(sessionName).catch(() => { });
+            const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+            if (state.workers[slotName]) {
+                state.workers[slotName] = {
+                    status: 'idle',
+                    seq: null,
+                    branch: null,
+                    worktree: null,
+                    tmuxSession: null,
+                    claimedAt: null,
+                    lastHeartbeat: null,
+                };
+            }
+            delete state.activeCards[seq];
+            writeState(this.ctx.paths.stateFile, state, 'pipeline-release');
+            this.taskBackend.releaseClaim(seq).catch(() => { });
+        }
+        catch {
+            this.log.warn(`Failed to release slot ${slotName} for seq ${seq}`);
+        }
+    }
+    logEvent(action, seq, result, meta) {
+        this.log.event({
+            component: 'pipeline',
+            action,
+            entity: `seq:${seq}`,
+            result,
+            meta,
+        });
+    }
+}
+//# sourceMappingURL=ExecutionEngine.js.map