@cluesmith/codev 1.6.1 → 2.0.0-rc.1

package/dist/commands/porch/index.js

@@ -0,0 +1,828 @@
+/**
+ * Porch - Protocol Orchestrator
+ *
+ * Generic loop orchestrator that reads protocol definitions from JSON
+ * and executes them with Claude. Implements the Ralph pattern: fresh
+ * context per iteration with state persisted to files.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { findProjectRoot, getSkeletonDir } from '../../lib/skeleton.js';
+import { getProjectDir, readState, writeState, createInitialState, updateState, approveGate, requestGateApproval, updatePhaseStatus, setPlanPhases, findProjects, findExecutions, findStatusFile, findPendingGates, getConsultationAttempts, incrementConsultationAttempts, resetConsultationAttempts, } from './state.js';
+import { extractPhasesFromPlanFile, findPlanFile, } from './plan-parser.js';
+import { extractSignal } from './signal-parser.js';
+import { runPhaseChecks, formatCheckResults } from './checks.js';
+import { runConsultationLoop, formatConsultationResults, hasConsultation, } from './consultation.js';
+import { loadProtocol as loadProtocolFromLoader, listProtocols as listProtocolsFromLoader, } from './protocol-loader.js';
+import { createNotifier, } from './notifications.js';
+// ============================================================================
+// Protocol Loading (delegates to protocol-loader.ts)
+// ============================================================================
+/**
+ * List available protocols
+ * Delegates to protocol-loader.ts for proper conversion
+ */
+export function listProtocols(projectRoot) {
+    const root = projectRoot || findProjectRoot();
+    return listProtocolsFromLoader(root);
+}
+/**
+ * Load a protocol definition
+ * Delegates to protocol-loader.ts which properly converts steps→substates
+ */
+export function loadProtocol(name, projectRoot) {
+    const root = projectRoot || findProjectRoot();
+    const protocol = loadProtocolFromLoader(root, name);
+    if (!protocol) {
+        throw new Error(`Protocol not found: ${name}\nAvailable protocols: ${listProtocols(root).join(', ')}`);
+    }
+    return protocol;
+}
+/**
+ * Load a prompt file for a phase
+ */
+function loadPrompt(protocol, phaseId, projectRoot) {
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    if (!phase?.prompt) {
+        return null;
+    }
+    // New structure: protocols/<protocol>/prompts/<prompt>.md
+    const promptPaths = [
+        path.join(projectRoot, 'codev', 'protocols', protocol.name, 'prompts', phase.prompt),
+        path.join(getSkeletonDir(), 'protocols', protocol.name, 'prompts', phase.prompt),
+        // Legacy paths
+        path.join(projectRoot, 'codev', 'porch', 'prompts', phase.prompt),
+        path.join(getSkeletonDir(), 'porch', 'prompts', phase.prompt),
+    ];
+    for (const promptPath of promptPaths) {
+        if (fs.existsSync(promptPath)) {
+            return fs.readFileSync(promptPath, 'utf-8');
+        }
+        // Try with .md extension
+        if (fs.existsSync(`${promptPath}.md`)) {
+            return fs.readFileSync(`${promptPath}.md`, 'utf-8');
+        }
+    }
+    return null;
+}
+// ============================================================================
+// Protocol Helpers
+// ============================================================================
+/**
+ * Check if a phase is terminal
+ */
+function isTerminalPhase(protocol, phaseId) {
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    return phase?.terminal === true;
+}
+/**
+ * Find the phase that has a gate blocking after the given state
+ */
+function getGateForState(protocol, state) {
+    const [phaseId, substate] = state.split(':');
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    if (phase?.gate && phase.gate.after === substate) {
+        const gateId = `${phaseId}_approval`;
+        return { gateId, phase };
+    }
+    return null;
+}
+/**
+ * Get next state after gate passes
+ */
+function getGateNextState(protocol, phaseId) {
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    return phase?.gate?.next || null;
+}
+/**
+ * Get signal-based next state
+ */
+function getSignalNextState(protocol, phaseId, signal) {
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    return phase?.signals?.[signal] || null;
+}
+/**
+ * Get the default next state for a phase (first substate or next phase)
+ */
+function getDefaultNextState(protocol, state) {
+    const [phaseId, substate] = state.split(':');
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    if (!phase)
+        return null;
+    // If phase has substates, move to next substate
+    if (phase.substates && substate) {
+        const currentIdx = phase.substates.indexOf(substate);
+        if (currentIdx >= 0 && currentIdx < phase.substates.length - 1) {
+            return `${phaseId}:${phase.substates[currentIdx + 1]}`;
+        }
+    }
+    // Move to next phase
+    const phaseIdx = protocol.phases.findIndex(p => p.id === phaseId);
+    if (phaseIdx >= 0 && phaseIdx < protocol.phases.length - 1) {
+        const nextPhase = protocol.phases[phaseIdx + 1];
+        if (nextPhase.substates && nextPhase.substates.length > 0) {
+            return `${nextPhase.id}:${nextPhase.substates[0]}`;
+        }
+        return nextPhase.id;
+    }
+    return null;
+}
+// ============================================================================
+// Claude Invocation
+// ============================================================================
+// Note: extractSignal is now imported from signal-parser.js
+/**
+ * Invoke Claude for a phase
+ */
+async function invokeClaude(protocol, phaseId, state, statusFilePath, projectRoot, options) {
+    const promptContent = loadPrompt(protocol, phaseId, projectRoot);
+    if (!promptContent) {
+        console.log(chalk.yellow(`[porch] No prompt file for phase: ${phaseId}`));
+        return '';
+    }
+    if (options.dryRun) {
+        console.log(chalk.yellow(`[porch] [DRY RUN] Would invoke Claude for phase: ${phaseId}`));
+        return '';
+    }
+    if (options.noClaude) {
+        console.log(chalk.blue(`[porch] [NO_CLAUDE] Simulating phase: ${phaseId}`));
+        await new Promise(r => setTimeout(r, 1000));
+        console.log(chalk.green(`[porch] Simulated completion of phase: ${phaseId}`));
+        return '';
+    }
+    console.log(chalk.cyan(`[phase] Invoking Claude for phase: ${phaseId}`));
+    const timeout = protocol.config?.claude_timeout || 600000; // 10 minutes default
+    const fullPrompt = `## Protocol: ${protocol.name}
+## Phase: ${phaseId}
+## Project ID: ${state.id}
+
+## Current Status
+\`\`\`yaml
+state: "${state.current_state}"
+iteration: ${state.iteration}
+started_at: "${state.started_at}"
+\`\`\`
+
+## Task
+Execute the ${phaseId} phase for project ${state.id} - ${state.title}
+
+## Phase Instructions
+${promptContent}
+
+## Important
+- Project ID: ${state.id}
+- Protocol: ${protocol.name}
+- Follow the instructions above precisely
+- Output <signal>...</signal> tags when you reach completion points
+`;
+    return new Promise((resolve, reject) => {
+        const args = ['--print', '-p', fullPrompt, '--dangerously-skip-permissions'];
+        const proc = spawn('claude', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout,
+        });
+        let output = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            output += data.toString();
+            process.stdout.write(data);
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+            process.stderr.write(data);
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Claude exited with code ${code}\n${stderr}`));
+            }
+            else {
+                resolve(output);
+            }
+        });
+        proc.on('error', reject);
+    });
+}
+// ============================================================================
+// Commands
+// ============================================================================
+/**
+ * Initialize a new project with a protocol
+ */
+export async function init(protocolName, projectId, projectName, options = {}) {
+    const projectRoot = findProjectRoot();
+    const protocol = loadProtocol(protocolName, projectRoot);
+    // Create project directory
+    const projectDir = getProjectDir(projectRoot, projectId, projectName);
+    fs.mkdirSync(projectDir, { recursive: true });
+    // Create initial state
+    const state = createInitialState(protocol, projectId, projectName, options.worktree);
+    const statusPath = path.join(projectDir, 'status.yaml');
+    await writeState(statusPath, state);
+    console.log(chalk.green(`[porch] Initialized project ${projectId} with protocol ${protocolName}`));
+    console.log(chalk.blue(`[porch] Project directory: ${projectDir}`));
+    console.log(chalk.blue(`[porch] Initial state: ${state.current_state}`));
+}
+/**
+ * Check if a protocol phase is a "phased" phase (runs per plan-phase)
+ */
+function isPhasedPhase(protocol, phaseId) {
+    const phase = protocol.phases.find(p => p.id === phaseId);
+    return phase?.phased === true;
+}
+/**
+ * Get the IDE phases (implement, defend, evaluate) that run per plan-phase
+ */
+function getIDEPhases(protocol) {
+    return protocol.phases
+        .filter(p => p.phased === true)
+        .map(p => p.id);
+}
+/**
+ * Parse the current plan-phase from state like "implement:phase_1"
+ */
+function parsePlanPhaseFromState(state) {
+    const parts = state.split(':');
+    const phaseId = parts[0];
+    // Check if second part is a plan phase (phase_N) or a substate
+    if (parts.length > 1) {
+        if (parts[1].startsWith('phase_')) {
+            return { phaseId, planPhaseId: parts[1], substate: parts[2] || null };
+        }
+        return { phaseId, planPhaseId: null, substate: parts[1] };
+    }
+    return { phaseId, planPhaseId: null, substate: null };
+}
+/**
+ * Get the next IDE state for a phased phase
+ * implement:phase_1 → defend:phase_1 → evaluate:phase_1 → implement:phase_2 → ...
+ */
+function getNextIDEState(protocol, currentState, planPhases, signal) {
+    const { phaseId, planPhaseId } = parsePlanPhaseFromState(currentState);
+    if (!planPhaseId)
+        return null;
+    const idePhases = getIDEPhases(protocol);
+    const currentIdeIndex = idePhases.indexOf(phaseId);
+    if (currentIdeIndex < 0)
+        return null;
+    // If not at the end of IDE phases, move to next IDE phase for same plan-phase
+    if (currentIdeIndex < idePhases.length - 1) {
+        return `${idePhases[currentIdeIndex + 1]}:${planPhaseId}`;
+    }
+    // At end of IDE phases (evaluate), move to next plan-phase
+    const currentPlanIndex = planPhases.findIndex(p => p.id === planPhaseId);
+    if (currentPlanIndex < 0)
+        return null;
+    // Check if there's a next plan phase
+    if (currentPlanIndex < planPhases.length - 1) {
+        const nextPlanPhase = planPhases[currentPlanIndex + 1];
+        return `${idePhases[0]}:${nextPlanPhase.id}`; // Start implement for next phase
+    }
+    // All plan phases complete, move to review
+    const reviewPhase = protocol.phases.find(p => p.id === 'review');
+    if (reviewPhase) {
+        return 'review';
+    }
+    return 'complete';
+}
+/**
+ * Run the protocol loop for a project
+ */
+export async function run(projectId, options = {}) {
+    const projectRoot = findProjectRoot();
+    // Find status file
+    const statusFilePath = findStatusFile(projectRoot, projectId);
+    if (!statusFilePath) {
+        throw new Error(`Status file not found for project: ${projectId}\n` +
+            `Run: porch init <protocol> ${projectId} <project-name>`);
+    }
+    // Read state and load protocol
+    const state = readState(statusFilePath);
+    if (!state) {
+        throw new Error(`Could not read state from: ${statusFilePath}`);
+    }
+    const protocol = loadProtocol(state.protocol, projectRoot);
+    const pollInterval = options.pollInterval || protocol.config?.poll_interval || 30;
+    const maxIterations = protocol.config?.max_iterations || 100;
+    // Create notifier for this project (desktop notifications for important events)
+    const notifier = createNotifier(projectId, { desktop: true });
+    console.log(chalk.blue(`[porch] Starting ${state.protocol} loop for project ${projectId}`));
+    console.log(chalk.blue(`[porch] Status file: ${statusFilePath}`));
+    console.log(chalk.blue(`[porch] Poll interval: ${pollInterval}s`));
+    let currentState = state;
+    // Extract plan phases if not already done and we're past planning
+    if (!currentState.plan_phases || currentState.plan_phases.length === 0) {
+        const planFile = findPlanFile(projectRoot, projectId, currentState.title);
+        if (planFile) {
+            try {
+                const planPhases = extractPhasesFromPlanFile(planFile);
+                currentState = setPlanPhases(currentState, planPhases);
+                await writeState(statusFilePath, currentState);
+                console.log(chalk.blue(`[porch] Extracted ${planPhases.length} phases from plan`));
+                for (const phase of planPhases) {
+                    console.log(chalk.blue(`  - ${phase.id}: ${phase.title}`));
+                }
+            }
+            catch (e) {
+                console.log(chalk.yellow(`[porch] Could not extract plan phases: ${e}`));
+            }
+        }
+    }
+    for (let iteration = currentState.iteration; iteration <= maxIterations; iteration++) {
+        console.log(chalk.blue('━'.repeat(40)));
+        console.log(chalk.blue(`[porch] Iteration ${iteration}`));
+        console.log(chalk.blue('━'.repeat(40)));
+        // Fresh read of state each iteration (Ralph pattern)
+        currentState = readState(statusFilePath) || currentState;
+        console.log(chalk.blue(`[porch] Current state: ${currentState.current_state}`));
+        // Parse state into phase and substate
+        const { phaseId, planPhaseId, substate } = parsePlanPhaseFromState(currentState.current_state);
+        // Re-attempt plan phase extraction if entering a phased phase without plan phases
+        // This handles the case where porch started during Specify phase (no plan file yet)
+        if (isPhasedPhase(protocol, phaseId) && (!currentState.plan_phases || currentState.plan_phases.length === 0)) {
+            const planFile = findPlanFile(projectRoot, projectId, currentState.title);
+            if (planFile) {
+                try {
+                    const planPhases = extractPhasesFromPlanFile(planFile);
+                    currentState = setPlanPhases(currentState, planPhases);
+                    await writeState(statusFilePath, currentState);
+                    console.log(chalk.blue(`[porch] Late discovery: Extracted ${planPhases.length} phases from plan`));
+                    for (const phase of planPhases) {
+                        console.log(chalk.blue(`  - ${phase.id}: ${phase.title}`));
+                    }
+                }
+                catch (e) {
+                    console.log(chalk.yellow(`[porch] Could not extract plan phases: ${e}`));
+                }
+            }
+            else {
+                console.log(chalk.yellow(`[porch] Warning: Entering phased phase '${phaseId}' but no plan file found`));
+            }
+        }
+        // Check if terminal phase
+        if (isTerminalPhase(protocol, phaseId)) {
+            console.log(chalk.green('━'.repeat(40)));
+            console.log(chalk.green(`[porch] ${state.protocol} loop COMPLETE`));
+            console.log(chalk.green(`[porch] Project ${projectId} finished all phases`));
+            console.log(chalk.green('━'.repeat(40)));
+            return;
+        }
+        // Check if there's a pending gate from a previous iteration (step already executed)
+        const pendingGateInfo = getGateForState(protocol, currentState.current_state);
+        if (pendingGateInfo) {
+            const { gateId } = pendingGateInfo;
+            // Check if gate is already approved
+            if (currentState.gates[gateId]?.status === 'passed') {
+                // Gate approved - proceed to next state
+                const nextState = getGateNextState(protocol, phaseId);
+                if (nextState) {
+                    console.log(chalk.green(`[porch] Gate ${gateId} passed! Proceeding to ${nextState}`));
+                    await notifier.gateApproved(gateId);
+                    // Reset any consultation attempts for the gated state
+                    currentState = resetConsultationAttempts(currentState, currentState.current_state);
+                    // If entering a phased phase, start with first plan phase
+                    if (isPhasedPhase(protocol, nextState.split(':')[0]) && currentState.plan_phases?.length) {
+                        const firstPlanPhase = currentState.plan_phases[0];
+                        currentState = updateState(currentState, `${nextState.split(':')[0]}:${firstPlanPhase.id}`);
+                        currentState = updatePhaseStatus(currentState, firstPlanPhase.id, 'in_progress');
+                    }
+                    else {
+                        currentState = updateState(currentState, nextState);
+                    }
+                    await writeState(statusFilePath, currentState);
+                    continue; // Start next iteration with new state
+                }
+            }
+            else if (currentState.gates[gateId]?.requested_at) {
+                // Gate requested but not approved - wait
+                console.log(chalk.cyan(`[phase] Phase: ${phaseId} (waiting for gate: ${gateId})`));
+                console.log(chalk.yellow(`[porch] BLOCKED - Waiting for gate: ${gateId}`));
+                console.log(chalk.yellow(`[porch] To approve: porch approve ${projectId} ${gateId}`));
+                await new Promise(r => setTimeout(r, pollInterval * 1000));
+                continue;
+            }
+            // If gate not yet requested, fall through to execute phase first
+        }
+        // Get the current phase definition
+        const phase = protocol.phases.find(p => p.id === phaseId);
+        // Show plan phase context if in a phased phase
+        if (planPhaseId && currentState.plan_phases) {
+            const planPhase = currentState.plan_phases.find(p => p.id === planPhaseId);
+            if (planPhase) {
+                console.log(chalk.cyan(`[phase] IDE Phase: ${phaseId} | Plan Phase: ${planPhase.title}`));
+            }
+            else {
+                console.log(chalk.cyan(`[phase] Phase: ${phaseId}`));
+            }
+        }
+        else {
+            console.log(chalk.cyan(`[phase] Phase: ${phaseId}`));
+        }
+        // Notify phase start
+        await notifier.phaseStart(phaseId);
+        // Execute phase
+        const output = await invokeClaude(protocol, phaseId, currentState, statusFilePath, projectRoot, options);
+        const signal = extractSignal(output);
+        // Run phase checks (build/test) if defined
+        if (phase?.checks && !options.dryRun) {
+            console.log(chalk.blue(`[porch] Running checks for phase ${phaseId}...`));
+            const checkResult = await runPhaseChecks(phase, {
+                cwd: projectRoot,
+                dryRun: options.dryRun,
+            });
+            console.log(formatCheckResults(checkResult));
+            if (!checkResult.success) {
+                // Notify about check failure
+                const failedCheck = checkResult.checks.find(c => !c.success);
+                await notifier.checkFailed(phaseId, failedCheck?.name || 'build/test', failedCheck?.error || 'Check failed');
+                // If checks fail, handle based on check configuration
+                if (checkResult.returnTo) {
+                    console.log(chalk.yellow(`[porch] Checks failed, returning to ${checkResult.returnTo}`));
+                    if (planPhaseId) {
+                        currentState = updateState(currentState, `${checkResult.returnTo}:${planPhaseId}`);
+                    }
+                    else {
+                        currentState = updateState(currentState, checkResult.returnTo);
+                    }
+                    await writeState(statusFilePath, currentState);
+                    continue;
+                }
+                // No returnTo means we should retry (already handled in checks)
+            }
+        }
+        // Run consultation if configured for this phase/substate
+        if (phase?.consultation && hasConsultation(phase) && !options.dryRun && !options.noClaude) {
+            const consultConfig = phase.consultation;
+            const currentSubstate = substate || parsePlanPhaseFromState(currentState.current_state).substate;
+            // Check if consultation is triggered by current substate
+            if (consultConfig.on === currentSubstate || consultConfig.on === phaseId) {
+                const maxRounds = consultConfig.max_rounds || 3;
+                const stateKey = currentState.current_state;
+                // Get attempt count from state (persisted across porch iterations)
+                const attemptCount = getConsultationAttempts(currentState, stateKey) + 1;
+                console.log(chalk.blue(`[porch] Consultation triggered for phase ${phaseId} (attempt ${attemptCount}/${maxRounds})`));
+                await notifier.consultationStart(phaseId, consultConfig.models || ['gemini', 'codex', 'claude']);
+                const consultResult = await runConsultationLoop(consultConfig, {
+                    subcommand: consultConfig.type.includes('pr') ? 'pr' : consultConfig.type.includes('spec') ? 'spec' : 'plan',
+                    identifier: projectId,
+                    cwd: projectRoot,
+                    timeout: protocol.config?.consultation_timeout,
+                    dryRun: options.dryRun,
+                });
+                console.log(formatConsultationResults(consultResult));
+                await notifier.consultationComplete(phaseId, consultResult.feedback, consultResult.allApproved);
+                // If not all approved, track attempt and check for escalation
+                if (!consultResult.allApproved) {
+                    // Increment attempt count in state (persists across iterations)
+                    currentState = incrementConsultationAttempts(currentState, stateKey);
+                    await writeState(statusFilePath, currentState);
+                    // Check if we've reached max attempts
+                    if (attemptCount >= maxRounds) {
+                        // Create escalation gate - requires human intervention
+                        const escalationGateId = `${phaseId}_consultation_escalation`;
+                        // Check if escalation gate was already approved (human override)
+                        if (currentState.gates[escalationGateId]?.status === 'passed') {
+                            console.log(chalk.green(`[porch] Consultation escalation gate already approved, continuing`));
+                            // Reset attempts and fall through to next state handling
+                            currentState = resetConsultationAttempts(currentState, stateKey);
+                            await writeState(statusFilePath, currentState);
+                        }
+                        else {
+                            console.log(chalk.red(`[porch] Consultation failed after ${attemptCount} attempts - escalating to human`));
+                            console.log(chalk.yellow(`[porch] To override and continue: porch approve ${projectId} ${escalationGateId}`));
+                            // Request human gate if not already requested
+                            if (!currentState.gates[escalationGateId]?.requested_at) {
+                                currentState = requestGateApproval(currentState, escalationGateId);
+                                await writeState(statusFilePath, currentState);
+                                await notifier.gatePending(phaseId, escalationGateId);
+                            }
+                            // Wait for human approval
+                            await new Promise(r => setTimeout(r, pollInterval * 1000));
+                            continue;
+                        }
+                    }
+                    else {
+                        console.log(chalk.yellow(`[porch] Consultation requested changes (attempt ${attemptCount}/${maxRounds}), continuing for revision`));
+                        // Stay in same state for Claude to revise on next iteration
+                        await new Promise(r => setTimeout(r, 2000));
+                        continue;
+                    }
+                }
+                else {
+                    // All approved - reset attempt counter
+                    currentState = resetConsultationAttempts(currentState, stateKey);
+                    await writeState(statusFilePath, currentState);
+                }
+                // All approved (or escalation gate passed) - use consultation's next state if defined
+                if (consultConfig.next) {
+                    if (planPhaseId) {
+                        currentState = updateState(currentState, `${consultConfig.next}:${planPhaseId}`);
+                    }
+                    else {
+                        currentState = updateState(currentState, consultConfig.next);
+                    }
+                    await writeState(statusFilePath, currentState);
+                    continue;
+                }
+            }
+        }
+        // Check if current state has a gate that should trigger AFTER this step
+        // This is the gate trigger point - step has executed, now block before transition
+        const gateInfo = getGateForState(protocol, currentState.current_state);
+        if (gateInfo) {
+            const { gateId } = gateInfo;
+            // Request gate approval if not already requested
+            if (!currentState.gates[gateId]?.requested_at) {
+                currentState = requestGateApproval(currentState, gateId);
+                await writeState(statusFilePath, currentState);
+                console.log(chalk.yellow(`[porch] Step complete. Gate approval requested: ${gateId}`));
+                await notifier.gatePending(phaseId, gateId);
+            }
+            // Gate not yet approved - wait (will check approval at start of next iteration)
+            if (currentState.gates[gateId]?.status !== 'passed') {
+                console.log(chalk.yellow(`[porch] BLOCKED - Waiting for gate: ${gateId}`));
+                console.log(chalk.yellow(`[porch] To approve: porch approve ${projectId} ${gateId}`));
+                await new Promise(r => setTimeout(r, pollInterval * 1000));
+                continue;
+            }
+        }
+        // Determine next state
+        let nextState = null;
+        if (signal) {
+            console.log(chalk.green(`[porch] Signal received: ${signal}`));
+            nextState = getSignalNextState(protocol, phaseId, signal);
+        }
+        if (!nextState) {
+            // Check if this is a phased phase (IDE loop)
+            if (isPhasedPhase(protocol, phaseId) && currentState.plan_phases?.length) {
+                nextState = getNextIDEState(protocol, currentState.current_state, currentState.plan_phases, signal || undefined);
+                // Mark current plan phase as complete if moving to next
+                if (nextState && planPhaseId) {
+                    const { planPhaseId: nextPlanPhaseId } = parsePlanPhaseFromState(nextState);
+                    if (nextPlanPhaseId !== planPhaseId) {
+                        currentState = updatePhaseStatus(currentState, planPhaseId, 'complete');
+                        if (nextPlanPhaseId) {
+                            currentState = updatePhaseStatus(currentState, nextPlanPhaseId, 'in_progress');
+                        }
+                    }
+                }
+            }
+            else {
+                // Use default transition
+                nextState = getDefaultNextState(protocol, currentState.current_state);
+            }
+        }
+        if (nextState) {
+            currentState = updateState(currentState, nextState, signal ? { signal } : undefined);
+            await writeState(statusFilePath, currentState);
+        }
+        else {
+            console.log(chalk.yellow(`[porch] No transition defined, staying in current state`));
+        }
+        await new Promise(r => setTimeout(r, 2000));
+    }
+    throw new Error(`Max iterations (${maxIterations}) reached!`);
+}
+/**
+ * Approve a gate
+ */
+export async function approve(projectId, gateId) {
+    const projectRoot = findProjectRoot();
+    const statusFilePath = findStatusFile(projectRoot, projectId);
+    if (!statusFilePath) {
+        throw new Error(`Status file not found for project: ${projectId}`);
+    }
+    const state = readState(statusFilePath);
+    if (!state) {
+        throw new Error(`Could not read state from: ${statusFilePath}`);
+    }
+    const updatedState = approveGate(state, gateId);
+    await writeState(statusFilePath, updatedState);
+    console.log(chalk.green(`[porch] Approved: ${gateId}`));
+}
+/**
+ * Show project status
+ */
+export async function status(projectId) {
+    const projectRoot = findProjectRoot();
+    if (projectId) {
+        // Show specific project
+        const statusFilePath = findStatusFile(projectRoot, projectId);
+        if (!statusFilePath) {
+            throw new Error(`Status file not found for project: ${projectId}`);
+        }
+        const state = readState(statusFilePath);
+        if (!state) {
+            throw new Error(`Could not read state from: ${statusFilePath}`);
+        }
+        console.log(chalk.blue(`[porch] Status for project ${projectId}:`));
+        console.log('');
+        console.log(`  ID:        ${state.id}`);
+        console.log(`  Title:     ${state.title}`);
+        console.log(`  Protocol:  ${state.protocol}`);
+        console.log(`  State:     ${state.current_state}`);
+        console.log(`  Iteration: ${state.iteration}`);
+        console.log(`  Started:   ${state.started_at}`);
+        console.log(`  Updated:   ${state.last_updated}`);
+        console.log('');
+        if (Object.keys(state.gates).length > 0) {
+            console.log('  Gates:');
+            for (const [gateId, gateStatus] of Object.entries(state.gates)) {
+                const icon = gateStatus.status === 'passed' ? '✓' : gateStatus.status === 'failed' ? '✗' : '⏳';
+                console.log(`    ${icon} ${gateId}: ${gateStatus.status}`);
+            }
+            console.log('');
+        }
+        if (state.plan_phases && state.plan_phases.length > 0) {
+            console.log('  Plan Phases:');
+            for (const phase of state.plan_phases) {
+                const phaseStatus = state.phases[phase.id]?.status || 'pending';
+                const icon = phaseStatus === 'complete' ? '✓' : phaseStatus === 'in_progress' ? '🔄' : '○';
+                console.log(`    ${icon} ${phase.id}: ${phase.title}`);
+            }
+        }
+    }
+    else {
+        // Show all projects
+        const projects = findProjects(projectRoot);
+        const executions = findExecutions(projectRoot);
+        if (projects.length === 0 && executions.length === 0) {
+            console.log(chalk.yellow('[porch] No projects found'));
+            return;
+        }
+        console.log(chalk.blue('[porch] Projects:'));
+        for (const { id, path: statusPath } of projects) {
+            const state = readState(statusPath);
+            if (state) {
+                const pendingGates = Object.entries(state.gates)
+                    .filter(([, g]) => g.status === 'pending' && g.requested_at)
+                    .map(([id]) => id);
+                const gateStr = pendingGates.length > 0 ? chalk.yellow(` [${pendingGates.join(', ')}]`) : '';
+                console.log(`  ${id} ${state.title} - ${state.current_state}${gateStr}`);
+            }
+        }
+        if (executions.length > 0) {
+            console.log('');
+            console.log(chalk.blue('[porch] Executions:'));
+            for (const { protocol, id, path: statusPath } of executions) {
+                const state = readState(statusPath);
+                if (state) {
+                    console.log(`  ${protocol}/${id} - ${state.current_state}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * List available protocols
+ */
+export async function list() {
+    const projectRoot = findProjectRoot();
+    const protocols = listProtocols(projectRoot);
+    if (protocols.length === 0) {
+        console.log(chalk.yellow('[porch] No protocols found'));
+        return;
+    }
+    console.log(chalk.blue('[porch] Available protocols:'));
+    for (const name of protocols) {
+        try {
+            const protocol = loadProtocol(name, projectRoot);
+            console.log(`  - ${name}: ${protocol.description}`);
+        }
+        catch {
+            console.log(`  - ${name}: (error loading)`);
+        }
+    }
+}
+/**
+ * Show protocol definition
+ */
+export async function show(protocolName) {
+    const projectRoot = findProjectRoot();
+    const protocol = loadProtocol(protocolName, projectRoot);
+    console.log(chalk.blue(`[porch] Protocol: ${protocolName}`));
+    console.log('');
+    console.log(JSON.stringify(protocol, null, 2));
+}
+/**
+ * Show pending gates across all projects
+ */
+export async function pending() {
+    const projectRoot = findProjectRoot();
+    const gates = findPendingGates(projectRoot);
+    if (gates.length === 0) {
+        console.log(chalk.green('[porch] No pending gates'));
+        return;
+    }
+    console.log(chalk.yellow('[porch] Pending gates:'));
+    for (const gate of gates) {
+        const requestedAt = gate.requestedAt ? ` (requested ${gate.requestedAt})` : '';
+        console.log(`  ${gate.projectId}: ${gate.gateId}${requestedAt}`);
+        console.log(`    → porch approve ${gate.projectId} ${gate.gateId}`);
+    }
+}
+// ============================================================================
+// Auto-Detection
+// ============================================================================
+/**
+ * Auto-detect project ID from current directory
+ *
+ * Detection methods:
+ * 1. Check if cwd is a worktree matching pattern: .builders/<id> or worktrees/<protocol>_<id>_*
+ * 2. Check for a single project in codev/projects/
+ * 3. Check for .porch-project marker file
+ */
+function autoDetectProject() {
+    const cwd = process.cwd();
+    // Method 1: Check path pattern for builder worktree
+    // Pattern: .builders/<id> or .builders/<id>-<name>
+    const buildersMatch = cwd.match(/[/\\]\.builders[/\\](\d+)(?:-[^/\\]*)?(?:[/\\]|$)/);
+    if (buildersMatch) {
+        return buildersMatch[1];
+    }
+    // Pattern: worktrees/<protocol>_<id>_<name>
+    const worktreeMatch = cwd.match(/[/\\]worktrees[/\\]\w+_(\d+)_[^/\\]*(?:[/\\]|$)/);
+    if (worktreeMatch) {
+        return worktreeMatch[1];
+    }
+    // Method 2: Check for .porch-project marker file
+    const markerPath = path.join(cwd, '.porch-project');
+    if (fs.existsSync(markerPath)) {
+        const content = fs.readFileSync(markerPath, 'utf-8').trim();
+        if (content) {
+            return content;
+        }
+    }
+    // Method 3: Check if there's exactly one project in codev/projects/
+    try {
+        const projectRoot = findProjectRoot();
+        const projects = findProjects(projectRoot);
+        if (projects.length === 1) {
+            return projects[0].id;
+        }
+    }
+    catch {
+        // Not in a codev project
+    }
+    return null;
+}
+export async function porch(options) {
+    const { subcommand, args, dryRun, noClaude, pollInterval, description, worktree } = options;
+    switch (subcommand.toLowerCase()) {
+        case 'run': {
+            let projectId = args[0];
+            // Auto-detect project if not provided
+            if (!projectId) {
+                const detected = autoDetectProject();
+                if (!detected) {
+                    throw new Error('Usage: porch run <project-id>\n' +
+                        'Or run from a project worktree to auto-detect.');
+                }
+                projectId = detected;
+                console.log(chalk.blue(`[porch] Auto-detected project: ${projectId}`));
+            }
+            await run(projectId, { dryRun, noClaude, pollInterval });
+            break;
+        }
+        case 'init': {
+            if (args.length < 3) {
+                throw new Error('Usage: porch init <protocol> <project-id> <project-name>');
+            }
+            await init(args[0], args[1], args[2], { description, worktree });
+            break;
+        }
+        case 'approve': {
+            if (args.length < 2) {
+                throw new Error('Usage: porch approve <project-id> <gate-id>');
+            }
+            await approve(args[0], args[1]);
+            break;
+        }
+        case 'status': {
+            await status(args[0]);
+            break;
+        }
+        case 'pending': {
+            await pending();
+            break;
+        }
+        case 'list':
+        case 'list-protocols': {
+            await list();
+            break;
+        }
+        case 'show':
+        case 'show-protocol': {
+            if (args.length < 1) {
+                throw new Error('Usage: porch show <protocol>');
+            }
+            await show(args[0]);
+            break;
+        }
+        default:
+            throw new Error(`Unknown subcommand: ${subcommand}\n` +
+                'Valid subcommands: run, init, approve, status, pending, list, show');
+    }
+}
+//# sourceMappingURL=index.js.map