@neurcode-ai/cli 0.9.11 → 0.9.13

package/dist/commands/ship.js

@@ -0,0 +1,707 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shipCommand = shipCommand;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const project_root_1 = require("../utils/project-root");
+const state_1 = require("../utils/state");
+let chalk;
+try {
+    chalk = require('chalk');
+}
+catch {
+    chalk = {
+        green: (str) => str,
+        yellow: (str) => str,
+        red: (str) => str,
+        bold: (str) => str,
+        dim: (str) => str,
+        cyan: (str) => str,
+        white: (str) => str,
+    };
+}
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+const PLAN_ID_PATTERN = /Plan ID:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/gi;
+const WRITE_PATH_PATTERN = /✅\s+Written:\s+(.+)$/gm;
+function stripAnsi(value) {
+    return value.replace(ANSI_PATTERN, '');
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function shellTailLines(text, limit) {
+    return text
+        .split('\n')
+        .filter(Boolean)
+        .slice(-limit)
+        .join('\n');
+}
+function getCliEntryPath() {
+    return (0, path_1.resolve)(__dirname, '..', 'index.js');
+}
+function runCliCommand(cwd, args) {
+    return new Promise((resolvePromise) => {
+        const startedAt = Date.now();
+        const child = (0, child_process_1.spawn)(process.execPath, [getCliEntryPath(), ...args], {
+            cwd,
+            env: {
+                ...process.env,
+                CI: 'true',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            process.stdout.write(text);
+        });
+        child.stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            process.stderr.write(text);
+        });
+        child.on('close', (code) => {
+            resolvePromise({
+                code: code ?? 1,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startedAt,
+            });
+        });
+    });
+}
+function runShellCommand(cwd, command) {
+    return new Promise((resolvePromise) => {
+        const startedAt = Date.now();
+        const child = (0, child_process_1.spawn)(command, {
+            cwd,
+            env: {
+                ...process.env,
+            },
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            process.stdout.write(text);
+        });
+        child.stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            process.stderr.write(text);
+        });
+        child.on('close', (code) => {
+            resolvePromise({
+                code: code ?? 1,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startedAt,
+            });
+        });
+    });
+}
+function extractPlanId(output) {
+    const clean = stripAnsi(output);
+    let latest = null;
+    let match;
+    while ((match = PLAN_ID_PATTERN.exec(clean)) !== null) {
+        latest = match[1];
+    }
+    return latest;
+}
+function extractLastJsonObject(output) {
+    const clean = stripAnsi(output).trim();
+    const end = clean.lastIndexOf('}');
+    if (end < 0)
+        return null;
+    let start = clean.lastIndexOf('{', end);
+    while (start >= 0) {
+        const candidate = clean.slice(start, end + 1).trim();
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+            start = clean.lastIndexOf('{', start - 1);
+        }
+    }
+    return null;
+}
+function parseVerifyPayload(output) {
+    const parsed = extractLastJsonObject(output);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const record = parsed;
+    if (typeof record.verdict !== 'string' || typeof record.grade !== 'string') {
+        return null;
+    }
+    const rawViolations = Array.isArray(record.violations) ? record.violations : [];
+    const violations = rawViolations
+        .filter((item) => !!item && typeof item === 'object')
+        .map((item) => ({
+        file: typeof item.file === 'string' ? item.file : 'unknown',
+        rule: typeof item.rule === 'string' ? item.rule : 'unknown',
+        severity: typeof item.severity === 'string' ? item.severity : 'warn',
+        message: typeof item.message === 'string' ? item.message : undefined,
+        startLine: typeof item.startLine === 'number' ? item.startLine : undefined,
+    }));
+    return {
+        grade: record.grade,
+        score: typeof record.score === 'number' ? record.score : 0,
+        verdict: record.verdict,
+        violations,
+        message: typeof record.message === 'string' ? record.message : undefined,
+        adherenceScore: typeof record.adherenceScore === 'number' ? record.adherenceScore : undefined,
+        scopeGuardPassed: typeof record.scopeGuardPassed === 'boolean' ? record.scopeGuardPassed : undefined,
+        bloatCount: typeof record.bloatCount === 'number' ? record.bloatCount : undefined,
+        bloatFiles: Array.isArray(record.bloatFiles)
+            ? record.bloatFiles.filter((item) => typeof item === 'string')
+            : undefined,
+        plannedFilesModified: typeof record.plannedFilesModified === 'number' ? record.plannedFilesModified : undefined,
+        totalPlannedFiles: typeof record.totalPlannedFiles === 'number' ? record.totalPlannedFiles : undefined,
+        policyDecision: typeof record.policyDecision === 'string' ? record.policyDecision : undefined,
+    };
+}
+function collectApplyWrittenFiles(output) {
+    const clean = stripAnsi(output);
+    const files = [];
+    let match;
+    while ((match = WRITE_PATH_PATTERN.exec(clean)) !== null) {
+        files.push(match[1].trim());
+    }
+    return Array.from(new Set(files));
+}
+function runGit(cwd, args) {
+    const result = (0, child_process_1.spawnSync)('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return {
+        code: result.status ?? 1,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+    };
+}
+function ensureCleanTreeOrExit(cwd, allowDirty) {
+    const status = runGit(cwd, ['status', '--porcelain']);
+    const hasDirtyFiles = status.stdout.trim().length > 0;
+    if (hasDirtyFiles && !allowDirty) {
+        console.error(chalk.red('❌ Working tree is not clean.'));
+        console.error(chalk.dim('   `neurcode ship` requires a clean tree so auto-remediation can safely revert scope drift.'));
+        console.error(chalk.dim('   Commit/stash your changes or re-run with --allow-dirty if intentional.'));
+        process.exit(1);
+    }
+}
+function restoreScopeDriftFiles(cwd, files) {
+    const uniqueFiles = Array.from(new Set(files.filter(Boolean)));
+    if (uniqueFiles.length === 0)
+        return [];
+    const result = runGit(cwd, ['restore', '--worktree', '--source=HEAD', '--', ...uniqueFiles]);
+    if (result.code !== 0) {
+        return [];
+    }
+    return uniqueFiles;
+}
+function applySimplePolicyFixes(cwd, violations) {
+    const touched = [];
+    const byFile = new Map();
+    for (const violation of violations) {
+        if (!violation.file || violation.file === 'unknown')
+            continue;
+        if (!byFile.has(violation.file)) {
+            byFile.set(violation.file, []);
+        }
+        byFile.get(violation.file).push(violation);
+    }
+    for (const [file, fileViolations] of byFile.entries()) {
+        const fullPath = (0, path_1.resolve)(cwd, file);
+        if (!(0, fs_1.existsSync)(fullPath))
+            continue;
+        let content;
+        try {
+            content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        let nextContent = content;
+        const flattened = fileViolations
+            .map((entry) => `${entry.rule} ${entry.message || ''}`.toLowerCase())
+            .join(' ');
+        if (flattened.includes('console.log')) {
+            nextContent = nextContent
+                .split('\n')
+                .filter((line) => !/console\.log\s*\(/.test(line))
+                .join('\n');
+        }
+        if (flattened.includes('debugger')) {
+            nextContent = nextContent
+                .split('\n')
+                .filter((line) => !/\bdebugger\b/.test(line))
+                .join('\n');
+        }
+        if (flattened.includes('eval(') || flattened.includes('no eval')) {
+            nextContent = nextContent
+                .split('\n')
+                .filter((line) => !/\beval\s*\(/.test(line))
+                .join('\n');
+        }
+        if (nextContent !== content) {
+            if (content.endsWith('\n') && !nextContent.endsWith('\n')) {
+                nextContent += '\n';
+            }
+            (0, fs_1.writeFileSync)(fullPath, nextContent, 'utf-8');
+            touched.push(file);
+        }
+    }
+    return Array.from(new Set(touched));
+}
+function collectBlastRadius(cwd) {
+    let output = '';
+    try {
+        output = (0, child_process_1.execSync)('git diff --numstat', {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 1024 * 1024 * 1024,
+        });
+    }
+    catch {
+        return {
+            changedFiles: 0,
+            linesAdded: 0,
+            linesRemoved: 0,
+            netLines: 0,
+            topFiles: [],
+        };
+    }
+    const rows = [];
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const line of output.split('\n')) {
+        if (!line.trim())
+            continue;
+        const [addedRaw, removedRaw, ...pathParts] = line.split('\t');
+        if (!addedRaw || !removedRaw || pathParts.length === 0)
+            continue;
+        const path = pathParts.join('\t');
+        const added = addedRaw === '-' ? 0 : parseInt(addedRaw, 10);
+        const removed = removedRaw === '-' ? 0 : parseInt(removedRaw, 10);
+        if (!Number.isFinite(added) || !Number.isFinite(removed))
+            continue;
+        rows.push({ path, added, removed });
+        linesAdded += added;
+        linesRemoved += removed;
+    }
+    rows.sort((a, b) => b.added + b.removed - (a.added + a.removed));
+    return {
+        changedFiles: rows.length,
+        linesAdded,
+        linesRemoved,
+        netLines: linesAdded - linesRemoved,
+        topFiles: rows.slice(0, 10),
+    };
+}
+function inferTestCommand(cwd, explicit) {
+    if (explicit && explicit.trim()) {
+        return explicit.trim();
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm test --if-present';
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'yarn.lock')))
+        return 'yarn test';
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'package-lock.json')))
+        return 'npm test --if-present';
+    if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'package.json')))
+        return 'npm test --if-present';
+    return null;
+}
+function buildVerifyRepairIntent(goal, currentPlanId, verify, attempt) {
+    const failureLines = verify.violations
+        .slice(0, 12)
+        .map((v) => `- ${v.file} [${v.severity}] ${v.rule}${v.message ? `: ${v.message}` : ''}`)
+        .join('\n');
+    return [
+        `Original goal: ${goal}`,
+        `Auto-repair attempt: ${attempt}`,
+        `Current failing plan ID: ${currentPlanId}`,
+        '',
+        'Repair only what is required to pass governance verification.',
+        'Constraints:',
+        '- Keep edits minimal and localized.',
+        '- Do not add new dependencies.',
+        '- Remove unplanned file changes.',
+        '- Preserve intended behavior.',
+        '',
+        'Current verification failures:',
+        failureLines || '- Scope or policy checks failed.',
+    ].join('\n');
+}
+function buildTestRepairIntent(goal, currentPlanId, testOutput, attempt) {
+    return [
+        `Original goal: ${goal}`,
+        `Auto-repair attempt: ${attempt}`,
+        `Current plan ID: ${currentPlanId}`,
+        '',
+        'Fix test failures with the smallest safe patch.',
+        'Constraints:',
+        '- Do not expand scope.',
+        '- Keep behavior changes limited to what tests require.',
+        '- Do not add risky dependencies.',
+        '',
+        'Test failure context (tail):',
+        shellTailLines(testOutput, 40) || '(no test output captured)',
+    ].join('\n');
+}
+function classifyRiskLabel(score) {
+    if (score >= 70)
+        return 'HIGH';
+    if (score >= 40)
+        return 'MEDIUM';
+    return 'LOW';
+}
+function computeRiskScore(verify, blast, testsPassed, remediationAttempts) {
+    const adherence = Number.isFinite(verify.adherenceScore) ? verify.adherenceScore : verify.score;
+    let risk = 0;
+    if (verify.verdict === 'FAIL')
+        risk += 52;
+    else if (verify.verdict === 'WARN')
+        risk += 30;
+    else
+        risk += 12;
+    risk += Math.round((100 - clamp(adherence, 0, 100)) * 0.3);
+    risk += Math.min(28, verify.violations.length * 4);
+    risk += Math.min(20, Math.max(0, blast.changedFiles - 3) * 2);
+    risk += Math.min(18, Math.floor((blast.linesAdded + blast.linesRemoved) / 100) * 3);
+    risk += remediationAttempts * 5;
+    if (!testsPassed) {
+        risk += 20;
+    }
+    return clamp(Math.round(risk), 0, 100);
+}
+function writeMergeConfidenceArtifacts(cwd, card) {
+    const outDir = (0, path_1.join)(cwd, '.neurcode', 'ship');
+    (0, fs_1.mkdirSync)(outDir, { recursive: true });
+    const ts = card.generatedAt.replace(/[:.]/g, '-');
+    const jsonPath = (0, path_1.join)(outDir, `merge-confidence-${ts}.json`);
+    const markdownPath = (0, path_1.join)(outDir, `merge-confidence-${ts}.md`);
+    const markdown = [
+        '# Merge Confidence Card',
+        '',
+        `- Status: **${card.status}**`,
+        `- Goal: ${card.goal}`,
+        `- Branch: ${card.repository.branch}`,
+        `- Head SHA: ${card.repository.headSha}`,
+        `- Initial Plan: ${card.plans.initialPlanId}`,
+        `- Final Plan: ${card.plans.finalPlanId}`,
+        '',
+        '## Governance',
+        '',
+        `- Verdict: **${card.verification.verdict}**`,
+        `- Grade: **${card.verification.grade}**`,
+        `- Score: **${card.verification.adherenceScore ?? card.verification.score}**`,
+        `- Violations: **${card.verification.violations.length}**`,
+        '',
+        '## Blast Radius',
+        '',
+        `- Files Changed: **${card.blastRadius.changedFiles}**`,
+        `- Lines Added: **${card.blastRadius.linesAdded}**`,
+        `- Lines Removed: **${card.blastRadius.linesRemoved}**`,
+        `- Net Lines: **${card.blastRadius.netLines}**`,
+        '',
+        '## Risk',
+        '',
+        `- Risk Score: **${card.risk.score}/100 (${card.risk.label})**`,
+        `- Merge Confidence: **${card.risk.mergeConfidence}/100**`,
+        '',
+        '## Auto-Remediation',
+        '',
+        `- Attempts Used: **${card.remediation.attemptsUsed}/${card.remediation.maxAttempts}**`,
+        `- Actions: ${card.remediation.actions.length > 0 ? card.remediation.actions.join('; ') : 'None'}`,
+        '',
+        '## Tests',
+        '',
+        `- Skipped: **${card.tests.skipped ? 'yes' : 'no'}**`,
+        `- Passed: **${card.tests.passed ? 'yes' : 'no'}**`,
+        card.tests.command ? `- Command: \`${card.tests.command}\`` : '- Command: none',
+        '',
+        '## Top Changed Files',
+        '',
+        ...(card.blastRadius.topFiles.length > 0
+            ? card.blastRadius.topFiles.map((file) => `- ${file.path} (+${file.added}/-${file.removed})`)
+            : ['- none']),
+        '',
+        '## Evidence (Violations)',
+        '',
+        ...(card.verification.violations.length > 0
+            ? card.verification.violations.slice(0, 20).map((v) => `- ${v.file}${typeof v.startLine === 'number' ? `:${v.startLine}` : ''} [${v.severity}] ${v.rule}${v.message ? ` - ${v.message}` : ''}`)
+            : ['- none']),
+        '',
+    ].join('\n');
+    (0, fs_1.writeFileSync)(jsonPath, JSON.stringify(card, null, 2) + '\n', 'utf-8');
+    (0, fs_1.writeFileSync)(markdownPath, markdown, 'utf-8');
+    return { jsonPath, markdownPath };
+}
+async function runPlanAndApply(cwd, intent, projectId) {
+    const planArgs = ['plan', intent, '--force-plan'];
+    if (projectId) {
+        planArgs.push('--project-id', projectId);
+    }
+    const planRun = await runCliCommand(cwd, planArgs);
+    const planOutput = `${planRun.stdout}\n${planRun.stderr}`;
+    const planId = extractPlanId(planOutput);
+    if (planRun.code !== 0 || !planId) {
+        return { planId: null, planRun, applyRun: null, writtenFiles: [] };
+    }
+    const applyArgs = ['apply', planId, '--force'];
+    const applyRun = await runCliCommand(cwd, applyArgs);
+    const writtenFiles = collectApplyWrittenFiles(`${applyRun.stdout}\n${applyRun.stderr}`);
+    return { planId, planRun, applyRun, writtenFiles };
+}
+async function shipCommand(goal, options) {
+    const startedAt = Date.now();
+    const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+    const maxFixAttempts = clamp(options.maxFixAttempts ?? 2, 0, 5);
+    const remediationActions = [];
+    const repairPlanIds = [];
+    const recordVerify = options.record !== false;
+    if (!goal || !goal.trim()) {
+        console.error(chalk.red('❌ Error: goal cannot be empty.'));
+        console.log(chalk.dim('Usage: neurcode ship "<goal>"'));
+        process.exit(1);
+    }
+    ensureCleanTreeOrExit(cwd, options.allowDirty === true);
+    console.log(chalk.bold.cyan('\n🚀 Neurcode Ship\n'));
+    console.log(chalk.dim(`Goal: ${goal.trim()}`));
+    console.log(chalk.dim(`Workspace: ${cwd}\n`));
+    console.log(chalk.dim('1/4 Planning and applying initial implementation...'));
+    const initial = await runPlanAndApply(cwd, goal.trim(), options.projectId);
+    if (!initial.planId || initial.planRun.code !== 0 || !initial.applyRun || initial.applyRun.code !== 0) {
+        console.error(chalk.red('\n❌ Ship failed during initial plan/apply.'));
+        process.exit(1);
+    }
+    let currentPlanId = initial.planId;
+    try {
+        (0, state_1.setActivePlanId)(currentPlanId);
+        (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
+    }
+    catch {
+        // Non-critical state write.
+    }
+    let verifyTotalMs = 0;
+    let testsTotalMs = 0;
+    let remediationAttemptsUsed = 0;
+    let verifyPayload = null;
+    let verifyExitCode = 1;
+    let testsPassed = options.skipTests === true;
+    let testsExitCode = options.skipTests ? 0 : 1;
+    let testsAttempts = 0;
+    let testCommand = inferTestCommand(cwd, options.testCommand);
+    while (true) {
+        console.log(chalk.dim('\n2/4 Running governance verification...'));
+        const verifyArgs = ['verify', '--plan-id', currentPlanId, '--json'];
+        if (recordVerify) {
+            verifyArgs.push('--record');
+        }
+        const verifyRun = await runCliCommand(cwd, verifyArgs);
+        verifyTotalMs += verifyRun.durationMs;
+        verifyExitCode = verifyRun.code;
+        const parsedVerify = parseVerifyPayload(`${verifyRun.stdout}\n${verifyRun.stderr}`);
+        if (!parsedVerify) {
+            console.error(chalk.red('\n❌ Could not parse verify JSON output.'));
+            process.exit(1);
+        }
+        verifyPayload = parsedVerify;
+        const verifyPassed = verifyRun.code === 0 && parsedVerify.verdict === 'PASS';
+        if (verifyPassed) {
+            console.log(chalk.green('✅ Governance verification passed.'));
+            break;
+        }
+        if (remediationAttemptsUsed >= maxFixAttempts) {
+            console.log(chalk.red(`❌ Verification still failing after ${remediationAttemptsUsed} remediation attempt(s).`));
+            break;
+        }
+        remediationAttemptsUsed += 1;
+        console.log(chalk.yellow(`⚠️  Auto-remediation attempt ${remediationAttemptsUsed}/${maxFixAttempts}`));
+        const scopeDriftFiles = parsedVerify.violations
+            .filter((v) => v.rule === 'scope_guard' && v.file)
+            .map((v) => v.file);
+        const restored = restoreScopeDriftFiles(cwd, scopeDriftFiles);
+        if (restored.length > 0) {
+            remediationActions.push(`restored_scope_files=${restored.join(',')}`);
+            console.log(chalk.dim(`   Restored ${restored.length} out-of-scope file(s) from HEAD.`));
+        }
+        const policyFixes = applySimplePolicyFixes(cwd, parsedVerify.violations);
+        if (policyFixes.length > 0) {
+            remediationActions.push(`policy_cleanup_files=${policyFixes.join(',')}`);
+            console.log(chalk.dim(`   Applied simple policy cleanup to ${policyFixes.length} file(s).`));
+        }
+        if (restored.length > 0 || policyFixes.length > 0) {
+            continue;
+        }
+        console.log(chalk.dim('   Falling back to constrained repair plan...'));
+        const repairIntent = buildVerifyRepairIntent(goal.trim(), currentPlanId, parsedVerify, remediationAttemptsUsed);
+        const repair = await runPlanAndApply(cwd, repairIntent, options.projectId);
+        if (!repair.planId || repair.planRun.code !== 0 || !repair.applyRun || repair.applyRun.code !== 0) {
+            remediationActions.push('repair_plan_failed');
+            console.log(chalk.red('   Repair plan/apply failed.'));
+            break;
+        }
+        currentPlanId = repair.planId;
+        repairPlanIds.push(repair.planId);
+        remediationActions.push(`repair_plan_applied=${repair.planId}`);
+        try {
+            (0, state_1.setActivePlanId)(currentPlanId);
+            (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
+        }
+        catch {
+            // Non-critical state write.
+        }
+    }
+    if (!verifyPayload) {
+        console.error(chalk.red('❌ Verification did not produce a valid payload.'));
+        process.exit(1);
+    }
+    const verifyPassedFinal = verifyExitCode === 0 && verifyPayload.verdict === 'PASS';
+    if (verifyPassedFinal && !options.skipTests) {
+        testsAttempts += 1;
+        if (!testCommand) {
+            console.log(chalk.yellow('\n⚠️  No test command detected. Skipping tests.'));
+            testsPassed = true;
+            testsExitCode = 0;
+        }
+        else {
+            console.log(chalk.dim(`\n3/4 Running tests: ${testCommand}`));
+            const testRun = await runShellCommand(cwd, testCommand);
+            testsTotalMs += testRun.durationMs;
+            testsExitCode = testRun.code;
+            testsPassed = testRun.code === 0;
+            if (!testsPassed && remediationAttemptsUsed < maxFixAttempts) {
+                remediationAttemptsUsed += 1;
+                console.log(chalk.yellow(`⚠️  Test failure auto-remediation attempt ${remediationAttemptsUsed}/${maxFixAttempts}`));
+                const repairIntent = buildTestRepairIntent(goal.trim(), currentPlanId, `${testRun.stdout}\n${testRun.stderr}`, remediationAttemptsUsed);
+                const repair = await runPlanAndApply(cwd, repairIntent, options.projectId);
+                if (repair.planId && repair.planRun.code === 0 && repair.applyRun && repair.applyRun.code === 0) {
+                    currentPlanId = repair.planId;
+                    repairPlanIds.push(repair.planId);
+                    remediationActions.push(`test_repair_plan_applied=${repair.planId}`);
+                    try {
+                        (0, state_1.setActivePlanId)(currentPlanId);
+                        (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
+                    }
+                    catch {
+                        // Non-critical state write.
+                    }
+                    const verifyAfterTestRepair = await runCliCommand(cwd, ['verify', '--plan-id', currentPlanId, '--json', ...(recordVerify ? ['--record'] : [])]);
+                    verifyTotalMs += verifyAfterTestRepair.durationMs;
+                    const parsedAfterRepair = parseVerifyPayload(`${verifyAfterTestRepair.stdout}\n${verifyAfterTestRepair.stderr}`);
+                    if (parsedAfterRepair) {
+                        verifyPayload = parsedAfterRepair;
+                        verifyExitCode = verifyAfterTestRepair.code;
+                    }
+                    testsAttempts += 1;
+                    const finalTestRun = await runShellCommand(cwd, testCommand);
+                    testsTotalMs += finalTestRun.durationMs;
+                    testsExitCode = finalTestRun.code;
+                    testsPassed = finalTestRun.code === 0;
+                }
+                else {
+                    remediationActions.push('test_repair_plan_failed');
+                }
+            }
+        }
+    }
+    const blast = collectBlastRadius(cwd);
+    const riskScore = computeRiskScore(verifyPayload, blast, testsPassed, remediationAttemptsUsed);
+    const riskLabel = classifyRiskLabel(riskScore);
+    const status = verifyExitCode === 0 && verifyPayload.verdict === 'PASS' && testsPassed ? 'READY_TO_MERGE' : 'BLOCKED';
+    const branch = (() => {
+        const branchResult = runGit(cwd, ['rev-parse', '--abbrev-ref', 'HEAD']);
+        return branchResult.code === 0 ? branchResult.stdout.trim() : 'unknown';
+    })();
+    const headSha = (() => {
+        const headResult = runGit(cwd, ['rev-parse', 'HEAD']);
+        return headResult.code === 0 ? headResult.stdout.trim() : 'unknown';
+    })();
+    const card = {
+        status,
+        generatedAt: new Date().toISOString(),
+        goal: goal.trim(),
+        repository: {
+            root: cwd,
+            branch,
+            headSha,
+        },
+        plans: {
+            initialPlanId: initial.planId,
+            finalPlanId: currentPlanId,
+            repairPlanIds,
+        },
+        verification: verifyPayload,
+        tests: {
+            skipped: options.skipTests === true,
+            command: testCommand || undefined,
+            passed: testsPassed,
+            attempts: testsAttempts,
+            lastExitCode: testsExitCode,
+        },
+        remediation: {
+            maxAttempts: maxFixAttempts,
+            attemptsUsed: remediationAttemptsUsed,
+            actions: remediationActions,
+        },
+        blastRadius: blast,
+        risk: {
+            score: riskScore,
+            label: riskLabel,
+            mergeConfidence: 100 - riskScore,
+        },
+        timingsMs: {
+            initialPlan: initial.planRun.durationMs,
+            initialApply: initial.applyRun ? initial.applyRun.durationMs : 0,
+            verifyTotal: verifyTotalMs,
+            testsTotal: testsTotalMs,
+            total: Date.now() - startedAt,
+        },
+    };
+    const artifactPaths = writeMergeConfidenceArtifacts(cwd, card);
+    console.log(chalk.dim('\n4/4 Merge Confidence Card generated.'));
+    console.log(chalk.dim(`   JSON: ${artifactPaths.jsonPath}`));
+    console.log(chalk.dim(`   Markdown: ${artifactPaths.markdownPath}`));
+    console.log('');
+    if (status === 'READY_TO_MERGE') {
+        console.log(chalk.bold.green('✅ Ready to merge'));
+        console.log(chalk.green(`   Confidence: ${card.risk.mergeConfidence}/100 | Risk: ${card.risk.label}`));
+    }
+    else {
+        console.log(chalk.bold.red('❌ Blocked'));
+        console.log(chalk.red(`   Verdict: ${verifyPayload.verdict} | Tests: ${testsPassed ? 'PASS' : 'FAIL'}`));
+        console.log(chalk.red(`   Confidence: ${card.risk.mergeConfidence}/100 | Risk: ${card.risk.label}`));
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            status: card.status,
+            finalPlanId: card.plans.finalPlanId,
+            mergeConfidence: card.risk.mergeConfidence,
+            riskScore: card.risk.score,
+            verification: {
+                verdict: card.verification.verdict,
+                grade: card.verification.grade,
+                score: card.verification.adherenceScore ?? card.verification.score,
+                violations: card.verification.violations.length,
+            },
+            tests: {
+                skipped: card.tests.skipped,
+                passed: card.tests.passed,
+            },
+            artifacts: artifactPaths,
+        }, null, 2));
+    }
+    process.exit(status === 'READY_TO_MERGE' ? 0 : 2);
+}
+//# sourceMappingURL=ship.js.map