@cluesmith/codev 2.0.0-rc.57 → 2.0.0-rc.59

package/dist/commands/porch/run.js

@@ -1,893 +0,0 @@
-/**
- * porch run - Main run loop (Build-Verify design)
- *
- * Porch orchestrates build-verify cycles:
- * 1. BUILD: Spawn Claude to create artifact
- * 2. VERIFY: Run 3-way consultation (Gemini, Codex, Claude)
- * 3. ITERATE: If any REQUEST_CHANGES, feed back to Claude
- * 4. COMPLETE: When all APPROVE (or max iterations), commit + push + gate
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import chalk from 'chalk';
-import { readState, writeState, findStatusPath } from './state.js';
-import { loadProtocol, getPhaseConfig, isPhased, getPhaseGate, isBuildVerify, getVerifyConfig, getMaxIterations, getOnCompleteConfig, getBuildConfig } from './protocol.js';
-import { getCurrentPlanPhase } from './plan.js';
-import { buildWithTimeout } from './claude.js';
-import { buildPhasePrompt } from './prompts.js';
-import { globSync } from 'node:fs';
-/**
- * Check if an artifact file has YAML frontmatter indicating it was
- * already approved and validated (3-way review).
- *
- * Frontmatter format:
- * ---
- * approved: 2026-01-29
- * validated: [gemini, codex, claude]
- * ---
- */
-function isArtifactPreApproved(projectRoot, artifactGlob) {
-    // Resolve glob pattern (e.g., "codev/specs/0085-*.md")
-    const matches = globSync(artifactGlob, { cwd: projectRoot });
-    if (matches.length === 0)
-        return false;
-    const filePath = path.join(projectRoot, matches[0]);
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        // Check for YAML frontmatter with approved and validated fields
-        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-        if (!frontmatterMatch)
-            return false;
-        const frontmatter = frontmatterMatch[1];
-        const hasApproved = /^approved:\s*.+$/m.test(frontmatter);
-        const hasValidated = /^validated:\s*\[.+\]$/m.test(frontmatter);
-        return hasApproved && hasValidated;
-    }
-    catch {
-        return false;
-    }
-}
-// Runtime artifacts go in project directory, not a hidden folder
-function getPorchDir(projectRoot, state) {
-    return path.join(projectRoot, 'codev', 'projects', `${state.id}-${state.title}`);
-}
-/**
- * Generate output file name with phase and iteration info.
- * e.g., "0074-specify-iter-1.txt" or "0074-phase_1-iter-2.txt"
- *
- * Uses state.iteration which is persisted and survives porch restarts.
- */
-function getOutputFileName(state) {
-    const planPhase = getCurrentPlanPhase(state.plan_phases);
-    // Build filename using persisted iteration from state
-    const parts = [state.id];
-    if (planPhase) {
-        parts.push(planPhase.id);
-    }
-    else {
-        parts.push(state.phase);
-    }
-    parts.push(`iter-${state.iteration}`);
-    return `${parts.join('-')}.txt`;
-}
-/** Exit code when AWAITING_INPUT is detected in non-interactive mode */
-export const EXIT_AWAITING_INPUT = 3;
-// Build constants — all build-loop settings centralized here (spec §Configuration)
-const BUILD_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
-const BUILD_MAX_RETRIES = 3;
-const BUILD_RETRY_DELAYS = [5000, 15000, 30000]; // 5s, 15s, 30s
-const CIRCUIT_BREAKER_THRESHOLD = 5;
-/**
- * Main run loop for porch.
- * Spawns Claude for each phase and monitors until protocol complete.
- */
-export async function run(projectRoot, projectId, options = {}) {
-    const statusPath = findStatusPath(projectRoot, projectId);
-    if (!statusPath) {
-        throw new Error(`Project ${projectId} not found.\nRun 'porch init' to create a new project.`);
-    }
-    // Read initial state to get project directory
-    let state = readState(statusPath);
-    const singleIteration = options.singleIteration || false;
-    const singlePhase = options.singlePhase || false;
-    // Ensure project artifacts directory exists
-    const porchDir = getPorchDir(projectRoot, state);
-    if (!fs.existsSync(porchDir)) {
-        fs.mkdirSync(porchDir, { recursive: true });
-    }
-    console.log('');
-    console.log(chalk.bold('PORCH - Protocol Orchestrator'));
-    console.log(chalk.dim('Porch is the outer loop. Claude runs under porch control.'));
-    console.log('');
-    let consecutiveFailures = 0;
-    while (true) {
-        state = readState(statusPath);
-        // AWAITING_INPUT resume guard — prevent infinite resume loops (spec §AWAITING_INPUT resume guard)
-        if (state.awaiting_input) {
-            // If we have a previous output hash, check if the file has changed.
-            // If unchanged, the human hasn't resolved the blocker — halt.
-            if (state.awaiting_input_output && state.awaiting_input_hash && fs.existsSync(state.awaiting_input_output)) {
-                const crypto = await import('node:crypto');
-                const currentHash = crypto.createHash('sha256').update(fs.readFileSync(state.awaiting_input_output)).digest('hex');
-                if (currentHash === state.awaiting_input_hash) {
-                    console.error(chalk.red('[PORCH] AWAITING_INPUT output unchanged since last run. Resolve the blocker before restarting.'));
-                    console.error(chalk.dim(`  Output file: ${state.awaiting_input_output}`));
-                    process.exit(EXIT_AWAITING_INPUT);
-                }
-            }
-            console.log(chalk.yellow('[PORCH] Resuming from AWAITING_INPUT state'));
-            state.awaiting_input = false;
-            delete state.awaiting_input_output;
-            delete state.awaiting_input_hash;
-            writeState(statusPath, state);
-            // Continue normally — will re-run the build phase
-        }
-        // Circuit breaker check
-        if (consecutiveFailures >= CIRCUIT_BREAKER_THRESHOLD) {
-            console.error(chalk.red(`[PORCH] Circuit breaker: ${consecutiveFailures} consecutive build failures. Halting.`));
-            process.exit(2);
-        }
-        const protocol = loadProtocol(projectRoot, state.protocol);
-        const phaseConfig = getPhaseConfig(protocol, state.phase);
-        if (!phaseConfig) {
-            console.log(chalk.green.bold('🎉 PROTOCOL COMPLETE'));
-            console.log(`\n  Project ${state.id} has completed the ${state.protocol} protocol.`);
-            break;
-        }
-        // Check for pending gate
-        const gateName = getPhaseGate(protocol, state.phase);
-        if (gateName && state.gates[gateName]?.status === 'pending' && state.gates[gateName]?.requested_at) {
-            // --single-phase: return gate status to Builder, let it handle human interaction
-            if (singlePhase) {
-                console.log(chalk.yellow(`\n[--single-phase] Gate '${gateName}' pending. Needs human approval.`));
-                outputSinglePhaseResult(state, 'gate_needed', gateName);
-                return;
-            }
-            const outputPath = path.join(porchDir, `${state.id}-gate.txt`);
-            await handleGate(state, gateName, statusPath, projectRoot, outputPath, protocol);
-            continue;
-        }
-        // Gate approved → advance to next phase
-        if (gateName && state.gates[gateName]?.status === 'approved') {
-            const { done } = await import('./index.js');
-            await done(projectRoot, state.id);
-            // --single-phase: exit after phase advances
-            if (singlePhase) {
-                const newState = readState(statusPath);
-                console.log(chalk.dim(`\n[--single-phase] Phase complete. Now at: ${newState.phase}`));
-                outputSinglePhaseResult(newState, 'advanced', undefined, undefined);
-                return;
-            }
-            continue;
-        }
-        // Handle build_verify phases
-        if (isBuildVerify(protocol, state.phase)) {
-            const maxIterations = getMaxIterations(protocol, state.phase);
-            // Check if artifact already exists and was pre-approved + validated
-            // (e.g., spec/plan created by architect before builder was spawned)
-            if (!state.build_complete && state.iteration === 1) {
-                const buildConfig = getBuildConfig(protocol, state.phase);
-                if (buildConfig?.artifact) {
-                    const artifactGlob = buildConfig.artifact.replace('${PROJECT_ID}', state.id);
-                    if (isArtifactPreApproved(projectRoot, artifactGlob)) {
-                        console.log(chalk.green(`[${state.id}] ${phaseConfig.name}: artifact exists with approval metadata - skipping build+verify`));
-                        // Auto-approve gate and advance
-                        if (gateName) {
-                            state.gates[gateName] = { status: 'approved', approved_at: new Date().toISOString() };
-                            writeState(statusPath, state);
-                        }
-                        const { done } = await import('./index.js');
-                        await done(projectRoot, state.id);
-                        continue;
-                    }
-                }
-            }
-            // Check if we need to run VERIFY (build just completed)
-            if (state.build_complete) {
-                // First check if the artifact was actually created
-                const artifactPath = getArtifactForPhase(state);
-                if (artifactPath) {
-                    const fullPath = path.join(projectRoot, artifactPath);
-                    if (!fs.existsSync(fullPath)) {
-                        console.log('');
-                        console.log(chalk.yellow(`Artifact not found: ${artifactPath}`));
-                        console.log(chalk.dim('Claude may have asked questions or encountered an error.'));
-                        console.log(chalk.dim('Check the output file for details, then respawn.'));
-                        state.build_complete = false;
-                        writeState(statusPath, state);
-                        continue;
-                    }
-                }
-                console.log('');
-                console.log(chalk.cyan(`[${state.id}] VERIFY - Iteration ${state.iteration}/${maxIterations}`));
-                const verifyStartMs = Date.now();
-                const reviews = await runVerification(projectRoot, state, protocol);
-                const verifyDurationMs = Date.now() - verifyStartMs;
-                // Structured timing output for e2e test parsing
-                const verdictMap = {};
-                for (const r of reviews) {
-                    verdictMap[r.model] = r.verdict;
-                }
-                console.log(`__PORCH_TIMING__${JSON.stringify({
-                    event: 'verify',
-                    phase: state.phase,
-                    plan_phase: state.current_plan_phase || null,
-                    iteration: state.iteration,
-                    duration_ms: verifyDurationMs,
-                    verdicts: verdictMap,
-                })}`);
-                // Get the build output file from current iteration (stored when we track it)
-                const currentBuildOutput = state.history.find(h => h.iteration === state.iteration)?.build_output || '';
-                // Update history with reviews
-                const existingRecord = state.history.find(h => h.iteration === state.iteration);
-                if (existingRecord) {
-                    existingRecord.reviews = reviews;
-                }
-                else {
-                    state.history.push({
-                        iteration: state.iteration,
-                        build_output: currentBuildOutput,
-                        reviews,
-                    });
-                }
-                if (allApprove(reviews)) {
-                    console.log(chalk.green('\nAll reviewers APPROVE!'));
-                    // Run on_complete actions (commit + push)
-                    await runOnComplete(projectRoot, state, protocol, reviews);
-                    // Request gate or advance plan phase
-                    if (gateName) {
-                        state.gates[gateName] = { status: 'pending', requested_at: new Date().toISOString() };
-                    }
-                    else if (isPhased(protocol, state.phase)) {
-                        // No gate on a per_plan_phase type — advance plan phase directly
-                        const { done } = await import('./index.js');
-                        await done(projectRoot, state.id);
-                        state = readState(statusPath); // Re-read after done() modifies state
-                    }
-                    // Reset for next iteration
-                    state.build_complete = false;
-                    state.iteration = 1;
-                    state.history = [];
-                    writeState(statusPath, state);
-                    // Single iteration mode: exit after completing a build-verify cycle
-                    if (singleIteration) {
-                        console.log(chalk.dim('\n[--single-iteration] Build-verify cycle complete. Exiting.'));
-                        return;
-                    }
-                    // --single-phase: exit after build-verify passes
-                    if (singlePhase) {
-                        if (gateName) {
-                            console.log(chalk.dim(`\n[--single-phase] Build-verify passed. Gate '${gateName}' requested.`));
-                            outputSinglePhaseResult(state, 'gate_needed', gateName, reviews);
-                        }
-                        else {
-                            console.log(chalk.dim(`\n[--single-phase] Build-verify passed. No gate needed.`));
-                            outputSinglePhaseResult(state, 'verified', undefined, reviews);
-                        }
-                        return;
-                    }
-                    continue;
-                }
-                // Some reviewers requested changes
-                console.log(chalk.yellow('\nChanges requested. Feeding back to Claude...'));
-                // --single-phase: return control to Builder with iterating status
-                if (singlePhase) {
-                    console.log(chalk.dim(`\n[--single-phase] Changes requested. Returning control to Builder.`));
-                    outputSinglePhaseResult(state, 'iterating', undefined, reviews);
-                    return;
-                }
-                if (state.iteration >= maxIterations) {
-                    // Max iterations reached without unanimity - summarize and interrupt user
-                    console.log('');
-                    console.log(chalk.red('═'.repeat(60)));
-                    console.log(chalk.red.bold('  MAX ITERATIONS REACHED - NO UNANIMITY'));
-                    console.log(chalk.red('═'.repeat(60)));
-                    console.log('');
-                    console.log(chalk.yellow(`After ${maxIterations} iterations, reviewers did not reach unanimity.`));
-                    console.log('');
-                    console.log(chalk.bold('Summary of reviewer positions:'));
-                    // Group reviews by verdict
-                    const byVerdict = {};
-                    for (const r of reviews) {
-                        if (!byVerdict[r.verdict])
-                            byVerdict[r.verdict] = [];
-                        byVerdict[r.verdict].push(r.model);
-                    }
-                    for (const [verdict, models] of Object.entries(byVerdict)) {
-                        const color = verdict === 'APPROVE' ? chalk.green :
-                            verdict === 'CONSULT_ERROR' ? chalk.red :
-                                verdict === 'REQUEST_CHANGES' ? chalk.yellow : chalk.blue;
-                        console.log(`  ${color(verdict)}: ${models.join(', ')}`);
-                    }
-                    console.log('');
-                    console.log(chalk.dim('Review files:'));
-                    for (const r of reviews) {
-                        console.log(`  ${r.model}: ${r.file}`);
-                    }
-                    console.log('');
-                    // Check for identical REQUEST_CHANGES (may indicate missing context)
-                    const requestChangesReviews = reviews.filter(r => r.verdict === 'REQUEST_CHANGES');
-                    if (requestChangesReviews.length >= 2) {
-                        console.log(chalk.yellow('Note: Multiple REQUEST_CHANGES may indicate missing file context.'));
-                        console.log(chalk.dim('Check if the artifact path is correct and files are committed.'));
-                        console.log('');
-                    }
-                    // Auto-continue when PORCH_AUTO_APPROVE is set (e2e/non-interactive mode)
-                    let action;
-                    if (process.env.PORCH_AUTO_APPROVE === 'true') {
-                        console.log(chalk.yellow('[E2E] Auto-continuing past max iterations'));
-                        action = 'c';
-                    }
-                    else {
-                        // Wait for user decision
-                        const readline = await import('node:readline');
-                        const rl = readline.createInterface({
-                            input: process.stdin,
-                            output: process.stdout,
-                        });
-                        console.log('Options:');
-                        console.log("  'c' or 'continue' - Proceed to gate anyway (let human decide)");
-                        console.log("  'r' or 'retry'    - Reset iteration counter and try again");
-                        console.log("  'q' or 'quit'     - Exit porch");
-                        console.log('');
-                        action = await new Promise((resolve) => {
-                            rl.question(chalk.cyan(`[${state.id}] > `), (input) => {
-                                rl.close();
-                                resolve(input.trim().toLowerCase());
-                            });
-                        });
-                    }
-                    switch (action) {
-                        case 'c':
-                        case 'continue':
-                            console.log(chalk.dim('\nProceeding to gate...'));
-                            break;
-                        case 'r':
-                        case 'retry':
-                            console.log(chalk.dim('\nResetting iteration counter...'));
-                            state.iteration = 1;
-                            state.build_complete = false;
-                            state.history = [];
-                            writeState(statusPath, state);
-                            continue;
-                        case 'q':
-                        case 'quit':
-                            console.log(chalk.yellow('\nExiting porch.'));
-                            return;
-                        default:
-                            console.log(chalk.yellow('\nUnknown option. Proceeding to gate.'));
-                    }
-                    // Run on_complete actions
-                    await runOnComplete(projectRoot, state, protocol, reviews);
-                    // Request gate
-                    if (gateName) {
-                        state.gates[gateName] = { status: 'pending', requested_at: new Date().toISOString() };
-                    }
-                    state.build_complete = false;
-                    state.iteration = 1;
-                    state.history = [];
-                    writeState(statusPath, state);
-                    // Single iteration mode: exit after max iterations
-                    if (singleIteration) {
-                        console.log(chalk.dim('\n[--single-iteration] Max iterations reached. Exiting.'));
-                        return;
-                    }
-                    continue;
-                }
-                // Increment iteration and continue to BUILD
-                state.iteration++;
-                state.build_complete = false;
-                writeState(statusPath, state);
-                // Single iteration mode: exit after storing feedback
-                if (singleIteration) {
-                    console.log(chalk.dim('\n[--single-iteration] Feedback stored for next iteration. Exiting.'));
-                    console.log(chalk.dim(`  Next run will be iteration ${state.iteration} with reviewer feedback.`));
-                    return;
-                }
-                // Fall through to BUILD phase
-            }
-            // BUILD phase
-            console.log('');
-            console.log(chalk.cyan(`[${state.id}] BUILD - ${phaseConfig.name} - Iteration ${state.iteration}/${maxIterations}`));
-        }
-        // Generate output file for this iteration
-        const outputFileName = getOutputFileName(state);
-        const outputPath = path.join(porchDir, outputFileName);
-        // Track this build output in history (for feedback to next iteration)
-        if (isBuildVerify(protocol, state.phase)) {
-            const existingRecord = state.history.find(h => h.iteration === state.iteration);
-            if (existingRecord) {
-                existingRecord.build_output = outputPath;
-            }
-            else {
-                state.history.push({
-                    iteration: state.iteration,
-                    build_output: outputPath,
-                    reviews: [],
-                });
-            }
-            writeState(statusPath, state);
-        }
-        // Build prompt for current phase (includes history file paths if iteration > 1)
-        const prompt = buildPhasePrompt(projectRoot, state, protocol);
-        console.log(chalk.dim(`Output: ${outputFileName}`));
-        // Show status
-        showStatus(state, protocol);
-        // Print the prompt being sent to the Worker
-        console.log('');
-        console.log(chalk.cyan('═'.repeat(60)));
-        console.log(chalk.cyan.bold('  PROMPT TO WORKER (Agent SDK)'));
-        console.log(chalk.cyan('═'.repeat(60)));
-        console.log(chalk.dim(prompt.substring(0, 2000)));
-        if (prompt.length > 2000) {
-            console.log(chalk.dim(`... (${prompt.length - 2000} more chars)`));
-        }
-        console.log(chalk.cyan('═'.repeat(60)));
-        console.log('');
-        // Run the Worker via Agent SDK with retry
-        console.log(chalk.dim('Starting Worker (Agent SDK)...'));
-        const buildStartMs = Date.now();
-        let actualOutputPath = outputPath;
-        let result = await buildWithTimeout(prompt, outputPath, projectRoot, BUILD_TIMEOUT_MS);
-        // Retry on failure (timeout or SDK error)
-        if (!result.success && isBuildVerify(protocol, state.phase)) {
-            for (let attempt = 1; attempt <= BUILD_MAX_RETRIES && !result.success; attempt++) {
-                const delay = BUILD_RETRY_DELAYS[attempt - 1] || BUILD_RETRY_DELAYS[BUILD_RETRY_DELAYS.length - 1];
-                console.log(chalk.yellow(`\nBuild failed. Retrying in ${delay / 1000}s... (attempt ${attempt + 1}/${BUILD_MAX_RETRIES + 1})`));
-                await sleep(delay);
-                // Each retry attempt gets a distinct output file
-                actualOutputPath = outputPath.replace(/\.txt$/, `-try-${attempt + 1}.txt`);
-                result = await buildWithTimeout(prompt, actualOutputPath, projectRoot, BUILD_TIMEOUT_MS);
-            }
-        }
-        const buildDurationMs = Date.now() - buildStartMs;
-        if (result.cost) {
-            console.log(chalk.dim(`  Cost: $${result.cost.toFixed(4)}`));
-        }
-        if (result.duration) {
-            console.log(chalk.dim(`  Duration: ${(result.duration / 1000).toFixed(1)}s`));
-        }
-        // Structured timing output for e2e test parsing
-        console.log(`__PORCH_TIMING__${JSON.stringify({
-            event: 'build',
-            phase: state.phase,
-            plan_phase: state.current_plan_phase || null,
-            iteration: state.iteration,
-            duration_ms: buildDurationMs,
-            cost: result.cost || null,
-            success: result.success,
-        })}`);
-        // AWAITING_INPUT detection
-        if (result.output && (/^<signal>BLOCKED:/im.test(result.output) || /^<signal>AWAITING_INPUT<\/signal>/im.test(result.output))) {
-            console.error(chalk.yellow(`[PORCH] Worker needs human input — check output file: ${actualOutputPath}`));
-            state.awaiting_input = true;
-            state.awaiting_input_output = actualOutputPath;
-            // Store hash of output for resume guard comparison
-            if (fs.existsSync(actualOutputPath)) {
-                const crypto = await import('node:crypto');
-                state.awaiting_input_hash = crypto.createHash('sha256').update(fs.readFileSync(actualOutputPath)).digest('hex');
-            }
-            writeState(statusPath, state);
-            process.exit(EXIT_AWAITING_INPUT);
-        }
-        // For build_verify phases, only proceed to verify on success
-        if (isBuildVerify(protocol, state.phase)) {
-            if (result.success) {
-                console.log(chalk.dim('\nWorker finished. Moving to verification...'));
-                // Update history to point at the actual successful attempt's output file
-                const historyRecord = state.history.find(h => h.iteration === state.iteration);
-                if (historyRecord) {
-                    historyRecord.build_output = actualOutputPath;
-                }
-                state.build_complete = true;
-                consecutiveFailures = 0;
-                writeState(statusPath, state);
-            }
-            else {
-                // All retries exhausted — increment circuit breaker, do NOT set build_complete
-                console.log(chalk.red('\nWorker failed after all retries.'));
-                console.log(chalk.dim(`Check output: ${actualOutputPath}`));
-                consecutiveFailures++;
-                // In single-phase or single-iteration mode, return control to the caller
-                if (singlePhase) {
-                    outputSinglePhaseResult(state, 'failed');
-                    return;
-                }
-                if (singleIteration) {
-                    console.log(chalk.dim('\n[--single-iteration] Build failed. Exiting.'));
-                    return;
-                }
-                // Loop back to top where circuit breaker check will halt if threshold reached
-                continue;
-            }
-            // Continue loop - will hit build_complete check and run verify
-        }
-        else if (!result.success) {
-            console.log(chalk.red('\nWorker failed.'));
-            console.log(chalk.dim(`Check output: ${actualOutputPath}`));
-            if (singlePhase) {
-                outputSinglePhaseResult(state, 'failed');
-            }
-            return;
-        }
-    }
-}
-// ============================================================================
-// Verification (3-way consultation)
-// ============================================================================
-/**
- * Run 3-way verification on the current phase artifact.
- * Writes each consultation output to a file.
- * Returns array of review results with file paths.
- */
-async function runVerification(projectRoot, state, protocol) {
-    const verifyConfig = getVerifyConfig(protocol, state.phase);
-    if (!verifyConfig) {
-        return []; // No verification configured
-    }
-    console.log(chalk.dim(`Running ${verifyConfig.models.length}-way consultation...`));
-    const porchDir = getPorchDir(projectRoot, state);
-    const reviews = [];
-    // Run consultations in parallel
-    const promises = verifyConfig.models.map(async (model) => {
-        console.log(chalk.dim(`  ${model}: starting...`));
-        // Output file for this review
-        const reviewFile = path.join(porchDir, `${state.id}-${state.phase}-iter${state.iteration}-${model}.txt`);
-        const result = await runConsult(projectRoot, model, verifyConfig.type, state, reviewFile);
-        reviews.push(result);
-        const verdictColor = result.verdict === 'APPROVE' ? chalk.green :
-            result.verdict === 'COMMENT' ? chalk.blue : chalk.yellow;
-        console.log(`  ${model}: ${verdictColor(result.verdict)}`);
-    });
-    await Promise.all(promises);
-    return reviews;
-}
-/**
- * Get the consult artifact type for a phase.
- */
-function getConsultArtifactType(phaseId) {
-    switch (phaseId) {
-        case 'specify':
-            return 'spec';
-        case 'plan':
-            return 'plan';
-        case 'implement':
-            return 'impl'; // Implementation reviews the code diff
-        case 'review':
-            return 'spec'; // Review phase reviews overall work
-        default:
-            return 'spec';
-    }
-}
-/**
- * Run a single consultation with retry on failure.
- * Writes output to file and returns result with file path.
- *
- * Retry logic:
- * - Non-zero exit code = consultation failed (API key missing, network error, etc.)
- * - Retry up to 3 times with exponential backoff
- * - If all retries fail, return CONSULT_ERROR (not REQUEST_CHANGES)
- */
-const CONSULT_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
-const CONSULT_MAX_RETRIES = 3;
-const CONSULT_RETRY_DELAYS = [5000, 15000, 30000]; // 5s, 15s, 30s
-async function runConsult(projectRoot, model, reviewType, state, outputFile) {
-    for (let attempt = 0; attempt < CONSULT_MAX_RETRIES; attempt++) {
-        const result = await runConsultOnce(projectRoot, model, reviewType, state, outputFile);
-        // Success - got a valid verdict
-        if (result.verdict !== 'CONSULT_ERROR') {
-            return result;
-        }
-        // Consultation failed - retry if attempts remaining
-        if (attempt < CONSULT_MAX_RETRIES - 1) {
-            const delay = CONSULT_RETRY_DELAYS[attempt];
-            console.log(chalk.yellow(`  ${model}: failed, retrying in ${delay / 1000}s... (attempt ${attempt + 2}/${CONSULT_MAX_RETRIES})`));
-            await sleep(delay);
-        }
-    }
-    // All retries failed
-    console.log(chalk.red(`  ${model}: FAILED after ${CONSULT_MAX_RETRIES} attempts`));
-    return { model, verdict: 'CONSULT_ERROR', file: outputFile };
-}
-async function runConsultOnce(projectRoot, model, reviewType, state, outputFile) {
-    const { spawn } = await import('node:child_process');
-    const artifactType = getConsultArtifactType(state.phase);
-    return new Promise((resolve) => {
-        // Load .env from projectRoot so API keys (e.g. GEMINI_API_KEY) propagate
-        // to consultation subprocesses regardless of CWD
-        const env = { ...process.env };
-        const envFile = path.join(projectRoot, '.env');
-        if (fs.existsSync(envFile)) {
-            for (const line of fs.readFileSync(envFile, 'utf-8').split('\n')) {
-                const trimmed = line.trim();
-                if (trimmed && !trimmed.startsWith('#')) {
-                    const eq = trimmed.indexOf('=');
-                    if (eq > 0) {
-                        env[trimmed.substring(0, eq)] = trimmed.substring(eq + 1);
-                    }
-                }
-            }
-        }
-        const args = ['--model', model, '--type', reviewType, artifactType, state.id];
-        const proc = spawn('consult', args, {
-            cwd: projectRoot,
-            env,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        let output = '';
-        let resolved = false;
-        let exitCode = null;
-        // Timeout after 1 hour
-        const timeout = setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                proc.kill('SIGTERM');
-                const timeoutOutput = output + '\n\n[TIMEOUT: Consultation exceeded 1 hour limit]';
-                fs.writeFileSync(outputFile, timeoutOutput);
-                console.log(chalk.yellow(`  ${model}: timeout (1 hour limit)`));
-                resolve({ model, verdict: 'CONSULT_ERROR', file: outputFile });
-            }
-        }, CONSULT_TIMEOUT_MS);
-        proc.stdout.on('data', (data) => { output += data.toString(); });
-        proc.stderr.on('data', (data) => { output += data.toString(); });
-        proc.on('close', (code) => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                exitCode = code;
-                // Write output to file
-                fs.writeFileSync(outputFile, output);
-                // Non-zero exit code = consultation failed (API key missing, etc.)
-                if (code !== 0) {
-                    console.log(chalk.yellow(`  ${model}: exit code ${code}`));
-                    resolve({ model, verdict: 'CONSULT_ERROR', file: outputFile });
-                    return;
-                }
-                // Parse verdict from output
-                const verdict = parseVerdict(output);
-                resolve({ model, verdict, file: outputFile });
-            }
-        });
-        proc.on('error', (err) => {
-            if (!resolved) {
-                resolved = true;
-                clearTimeout(timeout);
-                const errorOutput = `Error: ${err.message}`;
-                fs.writeFileSync(outputFile, errorOutput);
-                console.log(chalk.red(`  ${model}: error - ${err.message}`));
-                resolve({ model, verdict: 'CONSULT_ERROR', file: outputFile });
-            }
-        });
-    });
-}
-/**
- * Parse verdict from consultation output.
- *
- * Looks for the verdict line in format:
- *   VERDICT: APPROVE
- *   VERDICT: REQUEST_CHANGES
- *   VERDICT: COMMENT
- *
- * Also handles markdown formatting like:
- *   **VERDICT: APPROVE**
- *   *VERDICT: APPROVE*
- *
- * Safety: If no explicit verdict found (empty output, crash, malformed),
- * defaults to REQUEST_CHANGES to prevent proceeding with unverified code.
- */
-export function parseVerdict(output) {
-    // Empty or very short output = something went wrong
-    if (!output || output.trim().length < 50) {
-        return 'REQUEST_CHANGES';
-    }
-    // Scan lines LAST→FIRST so the actual verdict (at the end) takes priority
-    // over template text echoed by codex CLI at the start of output.
-    // Skip template lines containing "[" (e.g., "VERDICT: [APPROVE | REQUEST_CHANGES | COMMENT]")
-    const lines = output.split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-        // Strip markdown formatting (**, *, __, _, `) and trim
-        const stripped = lines[i].trim().replace(/^[\*_`-]+|[\*_`-]+$/g, '').trim().toUpperCase();
-        // Match "VERDICT: <value>" but NOT template "VERDICT: [APPROVE | ...]"
-        if (stripped.startsWith('VERDICT:') && !stripped.includes('[')) {
-            const value = stripped.substring('VERDICT:'.length).trim();
-            if (value.startsWith('REQUEST_CHANGES'))
-                return 'REQUEST_CHANGES';
-            if (value.startsWith('APPROVE'))
-                return 'APPROVE';
-            if (value.startsWith('COMMENT'))
-                return 'COMMENT';
-        }
-    }
-    // No valid VERDICT: line found — default to REQUEST_CHANGES for safety
-    return 'REQUEST_CHANGES';
-}
-/**
- * Check if all reviewers approved (unanimity required).
- *
- * Returns true only if ALL reviewers explicitly APPROVE.
- * COMMENT counts as approve (non-blocking feedback).
- * CONSULT_ERROR and REQUEST_CHANGES block approval.
- */
-function allApprove(reviews) {
-    if (reviews.length === 0)
-        return true; // No verification = auto-approve
-    // Unanimity: ALL must be APPROVE or COMMENT
-    return reviews.every(r => r.verdict === 'APPROVE' || r.verdict === 'COMMENT');
-}
-/**
- * Run on_complete actions (commit + push).
- */
-async function runOnComplete(projectRoot, state, protocol, reviews) {
-    const onComplete = getOnCompleteConfig(protocol, state.phase);
-    if (!onComplete)
-        return;
-    const buildConfig = getBuildConfig(protocol, state.phase);
-    if (!buildConfig)
-        return;
-    // Resolve artifact path
-    const artifact = buildConfig.artifact
-        .replace('${PROJECT_ID}', state.id)
-        .replace('${PROJECT_TITLE}', state.title);
-    const { exec } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const execAsync = promisify(exec);
-    if (onComplete.commit) {
-        console.log(chalk.dim('Committing...'));
-        try {
-            // Stage artifact
-            await execAsync(`git add ${artifact}`, { cwd: projectRoot });
-            // Commit
-            const message = `[Spec ${state.id}] ${state.phase}: ${state.title}
-
-Iteration ${state.iteration}
-3-way review: ${formatVerdicts(reviews)}`;
-            await execAsync(`git commit -m "${message}"`, { cwd: projectRoot });
-            console.log(chalk.green('Committed.'));
-        }
-        catch (err) {
-            console.log(chalk.yellow('Commit failed (may be nothing to commit).'));
-        }
-    }
-    if (onComplete.push) {
-        console.log(chalk.dim('Pushing...'));
-        try {
-            await execAsync('git push', { cwd: projectRoot });
-            console.log(chalk.green('Pushed.'));
-        }
-        catch (err) {
-            console.log(chalk.yellow('Push failed.'));
-        }
-    }
-}
-/**
- * Format verdicts for commit message.
- */
-function formatVerdicts(reviews) {
-    return reviews
-        .map(r => `${r.model}=${r.verdict}`)
-        .join(', ') || 'N/A';
-}
-/**
- * Display current status.
- */
-function showStatus(state, protocol) {
-    const phaseConfig = getPhaseConfig(protocol, state.phase);
-    console.log('');
-    console.log(chalk.bold(`[${state.id}] ${state.title}`));
-    console.log(`  Phase: ${state.phase} (${phaseConfig?.name || 'unknown'})`);
-    if (isBuildVerify(protocol, state.phase)) {
-        const maxIterations = getMaxIterations(protocol, state.phase);
-        console.log(`  Iteration: ${state.iteration}/${maxIterations}`);
-    }
-    if (isPhased(protocol, state.phase) && state.plan_phases.length > 0) {
-        const currentPlanPhase = getCurrentPlanPhase(state.plan_phases);
-        if (currentPlanPhase) {
-            console.log(`  Plan Phase: ${currentPlanPhase.id} - ${currentPlanPhase.title}`);
-        }
-    }
-    console.log('');
-}
-/**
- * Handle gate approval flow.
- */
-async function handleGate(state, gateName, statusPath, projectRoot, outputPath, protocol) {
-    // E2E testing: Auto-approve gates when PORCH_AUTO_APPROVE is set
-    if (process.env.PORCH_AUTO_APPROVE === 'true') {
-        console.log(chalk.yellow(`[E2E] Auto-approving gate: ${gateName}`));
-        state.gates[gateName].status = 'approved';
-        state.gates[gateName].approved_at = new Date().toISOString();
-        writeState(statusPath, state);
-        return;
-    }
-    console.log('');
-    console.log(chalk.yellow('═'.repeat(60)));
-    console.log(chalk.yellow.bold(`  GATE: ${gateName}`));
-    console.log(chalk.yellow('═'.repeat(60)));
-    console.log('');
-    // Show artifact path
-    const artifact = getArtifactForPhase(state);
-    if (artifact) {
-        console.log(`  Review: ${artifact}`);
-    }
-    console.log('');
-    console.log("  Type 'a' or 'approve' to approve and continue.");
-    console.log("  Type 'q' or 'quit' to exit.");
-    console.log('');
-    // Wait for user input
-    const readline = await import('node:readline');
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        const prompt = () => {
-            rl.question(chalk.cyan(`[${state.id}] WAITING FOR APPROVAL > `), (input) => {
-                const cmd = input.trim().toLowerCase();
-                switch (cmd) {
-                    case 'a':
-                    case 'approve':
-                        state.gates[gateName].status = 'approved';
-                        state.gates[gateName].approved_at = new Date().toISOString();
-                        writeState(statusPath, state);
-                        console.log(chalk.green(`\nGate ${gateName} approved.`));
-                        rl.close();
-                        resolve();
-                        break;
-                    case 'q':
-                    case 'quit':
-                        console.log(chalk.yellow('\nExiting without approval.'));
-                        rl.close();
-                        process.exit(0);
-                        break;
-                    default:
-                        console.log(chalk.dim("Unknown command. Type 'a' to approve or 'q' to quit."));
-                        prompt();
-                }
-            });
-        };
-        prompt();
-    });
-}
-/**
- * Get artifact path for current phase.
- */
-function getArtifactForPhase(state) {
-    switch (state.phase) {
-        case 'specify':
-            return `codev/specs/${state.id}-${state.title}.md`;
-        case 'plan':
-            return `codev/plans/${state.id}-${state.title}.md`;
-        case 'review':
-            return `codev/reviews/${state.id}-${state.title}.md`;
-        default:
-            return null;
-    }
-}
-/**
- * Output structured result for --single-phase mode.
- * The Builder (outer Claude) parses this to understand what happened.
- */
-function outputSinglePhaseResult(state, status, gateName, reviews) {
-    const result = {
-        phase: state.phase,
-        plan_phase: state.current_plan_phase,
-        iteration: state.iteration,
-        status,
-        gate: gateName || null,
-    };
-    // Include verdicts if reviews were run
-    if (reviews && reviews.length > 0) {
-        result.verdicts = Object.fromEntries(reviews.map(r => [r.model, r.verdict]));
-    }
-    // Include artifact path
-    const artifact = getArtifactForPhase(state);
-    if (artifact) {
-        result.artifact = artifact;
-    }
-    // Output as JSON on a single line for easy parsing
-    console.log(`\n__PORCH_RESULT__${JSON.stringify(result)}`);
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//# sourceMappingURL=run.js.map