kantban-cli 0.1.8 → 0.1.10

package/dist/commands/pipeline.js

@@ -1,1222 +0,0 @@
-import { spawn, execSync } from 'node:child_process';
-import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync, appendFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { PipelineOrchestrator } from '../lib/orchestrator.js';
-import { RalphLoop } from '../lib/ralph-loop.js';
-import { RunMemory } from '../lib/run-memory.js';
-import { EventQueue } from '../lib/event-queue.js';
-import { PipelineWsClient } from '../lib/ws-client.js';
-import { generateMcpConfig, generateGateProxyMcpConfig, cleanupMcpConfig, cleanupGateProxyConfigs } from '../lib/mcp-config.js';
-import { PipelineLogger } from '../lib/logger.js';
-import { composeLightPrompt, parseLightResponse } from '../lib/light-call.js';
-import { composeAdvisorPrompt, parseAdvisorResponse } from '../lib/advisor.js';
-import { composeStuckDetectionPrompt, parseStuckDetectionResponse } from '../lib/stuck-detector.js';
-import { cleanupWorktree } from '../lib/worktree.js';
-import { spawnReaper, killReaper } from '../lib/reaper.js';
-import { StreamJsonParser } from '../lib/stream-parser.js';
-import { parseGateConfig, resolveGatesForColumn, parseTimeout } from '../lib/gate-config.js';
-import { GateSnapshotStore } from '../lib/gate-snapshot.js';
-import { runGates } from '../lib/gate-runner.js';
-import { PipelineCostTracker } from '../lib/cost-tracker.js';
-import { composeReplannerPrompt, parseReplannerResponse } from '../lib/replanner.js';
-import { PipelineEventEmitter } from '../lib/event-emitter.js';
-function parseArgs(args) {
-    const positional = [];
-    let once = false;
-    let dryRun = false;
-    let columnFilter = null;
-    let maxIterations = null;
-    let maxBudget = null;
-    let model = null;
-    let concurrency = null;
-    let logRetention = 7;
-    let yes = false;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        switch (arg) {
-            case '--once':
-                once = true;
-                break;
-            case '--dry-run':
-                dryRun = true;
-                break;
-            case '--yes':
-            case '-y':
-                yes = true;
-                break;
-            case '--column':
-                columnFilter = args[++i] ?? null;
-                break;
-            case '--max-iterations': {
-                const val = Number(args[++i]);
-                if (isNaN(val) || val <= 0) {
-                    console.error(`Error: --max-iterations requires a positive number, got: ${args[i]}`);
-                    process.exit(1);
-                }
-                maxIterations = val;
-                break;
-            }
-            case '--max-budget': {
-                const val = Number(args[++i]);
-                if (isNaN(val) || val < 0) {
-                    console.error(`Error: --max-budget requires a non-negative number, got: ${args[i]}`);
-                    process.exit(1);
-                }
-                maxBudget = val;
-                break;
-            }
-            case '--model':
-                model = args[++i] ?? null;
-                break;
-            case '--concurrency': {
-                const val = Number(args[++i]);
-                if (isNaN(val) || val <= 0) {
-                    console.error(`Error: --concurrency requires a positive number, got: ${args[i]}`);
-                    process.exit(1);
-                }
-                concurrency = val;
-                break;
-            }
-            case '--log-retention':
-                logRetention = Number(args[++i]) || 7;
-                break;
-            default:
-                if (!arg.startsWith('--'))
-                    positional.push(arg);
-                break;
-        }
-    }
-    const boardId = positional[0] ?? '';
-    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (boardId && !UUID_RE.test(boardId)) {
-        console.error(`Error: invalid board ID "${boardId}" — expected UUID`);
-        process.exit(1);
-    }
-    if (!boardId) {
-        console.error(`Usage: kantban pipeline <board-id> [flags]
-
-Flags:
-  --once                Run one scan, wait for loops, then exit
-  --dry-run             Show config without starting
-  --column <id>         Filter to a single column
-  --max-iterations <n>  Override max iterations per ticket
-  --max-budget <usd>    Per-ticket budget cap (USD)
-  --model <model>       Override model preference
-  --concurrency <n>     Override concurrency per column
-  --log-retention <d>   Log retention in days (default: 7)
-  --yes, -y             Skip safety confirmation`);
-        process.exit(1);
-    }
-    return { boardId, once, dryRun, columnFilter, maxIterations, maxBudget, model, concurrency, logRetention, yes };
-}
-// ---------------------------------------------------------------------------
-// PID file helpers
-// ---------------------------------------------------------------------------
-function pidDir(boardId) {
-    return join(homedir(), '.kantban', 'pipelines', boardId);
-}
-function pidFilePath(boardId) {
-    return join(pidDir(boardId), 'orchestrator.pid');
-}
-function writePidFile(boardId) {
-    const dir = pidDir(boardId);
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    writeFileSync(pidFilePath(boardId), String(process.pid), { mode: 0o600 });
-}
-function removePidFile(boardId) {
-    try {
-        unlinkSync(pidFilePath(boardId));
-    }
-    catch {
-        /* already removed */
-    }
-}
-// ---------------------------------------------------------------------------
-// Child PID manifest helpers — tracks spawned child PIDs on disk for orphan
-// cleanup by the watchdog reaper or next-startup cleanup.
-// ---------------------------------------------------------------------------
-function childManifestPath(boardId) {
-    return join(pidDir(boardId), 'children.pid');
-}
-function appendChildPid(boardId, pid) {
-    const dir = pidDir(boardId);
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    appendFileSync(childManifestPath(boardId), `${String(pid)}\n`, { mode: 0o600 });
-}
-function removeChildPid(boardId, pid) {
-    const manifestPath = childManifestPath(boardId);
-    try {
-        const contents = readFileSync(manifestPath, 'utf-8');
-        const pids = contents.split('\n').filter(l => l.trim() !== '' && l.trim() !== String(pid));
-        writeFileSync(manifestPath, pids.length > 0 ? pids.join('\n') + '\n' : '', { mode: 0o600 });
-    }
-    catch {
-        /* manifest doesn't exist or unreadable — nothing to remove */
-    }
-}
-function readChildManifest(boardId) {
-    try {
-        const contents = readFileSync(childManifestPath(boardId), 'utf-8');
-        return contents
-            .split('\n')
-            .map(l => l.trim())
-            .filter(l => l !== '')
-            .map(Number)
-            .filter(n => !isNaN(n) && n > 0);
-    }
-    catch {
-        return [];
-    }
-}
-function removeChildManifest(boardId) {
-    try {
-        unlinkSync(childManifestPath(boardId));
-    }
-    catch {
-        /* already removed */
-    }
-}
-/**
- * Kill any orphaned pipeline processes from a previous run.
- * Reads the stale PID file, kills that process tree, then removes the file.
- * Also kills any lingering `claude -p` processes that reference our MCP config dir.
- */
-function cleanupOrphanedProcesses(boardId) {
-    // 1. Kill stale orchestrator from PID file
-    const pidPath = pidFilePath(boardId);
-    if (existsSync(pidPath)) {
-        try {
-            const stalePid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
-            if (stalePid && stalePid !== process.pid) {
-                try {
-                    process.kill(stalePid, 0); // test if alive
-                    process.kill(stalePid, 'SIGTERM');
-                    console.log(`Killed stale orchestrator (PID ${String(stalePid)})`);
-                }
-                catch {
-                    // already dead
-                }
-            }
-        }
-        catch {
-            // can't read PID file
-        }
-        removePidFile(boardId);
-    }
-    // 1.5. Kill children from the PID manifest (more targeted than grep)
-    const manifestPids = readChildManifest(boardId);
-    if (manifestPids.length > 0) {
-        for (const pid of manifestPids) {
-            try {
-                process.kill(pid, 0); // test if alive
-                process.kill(pid, 'SIGTERM');
-            }
-            catch {
-                // already dead
-            }
-        }
-        console.log(`Killed ${String(manifestPids.length)} orphaned child process(es) from manifest`);
-        removeChildManifest(boardId);
-    }
-    // 1.6. Kill stale reaper if still running
-    const staleReaperPath = join(pidDir(boardId), 'reaper.pid');
-    try {
-        if (existsSync(staleReaperPath)) {
-            const reaperPid = parseInt(readFileSync(staleReaperPath, 'utf-8').trim(), 10);
-            if (reaperPid && !isNaN(reaperPid)) {
-                try {
-                    process.kill(reaperPid, 0);
-                    process.kill(reaperPid, 'SIGTERM');
-                    console.log(`Killed stale reaper (PID ${String(reaperPid)})`);
-                }
-                catch {
-                    // already dead
-                }
-            }
-            unlinkSync(staleReaperPath);
-        }
-    }
-    catch {
-        // can't read reaper PID — not critical
-    }
-    // 2. Kill orphaned claude -p processes with THIS BOARD's MCP configs
-    try {
-        const boardDir = pidDir(boardId).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const out = execSync(`ps aux | grep 'claude.*-p' | grep '${boardDir}' | grep -v grep | awk '{print $2}'`, { encoding: 'utf-8', timeout: 5000 }).trim();
-        if (out) {
-            const pids = out.split('\n').filter(Boolean);
-            for (const pid of pids) {
-                try {
-                    process.kill(parseInt(pid, 10), 'SIGTERM');
-                }
-                catch {
-                    // already dead
-                }
-            }
-            if (pids.length > 0) {
-                console.log(`Killed ${String(pids.length)} orphaned claude agent(s)`);
-            }
-        }
-    }
-    catch {
-        // ps/grep failed — not critical
-    }
-}
-// ---------------------------------------------------------------------------
-// invokeClaudeP — spawns a Claude Code process with -p flag
-// Children are spawned in the orchestrator's process group so that killing
-// the group (e.g. on crash) takes all children down with it.
-// ---------------------------------------------------------------------------
-const activeChildProcesses = new Set();
-let currentBoardId = '';
-const CLAUDE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour max per invocation
-async function invokeClaudeP(prompt, options) {
-    const args = ['-p', prompt, '--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
-    // MCP config — omit for toolless invocations
-    if (options.includeMcpConfig !== false && options.mcpConfigPath) {
-        args.push('--mcp-config', options.mcpConfigPath);
-    }
-    if (options.model)
-        args.push('--model', options.model);
-    if (options.maxTurns) {
-        args.push('--max-turns', String(options.maxTurns));
-    }
-    else if (options.maxBudgetUsd !== undefined && options.maxBudgetUsd !== null) {
-        args.push('--max-turns', String(Math.max(1, Math.ceil(options.maxBudgetUsd * 10))));
-    }
-    if (options.worktree)
-        args.push('--worktree', options.worktree);
-    // Tool scoping flags
-    if (options.tools !== undefined) {
-        args.push('--tools', options.tools);
-    }
-    if (options.allowedTools?.length) {
-        args.push('--allowedTools', ...options.allowedTools);
-    }
-    if (options.disallowedTools?.length) {
-        args.push('--disallowedTools', ...options.disallowedTools);
-    }
-    return new Promise((resolve) => {
-        const child = spawn('claude', args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        activeChildProcesses.add(child);
-        if (child.pid && currentBoardId)
-            appendChildPid(currentBoardId, child.pid);
-        const parser = new StreamJsonParser();
-        parser.on('error', (err) => {
-            process.stderr.write(`[stream-parser] ${err.message}\n`);
-        });
-        let lastOutput = '';
-        let tokensIn = 0;
-        let tokensOut = 0;
-        parser.on('event', (event) => {
-            // Capture final result metadata
-            if (event.type === 'result') {
-                const usage = event.usage;
-                tokensIn += usage?.input_tokens ?? 0;
-                tokensOut += usage?.output_tokens ?? 0;
-                if (typeof event.result === 'string')
-                    lastOutput = event.result;
-            }
-            // Forward to stream callback if provided
-            options.onStreamEvent?.(event);
-        });
-        child.stdout?.on('data', (chunk) => {
-            parser.feed(chunk.toString());
-        });
-        // Capture stderr for error diagnostics
-        let stderr = '';
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
-        // Close stdin immediately (we pass prompt via -p flag)
-        child.stdin?.end();
-        // Set up timeout
-        let killTimer;
-        const timeoutHandle = setTimeout(() => {
-            try {
-                child.kill('SIGTERM');
-            }
-            catch { /* already dead */ }
-            // Escalate to SIGKILL if process doesn't exit within 5s
-            killTimer = setTimeout(() => {
-                if (!resolved) {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch { /* already dead */ }
-                }
-            }, 5000);
-        }, CLAUDE_TIMEOUT_MS);
-        let resolved = false;
-        child.on('close', (code) => {
-            if (resolved)
-                return;
-            resolved = true;
-            clearTimeout(timeoutHandle);
-            if (killTimer)
-                clearTimeout(killTimer);
-            activeChildProcesses.delete(child);
-            if (child.pid && currentBoardId)
-                removeChildPid(currentBoardId, child.pid);
-            parser.flush();
-            resolve({
-                exitCode: code ?? 1,
-                output: lastOutput || stderr,
-                toolCallCount: parser.getToolCallCount(),
-                tokensIn,
-                tokensOut,
-            });
-        });
-        child.on('error', (err) => {
-            if (resolved)
-                return;
-            resolved = true;
-            clearTimeout(timeoutHandle);
-            if (killTimer)
-                clearTimeout(killTimer);
-            activeChildProcesses.delete(child);
-            if (child.pid && currentBoardId)
-                removeChildPid(currentBoardId, child.pid);
-            parser.flush();
-            resolve({
-                exitCode: 1,
-                output: err.message,
-                toolCallCount: parser.getToolCallCount(),
-                tokensIn,
-                tokensOut,
-            });
-        });
-    });
-}
-function killAllChildProcesses() {
-    for (const child of activeChildProcesses) {
-        try {
-            if (child.pid) {
-                try {
-                    process.kill(-child.pid, 'SIGTERM');
-                }
-                catch {
-                    try {
-                        child.kill('SIGTERM');
-                    }
-                    catch { /* already dead */ }
-                }
-            }
-            else {
-                try {
-                    child.kill('SIGTERM');
-                }
-                catch { /* already dead */ }
-            }
-        }
-        catch {
-            // Process already exited — safe to ignore
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Safety confirmation
-// ---------------------------------------------------------------------------
-function printSafetyWarning() {
-    console.log(`
-=== SAFETY WARNING ===
-
-This pipeline will run Claude Code agents with --dangerously-skip-permissions.
-Agents will have unrestricted access to tools, file system, and MCP servers.
-
-Before proceeding:
-  1. Review all prompt documents linked to pipeline columns
-  2. Ensure your project signals/guardrails are configured correctly
-  3. Verify your MCP server configuration is appropriate
-
-Press Ctrl+C to cancel, or re-run with --yes to skip this warning.
-`);
-}
-function waitForConfirmation() {
-    return new Promise((resolve) => {
-        // Non-TTY (piped input) — read from stdin instead of rejecting
-        process.stdout.write('Continue? [y/N] ');
-        process.stdin.setEncoding('utf8');
-        process.stdin.once('data', (data) => {
-            const answer = data.trim().toLowerCase();
-            resolve(answer === 'y' || answer === 'yes');
-        });
-        // If stdin ends without data (empty pipe), default to no
-        process.stdin.once('end', () => resolve(false));
-    });
-}
-// ---------------------------------------------------------------------------
-// runPipeline — main entry point
-// ---------------------------------------------------------------------------
-export async function runPipeline(client, args) {
-    // Handle subcommands
-    if (args[0] === 'init') {
-        const { runPipelineInit } = await import('./pipeline-init.js');
-        await runPipelineInit();
-        return;
-    }
-    const opts = parseArgs(args);
-    currentBoardId = opts.boardId;
-    // Safety confirmation
-    if (!opts.yes && !opts.dryRun) {
-        printSafetyWarning();
-        const confirmed = await waitForConfirmation();
-        if (!confirmed) {
-            console.log('Aborted.');
-            return;
-        }
-    }
-    // Validate gate file
-    const gateFilePath = join(process.cwd(), 'pipeline.gates.yaml');
-    let gateConfig;
-    if (!existsSync(gateFilePath)) {
-        console.error(`Error: pipeline.gates.yaml not found in ${process.cwd()}`);
-        console.error('Run "kantban pipeline init" to generate a starter gate file.');
-        process.exit(1);
-    }
-    try {
-        const gateYaml = readFileSync(gateFilePath, 'utf-8');
-        gateConfig = parseGateConfig(gateYaml);
-        console.log(`Gate config loaded: ${gateConfig.default.length} default gate(s)`);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: Invalid pipeline.gates.yaml: ${message}`);
-        process.exit(1);
-    }
-    // Create cost tracker if budget is configured
-    const costTracker = gateConfig.settings?.budget
-        ? new PipelineCostTracker(crypto.randomUUID(), gateConfig.settings.budget)
-        : undefined;
-    // Gate snapshot store — per-ticket gate history for gutter detection and advisor
-    const gateSnapshotStore = new GateSnapshotStore();
-    // Resolve project ID
-    let projectId = process.env['KANTBAN_PROJECT_ID'] ?? '';
-    if (!projectId) {
-        try {
-            const result = await client.getBoardProject(opts.boardId);
-            projectId = result.project_id;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`Error: Could not resolve project ID for board ${opts.boardId}: ${message}`);
-            console.error('Set KANTBAN_PROJECT_ID environment variable or ensure the board exists.');
-            process.exit(1);
-        }
-    }
-    // Generate MCP config (stable path per board — survives restarts)
-    const mcpConfigPath = generateMcpConfig(client.baseUrl, client.token, opts.boardId);
-    // Initialize logger
-    const logBaseDir = join(homedir(), '.kantban', 'pipelines');
-    const logger = new PipelineLogger(logBaseDir, opts.boardId);
-    logger.pruneOldLogs(opts.logRetention);
-    // Declared early so closures in deps can capture it by reference before initialization
-    let runMemory = null;
-    // Stable session ID for all pipeline events in this run
-    const pipelineSessionId = crypto.randomUUID();
-    const eventEmitter = new PipelineEventEmitter(client.baseUrl, projectId, client.token, opts.boardId, pipelineSessionId);
-    // Wire up OrchestratorDeps
-    const deps = {
-        fetchBoardScope: (boardId) => client.get(`/projects/${projectId}/pipeline-context`, { boardId }),
-        fetchColumnScope: (columnId) => client.get(`/projects/${projectId}/pipeline-context`, { columnId }),
-        startLoop: async (ticketId, columnId, config) => {
-            // Apply CLI overrides
-            const effectiveConfig = {
-                ...config,
-                ...(opts.maxIterations !== null && { maxIterations: opts.maxIterations }),
-                ...(opts.maxBudget !== null && { maxBudgetUsd: opts.maxBudget }),
-                ...(opts.model !== null && { model: opts.model }),
-            };
-            // Capture run memory ref before async work so closures below see the same instance
-            const mem = runMemory;
-            // Resolve column name once upfront so we can select the right MCP config.
-            // This also pre-warms cachedColumnName for onPostIterationGates below.
-            const colScopeForName = await client.get(`/projects/${projectId}/pipeline-context`, { columnId });
-            const resolvedColumnName = colScopeForName.column.name;
-            // Choose MCP config: gate-proxy variant when gates are configured for this column,
-            // global variant otherwise.
-            const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
-            const effectiveMcpConfigPath = columnGates.length > 0
-                ? generateGateProxyMcpConfig(client.baseUrl, client.token, opts.boardId, gateFilePath, columnId, resolvedColumnName, projectId)
-                : mcpConfigPath;
-            const loopDeps = {
-                fetchTicketContext: (tid) => client.get(`/projects/${projectId}/pipeline-context`, { ticketId: tid }),
-                fetchColumnContext: (cid) => client.get(`/projects/${projectId}/pipeline-context`, { columnId: cid }),
-                fetchFingerprint: (tid) => client.getFingerprint(projectId, tid),
-                invokeClaudeP,
-                mcpConfigPath: effectiveMcpConfigPath,
-                projectId,
-                log: (msg) => {
-                    logger.orchestrator(`[${ticketId}] ${msg}`);
-                },
-                // Run memory enrichment — inject accumulated discoveries into each iteration prompt
-                fetchRunMemoryContent: mem
-                    ? async () => {
-                        const content = await mem.getContent();
-                        const lines = content.split('\n');
-                        if (lines.length > 500) {
-                            return lines.slice(-500).join('\n');
-                        }
-                        return content;
-                    }
-                    : undefined,
-                // Lookahead enrichment — fetch next-column prompt doc so agent can anticipate exit criteria
-                fetchLookaheadDocument: effectiveConfig.lookaheadColumnId
-                    ? async () => {
-                        const colScope = await client.get(`/projects/${projectId}/pipeline-context`, { columnId: effectiveConfig.lookaheadColumnId });
-                        if (!colScope.prompt_document)
-                            return undefined;
-                        return { title: colScope.prompt_document.title, content: colScope.prompt_document.content };
-                    }
-                    : undefined,
-                // Pipeline event emission — forward stream/session events to WS for browser delivery
-                onStreamEvent: deps.emitPipelineEvent
-                    ? (event, context) => {
-                        deps.emitPipelineEvent({
-                            type: 'pipeline:stream',
-                            payload: {
-                                boardId: opts.boardId,
-                                ticketId: context.ticketId,
-                                columnId: context.columnId,
-                                runId: context.runId,
-                                sessionId: pipelineSessionId,
-                                event: event,
-                            },
-                        });
-                    }
-                    : undefined,
-                onSessionStart: deps.emitPipelineEvent
-                    ? (meta) => {
-                        deps.emitPipelineEvent({
-                            type: 'pipeline:session-start',
-                            payload: {
-                                boardId: opts.boardId,
-                                ticketId,
-                                columnId,
-                                runId: meta.runId,
-                                sessionId: pipelineSessionId,
-                                model: meta.model,
-                                invocationType: 'heavy',
-                                iteration: meta.iteration,
-                            },
-                        });
-                    }
-                    : undefined,
-                onSessionEnd: (meta) => {
-                    // Cost tracking — always active
-                    costTracker?.record({
-                        ticketId,
-                        columnId,
-                        model: effectiveConfig.model ?? 'default',
-                        tokensIn: meta.tokensIn,
-                        tokensOut: meta.tokensOut,
-                        type: 'heavy',
-                    });
-                    // Pipeline event emission — only when WS client is connected
-                    if (deps.emitPipelineEvent) {
-                        deps.emitPipelineEvent({
-                            type: 'pipeline:session-end',
-                            payload: {
-                                boardId: opts.boardId,
-                                runId: meta.runId,
-                                exitReason: null,
-                                tokensIn: meta.tokensIn,
-                                tokensOut: meta.tokensOut,
-                                toolCallCount: meta.toolCallCount,
-                                durationMs: meta.durationMs,
-                            },
-                        });
-                    }
-                },
-            };
-            // Wire checkpoint callback when setFieldValue is available
-            if (deps.setFieldValue) {
-                effectiveConfig.onCheckpoint = async (tid, checkpoint) => {
-                    try {
-                        await deps.setFieldValue(tid, 'loop_checkpoint', checkpoint);
-                    }
-                    catch {
-                        // Fire-and-forget
-                    }
-                };
-            }
-            // Wire stuck detection — invokes a lightweight LLM to classify trajectory mid-run
-            if (effectiveConfig.stuckDetection) {
-                effectiveConfig.invokeStuckDetection = async (input) => {
-                    const prompt = composeStuckDetectionPrompt(input);
-                    const { exitCode, output } = await invokeClaudeP(prompt, {
-                        mcpConfigPath,
-                        model: 'haiku',
-                        maxBudgetUsd: 0.01,
-                        tools: '',
-                        includeMcpConfig: false,
-                    });
-                    if (exitCode !== 0) {
-                        throw new Error(`Stuck detection call failed (exit ${String(exitCode)})`);
-                    }
-                    return parseStuckDetectionResponse(output);
-                };
-            }
-            // Wire post-iteration gate runner — runs all gates after each Claude invocation
-            // resolvedColumnName is already fetched above — no per-iteration API call needed.
-            effectiveConfig.onPostIterationGates = async (tid, iteration) => {
-                const gates = resolveGatesForColumn(gateConfig, resolvedColumnName);
-                if (gates.length === 0) {
-                    // No gates — return a synthetic all-pass snapshot
-                    return gateSnapshotStore.record(tid, iteration, []);
-                }
-                const runOpts = {};
-                if (gateConfig.settings?.cwd)
-                    runOpts.cwd = gateConfig.settings.cwd;
-                if (gateConfig.settings?.env)
-                    runOpts.env = gateConfig.settings.env;
-                if (gateConfig.settings?.total_timeout) {
-                    runOpts.totalTimeoutMs = parseTimeout(gateConfig.settings.total_timeout);
-                }
-                const results = await runGates(gates, runOpts);
-                return gateSnapshotStore.record(tid, iteration, results);
-            };
-            const loop = new RalphLoop(ticketId, columnId, effectiveConfig, loopDeps);
-            // Track active loops for graceful shutdown
-            activeRalphLoops.add(loop);
-            return loop.run().finally(() => {
-                activeRalphLoops.delete(loop);
-            });
-        },
-        createComment: (ticketId, body) => client.post(`/projects/${projectId}/tickets/${ticketId}/comments`, { body }),
-        createSignal: (ticketId, body) => client.post(`/projects/${projectId}/signals`, {
-            scopeType: 'ticket',
-            scopeId: ticketId,
-            content: body,
-        }),
-        createColumnSignal: (columnId, body) => client.post(`/projects/${projectId}/signals`, {
-            scopeType: 'column',
-            scopeId: columnId,
-            content: body,
-        }),
-        claimTicket: (ticketId) => client.claimTicket(projectId, ticketId),
-        fetchBlockedTickets: (ticketId) => client.get(`/projects/${projectId}/tickets/${ticketId}/blocked-tickets`),
-        hasUnresolvedBlockers: async (ticketId) => {
-            const blockers = await client.get(`/projects/${projectId}/tickets/${ticketId}/unresolved-blockers`);
-            return blockers.length > 0;
-        },
-        dispatchLightCall: async (ticketId, columnId) => {
-            // Fetch minimal context for light call (parallel)
-            const [ticketCtx, colScope, boardScope] = await Promise.all([
-                client.get(`/projects/${projectId}/pipeline-context`, { ticketId }),
-                client.get(`/projects/${projectId}/pipeline-context`, { columnId }),
-                client.get(`/projects/${projectId}/pipeline-context`, { boardId: opts.boardId }),
-            ]);
-            const lightCtx = {
-                ticketId,
-                ticketNumber: ticketCtx.ticket.ticket_number,
-                ticketTitle: ticketCtx.ticket.title,
-                ...(ticketCtx.ticket.description ? { ticketDescription: ticketCtx.ticket.description } : {}),
-                columnName: colScope.column.name,
-                fieldValues: ticketCtx.field_values,
-                toolPrefix: colScope.tool_prefix,
-                projectId,
-                ...(colScope.transition_rules ? { transitionRules: colScope.transition_rules } : {}),
-                ...(boardScope.columns && boardScope.columns.length > 0 && {
-                    availableColumns: boardScope.columns.map((col) => ({ id: col.id, name: col.name })),
-                }),
-            };
-            const prompt = composeLightPrompt(lightCtx);
-            logger.orchestrator(`[${ticketId}] Light call: composing prompt for column "${colScope.column.name}"`);
-            const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
-                mcpConfigPath,
-                model: 'haiku',
-                maxBudgetUsd: 0.01,
-                maxTurns: 3,
-                tools: '', // Strip all built-in tools
-                includeMcpConfig: false, // No MCP tools either
-            });
-            costTracker?.record({ ticketId, columnId, model: 'haiku', tokensIn, tokensOut, type: 'light' });
-            if (exitCode !== 0) {
-                throw new Error(`Light call exited with code ${exitCode}: ${output.slice(0, 200)}`);
-            }
-            const response = parseLightResponse(output);
-            logger.orchestrator(`[${ticketId}] Light call result: ${response.action} — ${response.reason}`);
-            return response;
-        },
-        // Advisor invocation — recovers from failure exits (stalled/error/max_iterations)
-        invokeAdvisor: async (input) => {
-            const prompt = composeAdvisorPrompt(input);
-            logger.orchestrator(`[${input.ticketId}] Advisor: invoking for ${input.exitReason}`);
-            const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
-                mcpConfigPath,
-                model: 'haiku',
-                maxBudgetUsd: 0.01,
-                tools: '',
-                includeMcpConfig: false,
-            });
-            costTracker?.record({ ticketId: input.ticketId, columnId: '', model: 'haiku', tokensIn, tokensOut, type: 'advisor' });
-            if (exitCode !== 0) {
-                throw new Error(`Advisor call exited with code ${exitCode}: ${output.slice(0, 200)}`);
-            }
-            const response = parseAdvisorResponse(output);
-            logger.orchestrator(`[${input.ticketId}] Advisor: ${response.action} — ${response.reason}`);
-            return response;
-        },
-        // Field value management — used for debt items, checkpoint writes, and escalation metadata
-        setFieldValue: async (ticketId, fieldName, value) => {
-            await client.put(`/projects/${projectId}/tickets/${ticketId}/field-values`, {
-                values: { [fieldName]: value },
-            });
-        },
-        getFieldValues: async (ticketId) => {
-            const ctx = await client.get(`/projects/${projectId}/pipeline-context`, { ticketId });
-            return ctx.field_values;
-        },
-        // Ticket management for advisor actions (ESCALATE, SPLIT_TICKET)
-        moveTicketToColumn: async (ticketId, columnId, handoff) => {
-            await client.patch(`/projects/${projectId}/tickets/${ticketId}/move`, {
-                column_id: columnId,
-                handoff,
-            });
-        },
-        createTickets: async (parentTicketId, specs) => {
-            const ids = [];
-            for (const spec of specs) {
-                const result = await client.post(`/projects/${projectId}/tickets`, { title: spec.title, description: spec.description, parent_id: parentTicketId });
-                ids.push(result.id);
-            }
-            return ids;
-        },
-        archiveTicket: async (ticketId) => {
-            await client.post(`/projects/${projectId}/tickets/${ticketId}/archive`, {});
-        },
-        // Run memory append — closure captures runMemory by reference (set after initialization)
-        appendRunMemory: (section, content) => runMemory ? runMemory.append(section, content) : Promise.resolve(),
-        cleanupWorktree: (name) => cleanupWorktree(name),
-        // Pipeline event emission — wsClient captured by reference (set later before any loops run)
-        emitPipelineEvent: (event) => {
-            wsClient?.send(event);
-        },
-        boardId: opts.boardId,
-        eventEmitter,
-        costTracker,
-        gateSnapshotStore,
-        invokeReplanner: async (state) => {
-            const prompt = composeReplannerPrompt(state);
-            const { exitCode, output, tokensIn, tokensOut } = await invokeClaudeP(prompt, {
-                mcpConfigPath,
-                model: 'haiku',
-                maxBudgetUsd: 0.01,
-                tools: '',
-                includeMcpConfig: false,
-            });
-            costTracker?.record({ ticketId: 'replanner', columnId: 'pipeline', model: 'haiku', tokensIn, tokensOut, type: 'orchestrator' });
-            if (exitCode !== 0)
-                throw new Error(`Replanner failed`);
-            return parseReplannerResponse(output);
-        },
-    };
-    // Create orchestrator
-    const orchestrator = new PipelineOrchestrator(opts.boardId, projectId, deps);
-    // Initialize — discovers pipeline columns
-    console.log(`Initializing pipeline for board ${opts.boardId}...`);
-    logger.orchestrator('Initializing pipeline');
-    try {
-        await orchestrator.initialize();
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: Failed to initialize pipeline: ${message}`);
-        console.error('Check that the board exists, has pipeline columns configured, and the API is reachable.');
-        cleanupMcpConfig(mcpConfigPath);
-        cleanupGateProxyConfigs(pidDir(opts.boardId));
-        process.exit(1);
-    }
-    const columnIds = orchestrator.pipelineColumnIds;
-    // Initialize run memory if any pipeline column has run_memory enabled
-    try {
-        for (const colId of columnIds) {
-            const colScope = await client.get(`/projects/${projectId}/pipeline-context`, { columnId: colId });
-            if (colScope.agent_config?.run_memory) {
-                // Fetch board name for the run memory document title
-                const boardScope = await client.get(`/projects/${projectId}/pipeline-context`, { boardId: opts.boardId });
-                // Resolve a space to store the run memory document — use first available space
-                const spaces = await client.get(`/projects/${projectId}/spaces`);
-                const spaceId = spaces[0]?.id;
-                if (!spaceId) {
-                    logger.orchestrator('Run memory: no spaces found in project — skipping run memory');
-                    console.warn('Warning: Run memory requires at least one document space in the project — skipping.');
-                    break;
-                }
-                runMemory = new RunMemory(opts.boardId, boardScope.board.name, {
-                    createDocument: async (content, title) => {
-                        const result = await client.post(`/projects/${projectId}/spaces/${spaceId}/documents`, { title, content });
-                        return result.id;
-                    },
-                    getDocument: async (docId) => {
-                        const doc = await client.get(`/projects/${projectId}/documents/${docId}`);
-                        return doc.content;
-                    },
-                    updateDocument: async (docId, content) => {
-                        await client.patch(`/projects/${projectId}/documents/${docId}`, { content });
-                    },
-                });
-                await runMemory.initialize();
-                logger.orchestrator(`Run memory initialized (doc=${runMemory.documentId ?? 'none'})`);
-                console.log(`Run memory enabled (document: ${runMemory.documentId ?? 'none'})`);
-                break;
-            }
-        }
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.orchestrator(`Run memory init failed (non-fatal): ${msg}`);
-        console.error(`Warning: Run memory initialization failed: ${msg}`);
-    }
-    if (columnIds.length === 0) {
-        console.log('No pipeline columns found (columns need has_prompt=true and type !== "done").');
-        cleanupMcpConfig(mcpConfigPath);
-        cleanupGateProxyConfigs(pidDir(opts.boardId));
-        return;
-    }
-    console.log(`Discovered ${String(columnIds.length)} pipeline column(s).`);
-    logger.orchestrator(`Discovered ${String(columnIds.length)} pipeline columns: ${columnIds.join(', ')}`);
-    // Dry-run: print config summary and exit
-    if (opts.dryRun) {
-        console.log('\n--- Dry Run Configuration ---');
-        console.log(`Board ID:       ${opts.boardId}`);
-        console.log(`Project ID:     ${projectId}`);
-        console.log(`Pipeline cols:  ${String(columnIds.length)}`);
-        console.log(`Column filter:  ${opts.columnFilter ?? '(none)'}`);
-        console.log(`Max iterations: ${opts.maxIterations !== null ? String(opts.maxIterations) : '(per-column default)'}`);
-        console.log(`Max budget:     ${opts.maxBudget !== null ? `$${String(opts.maxBudget)}` : '(per-column default)'}`);
-        console.log(`Model:          ${opts.model ?? '(per-column default)'}`);
-        console.log(`Concurrency:    ${opts.concurrency !== null ? String(opts.concurrency) : '(per-column default)'}`);
-        console.log(`Mode:           ${opts.once ? 'once' : 'persistent'}`);
-        console.log(`Log retention:  ${String(opts.logRetention)} days`);
-        console.log(`MCP config:     ${mcpConfigPath}`);
-        console.log('\n[Dry run -- no agents started]');
-        cleanupMcpConfig(mcpConfigPath);
-        cleanupGateProxyConfigs(pidDir(opts.boardId));
-        return;
-    }
-    // --- Live mode ---
-    // Set up graceful shutdown
-    let shutdownInProgress = false;
-    const shutdown = async (signal) => {
-        if (shutdownInProgress)
-            return;
-        shutdownInProgress = true;
-        console.log(`\nReceived ${signal}. Shutting down gracefully...`);
-        logger.orchestrator(`Shutdown initiated (${signal})`);
-        if (rescanTimer)
-            clearInterval(rescanTimer);
-        eventQueue?.stop();
-        // Notify browser clients that the pipeline is stopping (before closing WS)
-        wsClient?.send({ type: 'pipeline:stopped', payload: { boardId: opts.boardId } });
-        // Give the WS a moment to flush the stop notification
-        await new Promise(r => setTimeout(r, 200));
-        await eventEmitter.close();
-        wsClient?.stop();
-        for (const loop of activeRalphLoops) {
-            loop.stop();
-        }
-        killAllChildProcesses();
-        // Wait for children to actually exit (up to 5 seconds)
-        const deadline = Date.now() + 5000;
-        while (activeChildProcesses.size > 0 && Date.now() < deadline) {
-            await new Promise(r => setTimeout(r, 200));
-        }
-        if (activeChildProcesses.size > 0) {
-            console.error(`Warning: ${String(activeChildProcesses.size)} child process(es) did not exit. Sending SIGKILL...`);
-            for (const child of activeChildProcesses) {
-                try {
-                    if (child.pid) {
-                        try {
-                            process.kill(-child.pid, 'SIGKILL');
-                        }
-                        catch {
-                            try {
-                                child.kill('SIGKILL');
-                            }
-                            catch { /* already dead */ }
-                        }
-                    }
-                    else {
-                        try {
-                            child.kill('SIGKILL');
-                        }
-                        catch { /* already dead */ }
-                    }
-                }
-                catch {
-                    // Process already exited
-                }
-            }
-        }
-        // Print cost report
-        if (costTracker) {
-            console.log('\n--- Pipeline Cost Report ---');
-            console.log(costTracker.generateReport(gateConfig.settings?.pricing));
-        }
-        cleanupMcpConfig(mcpConfigPath);
-        cleanupGateProxyConfigs(pidDir(opts.boardId));
-        killReaper(reaperPidPath);
-        removePidFile(opts.boardId);
-        removeChildManifest(opts.boardId);
-        logger.orchestrator('Shutdown complete');
-        console.log('Pipeline stopped.');
-        process.exit(0);
-    };
-    process.on('SIGTERM', () => {
-        shutdown('SIGTERM').catch((err) => {
-            console.error('Error during shutdown:', err);
-            process.exit(1);
-        });
-    });
-    process.on('SIGINT', () => {
-        shutdown('SIGINT').catch((err) => {
-            console.error('Error during shutdown:', err);
-            process.exit(1);
-        });
-    });
-    process.on('SIGHUP', () => {
-        shutdown('SIGHUP').catch((err) => {
-            console.error('Error during shutdown:', err);
-            process.exit(1);
-        });
-    });
-    // Clean up orphaned processes from a previous run before starting
-    cleanupOrphanedProcesses(opts.boardId);
-    // Write PID file
-    writePidFile(opts.boardId);
-    logger.orchestrator(`PID file written: ${String(process.pid)}`);
-    // Spawn watchdog reaper — kills children if orchestrator dies unexpectedly
-    const reaperPidPath = join(pidDir(opts.boardId), 'reaper.pid');
-    const reaperProcess = spawnReaper({
-        orchestratorPid: process.pid,
-        manifestPath: childManifestPath(opts.boardId),
-        pidFilePath: pidFilePath(opts.boardId),
-        reaperPidPath,
-        mcpConfigPath,
-        pipelineDir: pidDir(opts.boardId),
-    });
-    logger.orchestrator(`Watchdog reaper spawned (PID ${String(reaperProcess.pid ?? 'unknown')})`);
-    // Set up event queue and WS client
-    let eventQueue = null;
-    let wsClient = null;
-    let rescanTimer = null;
-    const onEventError = (event, err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.orchestrator(`Event handler error for ${event.type} ticket=${event.ticketId}: ${msg}`);
-        console.error(`Event handler error: ${msg}`);
-    };
-    eventQueue = new EventQueue((event) => orchestrator.handleEvent(event), {
-        drainRateMs: 100,
-        onError: onEventError,
-    });
-    wsClient = new PipelineWsClient(client, {
-        boardId: opts.boardId,
-        projectId,
-        onEvent: (wsEvent) => {
-            // Map WS events to pipeline events
-            const payload = wsEvent.payload;
-            // ticket:moved and ticket:created nest the id inside payload.ticket
-            // ticket:deleted and ticket:archived have payload.ticketId directly
-            const ticket = payload['ticket'];
-            const ticketId = (typeof payload['ticketId'] === 'string' ? payload['ticketId'] : null) ??
-                (ticket && typeof ticket['id'] === 'string' ? ticket['id'] : null);
-            // ticket:created has payload.columnId; ticket:moved has the new column in ticket.column_id
-            const columnId = (typeof payload['columnId'] === 'string' ? payload['columnId'] : null) ??
-                (ticket && typeof ticket['column_id'] === 'string' ? ticket['column_id'] : null);
-            // Handle firing constraint changes — refresh constraint caches
-            if (wsEvent.type === 'firing_constraint:created' ||
-                wsEvent.type === 'firing_constraint:updated' ||
-                wsEvent.type === 'firing_constraint:deleted') {
-                logger.orchestrator(`WS event: ${wsEvent.type} — refreshing constraint caches`);
-                void orchestrator.refreshConstraints().catch((err) => {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    logger.orchestrator(`Constraint cache refresh failed: ${msg}`);
-                });
-                return;
-            }
-            if (!ticketId)
-                return;
-            const eventType = wsEvent.type;
-            if (eventType === 'ticket:created' ||
-                eventType === 'ticket:moved' ||
-                eventType === 'ticket:updated' ||
-                eventType === 'ticket:archived' ||
-                eventType === 'ticket:deleted') {
-                const pipelineEvent = { type: eventType, ticketId, columnId };
-                eventQueue.push(pipelineEvent);
-                logger.orchestrator(`WS event: ${eventType} ticket=${ticketId} column=${columnId ?? 'null'}`);
-            }
-        },
-        onConnect: () => {
-            console.log('WebSocket connected. Listening for board events...');
-            logger.orchestrator('WebSocket connected');
-        },
-        onDisconnect: () => {
-            logger.orchestrator('WebSocket disconnected');
-        },
-    });
-    // Try initial WS connection (non-fatal)
-    try {
-        await wsClient.connect();
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Warning: WebSocket connection failed: ${message}`);
-        console.error('Pipeline will poll for changes and retry WS periodically.');
-        logger.orchestrator(`WebSocket connection failed: ${message}`);
-    }
-    // Start event queue
-    eventQueue.start();
-    // Initial scan and spawn
-    console.log('Scanning pipeline columns for tickets...');
-    logger.orchestrator('Starting scan and spawn');
-    try {
-        await orchestrator.scanAndSpawn();
-        logger.orchestrator(`Scan complete. Active loops: ${String(orchestrator.activeLoopCount)}`);
-        console.log(`Scan complete. Active loops: ${String(orchestrator.activeLoopCount)}`);
-    }
-    catch (scanErr) {
-        const scanMsg = scanErr instanceof Error ? scanErr.message : String(scanErr);
-        logger.orchestrator(`Scan error: ${scanMsg}`);
-        console.error(`Scan error: ${scanMsg}`);
-    }
-    if (opts.once) {
-        // Wait for all active loops to complete, then exit
-        console.log('Running in --once mode. Waiting for all loops to complete...');
-        logger.orchestrator('Once mode: waiting for loops to complete');
-        // Poll until no active loops or queued work remain
-        await waitForAllLoops(orchestrator);
-        // Print cost report
-        if (costTracker) {
-            console.log('\n--- Pipeline Cost Report ---');
-            console.log(costTracker.generateReport(gateConfig.settings?.pricing));
-        }
-        // Notify browser clients that the pipeline has finished
-        wsClient.send({ type: 'pipeline:stopped', payload: { boardId: opts.boardId } });
-        await new Promise(r => setTimeout(r, 200));
-        // Cleanup
-        await eventEmitter.close();
-        wsClient.stop();
-        eventQueue.stop();
-        cleanupMcpConfig(mcpConfigPath);
-        cleanupGateProxyConfigs(pidDir(opts.boardId));
-        killReaper(reaperPidPath);
-        removePidFile(opts.boardId);
-        removeChildManifest(opts.boardId);
-        logger.orchestrator('Once mode complete. Exiting.');
-        console.log('All loops complete. Pipeline exiting.');
-    }
-    else {
-        // Persistent mode — unified poll loop: rescan columns and try to
-        // reconnect WS if disconnected.  This replaces the separate polling
-        // fallback and rescan timer with a single 30s heartbeat.
-        let consecutiveScanFailures = 0;
-        rescanTimer = setInterval(() => {
-            void (async () => {
-                try {
-                    await orchestrator.scanAndSpawn();
-                    if (consecutiveScanFailures > 0) {
-                        console.log(`Rescan recovered after ${String(consecutiveScanFailures)} failure(s)`);
-                    }
-                    consecutiveScanFailures = 0;
-                }
-                catch (err) {
-                    consecutiveScanFailures++;
-                    const msg = err instanceof Error ? err.message : String(err);
-                    logger.orchestrator(`Periodic rescan error (${String(consecutiveScanFailures)}x): ${msg}`);
-                    if (consecutiveScanFailures === 1 || consecutiveScanFailures % 10 === 0) {
-                        console.error(`Warning: Rescan has failed ${String(consecutiveScanFailures)} consecutive time(s): ${msg}`);
-                    }
-                }
-                if (wsClient && !wsClient.connected) {
-                    const reconnected = await wsClient.tryReconnect();
-                    if (reconnected) {
-                        logger.orchestrator('WS reconnected via poll cycle');
-                    }
-                }
-            })();
-        }, 30_000);
-        console.log(`Pipeline running (PID ${String(process.pid)}). Use 'kantban pipeline stop ${opts.boardId}' to stop.`);
-        logger.orchestrator('Pipeline running in persistent mode');
-    }
-}
-// ---------------------------------------------------------------------------
-// Active loop tracking for graceful shutdown
-// ---------------------------------------------------------------------------
-const activeRalphLoops = new Set();
-async function waitForAllLoops(orchestrator, timeoutMs = 4 * 60 * 60 * 1000) {
-    let consecutiveIdle = 0;
-    const startTime = Date.now();
-    let lastProgressLog = 0;
-    while (consecutiveIdle < 2) {
-        if (Date.now() - startTime > timeoutMs) {
-            console.error(`Warning: waitForAllLoops timed out after ${String(Math.round(timeoutMs / 60_000))}m. ` +
-                `Active: ${String(activeRalphLoops.size)}, orchestrator: ${String(orchestrator.activeLoopCount)}, ` +
-                `queued: ${String(orchestrator.hasQueuedWork)}`);
-            return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        if (activeRalphLoops.size === 0 && orchestrator.activeLoopCount === 0 && !orchestrator.hasActiveQueuedWork) {
-            consecutiveIdle++;
-        }
-        else {
-            consecutiveIdle = 0;
-            const now = Date.now();
-            if (now - lastProgressLog > 30_000) {
-                lastProgressLog = now;
-                console.log(`Waiting... Active loops: ${String(activeRalphLoops.size)}, ` +
-                    `queued work: ${String(orchestrator.hasQueuedWork)}`);
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// stopPipeline — sends SIGTERM to a running pipeline
-// ---------------------------------------------------------------------------
-export async function stopPipeline(args) {
-    const boardId = args[0];
-    if (!boardId) {
-        console.error('Usage: kantban pipeline stop <board-id>');
-        process.exit(1);
-    }
-    const pidFile = pidFilePath(boardId);
-    let pid;
-    try {
-        const content = readFileSync(pidFile, 'utf8').trim();
-        pid = Number(content);
-        if (isNaN(pid) || pid <= 0) {
-            throw new Error('Invalid PID');
-        }
-    }
-    catch {
-        console.error(`No running pipeline found for board ${boardId}.`);
-        console.error(`Expected PID file at: ${pidFile}`);
-        process.exit(1);
-        return; // unreachable, but helps TS
-    }
-    try {
-        // Kill the entire process group to take down child claude -p processes too
-        try {
-            process.kill(-pid, 'SIGTERM');
-            console.log(`Sent SIGTERM to pipeline process group (pgid ${String(pid)}) for board ${boardId}.`);
-        }
-        catch {
-            // Process group kill failed (not a group leader) — fall back to direct kill
-            process.kill(pid, 'SIGTERM');
-            console.log(`Sent SIGTERM to pipeline process ${String(pid)} for board ${boardId}.`);
-        }
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Failed to stop pipeline (PID ${String(pid)}): ${message}`);
-        console.error('The process may have already exited. Removing stale PID file.');
-        removePidFile(boardId);
-        process.exit(1);
-    }
-}
-//# sourceMappingURL=pipeline.js.map