@neurcode-ai/cli 0.9.26 → 0.9.28

package/dist/commands/ship.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shipCommand = shipCommand;
+exports.shipResumeCommand = shipResumeCommand;
+exports.shipRunsCommand = shipRunsCommand;
+exports.shipAttestationVerifyCommand = shipAttestationVerifyCommand;
 const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const api_client_1 = require("../api-client");
@@ -27,12 +31,145 @@ catch {
 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 getShipRunDir(cwd) {
+    return (0, path_1.join)(cwd, '.neurcode', 'ship', 'runs');
+}
+function getShipRunPath(cwd, runId) {
+    return (0, path_1.join)(getShipRunDir(cwd), `${runId}.json`);
+}
+function saveShipCheckpoint(cwd, checkpoint) {
+    const dir = getShipRunDir(cwd);
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(getShipRunPath(cwd, checkpoint.runId), JSON.stringify(checkpoint, null, 2) + '\n', 'utf-8');
+}
+function loadShipCheckpoint(cwd, runId) {
+    const path = getShipRunPath(cwd, runId);
+    if (!(0, fs_1.existsSync)(path))
+        return null;
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        if (parsed &&
+            parsed.version === 1 &&
+            typeof parsed.runId === 'string' &&
+            typeof parsed.goal === 'string' &&
+            typeof parsed.cwd === 'string') {
+            return parsed;
+        }
+    }
+    catch {
+        // Invalid checkpoint payload.
+    }
+    return null;
+}
+function listShipRunSummaries(cwd) {
+    const dir = getShipRunDir(cwd);
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const summaries = [];
+    for (const entry of (0, fs_1.readdirSync)(dir)) {
+        if (!entry.endsWith('.json'))
+            continue;
+        const runId = entry.replace(/\.json$/, '');
+        const checkpoint = loadShipCheckpoint(cwd, runId);
+        if (!checkpoint)
+            continue;
+        summaries.push({
+            runId: checkpoint.runId,
+            status: checkpoint.status,
+            stage: checkpoint.stage,
+            goal: checkpoint.goal,
+            updatedAt: checkpoint.updatedAt,
+            currentPlanId: checkpoint.currentPlanId,
+            resultStatus: checkpoint.resultStatus,
+        });
+    }
+    summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return summaries;
+}
+function createShipCheckpoint(input) {
+    return {
+        version: 1,
+        runId: input.runId,
+        goal: input.goal,
+        cwd: input.cwd,
+        status: 'running',
+        stage: 'bootstrap',
+        startedAt: input.startedAt,
+        updatedAt: new Date().toISOString(),
+        options: {
+            projectId: input.options.projectId || null,
+            maxFixAttempts: input.maxFixAttempts,
+            allowDirty: input.options.allowDirty === true,
+            skipTests: input.options.skipTests === true,
+            testCommand: input.options.testCommand || null,
+            record: input.options.record !== false,
+            requirePass: input.requirePass,
+            requirePolicyLock: input.requirePolicyLock,
+            skipPolicyLock: input.skipPolicyLock,
+            publishCard: input.options.publishCard !== false,
+        },
+        baselineDirtyPaths: [],
+        initialPlanId: null,
+        currentPlanId: null,
+        repairPlanIds: [],
+        remediationAttemptsUsed: 0,
+        verifyExitCode: null,
+        verifyPayload: null,
+        tests: {
+            skipped: input.options.skipTests === true,
+            passed: input.options.skipTests === true,
+            exitCode: input.options.skipTests === true ? 0 : null,
+            attempts: 0,
+            command: input.options.testCommand || null,
+        },
+        resultStatus: null,
+        artifacts: null,
+        shareCard: null,
+        audit: null,
+        error: null,
+    };
+}
 function stripAnsi(value) {
     return value.replace(ANSI_PATTERN, '');
 }
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
+function parsePositiveInt(raw) {
+    if (!raw)
+        return null;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return null;
+    return Math.floor(parsed);
+}
+function resolveTimeoutMs(raw, fallbackMs) {
+    const parsed = parsePositiveInt(raw);
+    const candidate = parsed ?? fallbackMs;
+    return clamp(candidate, 30_000, 60 * 60 * 1000);
+}
+function resolveHeartbeatMs(raw, fallbackMs) {
+    const parsed = parsePositiveInt(raw);
+    const candidate = parsed ?? fallbackMs;
+    return clamp(candidate, 5_000, 120_000);
+}
+function getPlanTimeoutMs() {
+    return resolveTimeoutMs(process.env.NEURCODE_SHIP_PLAN_TIMEOUT_MS, resolveTimeoutMs(process.env.NEURCODE_SHIP_STEP_TIMEOUT_MS, 8 * 60 * 1000));
+}
+function getApplyTimeoutMs() {
+    return resolveTimeoutMs(process.env.NEURCODE_SHIP_APPLY_TIMEOUT_MS, resolveTimeoutMs(process.env.NEURCODE_SHIP_STEP_TIMEOUT_MS, 15 * 60 * 1000));
+}
+function getVerifyTimeoutMs() {
+    return resolveTimeoutMs(process.env.NEURCODE_SHIP_VERIFY_TIMEOUT_MS, resolveTimeoutMs(process.env.NEURCODE_SHIP_STEP_TIMEOUT_MS, 6 * 60 * 1000));
+}
+function getTestTimeoutMs() {
+    return resolveTimeoutMs(process.env.NEURCODE_SHIP_TEST_TIMEOUT_MS, resolveTimeoutMs(process.env.NEURCODE_SHIP_STEP_TIMEOUT_MS, 20 * 60 * 1000));
+}
+function getHeartbeatIntervalMs() {
+    return resolveHeartbeatMs(process.env.NEURCODE_SHIP_HEARTBEAT_MS, 30_000);
+}
 function shellTailLines(text, limit) {
     return text
         .split('\n')
@@ -40,12 +177,46 @@ function shellTailLines(text, limit) {
         .slice(-limit)
         .join('\n');
 }
+function emitShipJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+function inferStepStatus(run) {
+    if (!run)
+        return 'SKIPPED';
+    const stderr = (run.stderr || '').toLowerCase();
+    if (run.code === 124 || stderr.includes('exceeded timeout')) {
+        return 'TIMEOUT';
+    }
+    return run.code === 0 ? 'SUCCESS' : 'FAILED';
+}
+function recordRunStep(steps, input) {
+    const nowIso = new Date().toISOString();
+    const run = input.run;
+    const durationMs = run?.durationMs ?? 0;
+    const startedAt = input.startedAt
+        ? input.startedAt
+        : new Date(Date.now() - Math.max(0, durationMs)).toISOString();
+    steps.push({
+        stage: input.stage,
+        attempt: input.attempt,
+        status: inferStepStatus(run),
+        startedAt,
+        endedAt: nowIso,
+        durationMs,
+        ...(run ? { exitCode: run.code } : {}),
+        ...(input.planId ? { planId: input.planId } : {}),
+        ...(input.message ? { message: input.message } : {}),
+    });
+}
 function getCliEntryPath() {
     return (0, path_1.resolve)(__dirname, '..', 'index.js');
 }
-function runCliCommand(cwd, args, extraEnv) {
+function runCliCommand(cwd, args, extraEnv, execution) {
     return new Promise((resolvePromise) => {
         const startedAt = Date.now();
+        const timeoutMs = execution?.timeoutMs ?? getPlanTimeoutMs();
+        const heartbeatMs = execution?.heartbeatMs ?? getHeartbeatIntervalMs();
+        const commandLabel = execution?.label || `neurcode ${args.join(' ')}`;
         const child = (0, child_process_1.spawn)(process.execPath, [getCliEntryPath(), ...args], {
             cwd,
             env: {
@@ -57,6 +228,61 @@ function runCliCommand(cwd, args, extraEnv) {
         });
         let stdout = '';
         let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        let timeoutHandle = null;
+        let heartbeatHandle = null;
+        let forceKillHandle = null;
+        const finalize = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (heartbeatHandle)
+                clearInterval(heartbeatHandle);
+            if (forceKillHandle)
+                clearTimeout(forceKillHandle);
+            resolvePromise({
+                code,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startedAt,
+            });
+        };
+        timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            const timeoutMessage = `⏱️  ${commandLabel} exceeded timeout (${Math.round(timeoutMs / 1000)}s). Terminating.`;
+            stderr += `${timeoutMessage}\n`;
+            console.error(chalk.red(timeoutMessage));
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                // Ignore process termination errors.
+            }
+            forceKillHandle = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // Ignore process termination errors.
+                }
+            }, 5_000);
+            if (typeof forceKillHandle.unref === 'function') {
+                forceKillHandle.unref();
+            }
+        }, timeoutMs);
+        if (typeof timeoutHandle.unref === 'function') {
+            timeoutHandle.unref();
+        }
+        heartbeatHandle = setInterval(() => {
+            const elapsedSeconds = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
+            console.log(chalk.dim(`⏳ ${commandLabel} still running (${elapsedSeconds}s elapsed)...`));
+        }, heartbeatMs);
+        if (typeof heartbeatHandle.unref === 'function') {
+            heartbeatHandle.unref();
+        }
         child.stdout.on('data', (chunk) => {
             const text = chunk.toString();
             stdout += text;
@@ -67,19 +293,25 @@ function runCliCommand(cwd, args, extraEnv) {
             stderr += text;
             process.stderr.write(text);
         });
+        child.on('error', (error) => {
+            stderr += `${error instanceof Error ? error.message : String(error)}\n`;
+            finalize(1);
+        });
         child.on('close', (code) => {
-            resolvePromise({
-                code: code ?? 1,
-                stdout,
-                stderr,
-                durationMs: Date.now() - startedAt,
-            });
+            if (timedOut) {
+                finalize(124);
+                return;
+            }
+            finalize(code ?? 1);
         });
     });
 }
-function runShellCommand(cwd, command) {
+function runShellCommand(cwd, command, execution) {
     return new Promise((resolvePromise) => {
         const startedAt = Date.now();
+        const timeoutMs = execution?.timeoutMs ?? getTestTimeoutMs();
+        const heartbeatMs = execution?.heartbeatMs ?? getHeartbeatIntervalMs();
+        const commandLabel = execution?.label || command;
         const child = (0, child_process_1.spawn)(command, {
             cwd,
             env: {
@@ -90,6 +322,61 @@ function runShellCommand(cwd, command) {
         });
         let stdout = '';
         let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        let timeoutHandle = null;
+        let heartbeatHandle = null;
+        let forceKillHandle = null;
+        const finalize = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (heartbeatHandle)
+                clearInterval(heartbeatHandle);
+            if (forceKillHandle)
+                clearTimeout(forceKillHandle);
+            resolvePromise({
+                code,
+                stdout,
+                stderr,
+                durationMs: Date.now() - startedAt,
+            });
+        };
+        timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            const timeoutMessage = `⏱️  ${commandLabel} exceeded timeout (${Math.round(timeoutMs / 1000)}s). Terminating.`;
+            stderr += `${timeoutMessage}\n`;
+            console.error(chalk.red(timeoutMessage));
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                // Ignore process termination errors.
+            }
+            forceKillHandle = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // Ignore process termination errors.
+                }
+            }, 5_000);
+            if (typeof forceKillHandle.unref === 'function') {
+                forceKillHandle.unref();
+            }
+        }, timeoutMs);
+        if (typeof timeoutHandle.unref === 'function') {
+            timeoutHandle.unref();
+        }
+        heartbeatHandle = setInterval(() => {
+            const elapsedSeconds = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
+            console.log(chalk.dim(`⏳ ${commandLabel} still running (${elapsedSeconds}s elapsed)...`));
+        }, heartbeatMs);
+        if (typeof heartbeatHandle.unref === 'function') {
+            heartbeatHandle.unref();
+        }
         child.stdout.on('data', (chunk) => {
             const text = chunk.toString();
             stdout += text;
@@ -100,13 +387,16 @@ function runShellCommand(cwd, command) {
             stderr += text;
             process.stderr.write(text);
         });
+        child.on('error', (error) => {
+            stderr += `${error instanceof Error ? error.message : String(error)}\n`;
+            finalize(1);
+        });
         child.on('close', (code) => {
-            resolvePromise({
-                code: code ?? 1,
-                stdout,
-                stderr,
-                durationMs: Date.now() - startedAt,
-            });
+            if (timedOut) {
+                finalize(124);
+                return;
+            }
+            finalize(code ?? 1);
         });
     });
 }
@@ -154,6 +444,104 @@ function parseVerifyPayload(output) {
         message: typeof item.message === 'string' ? item.message : undefined,
         startLine: typeof item.startLine === 'number' ? item.startLine : undefined,
     }));
+    const policyLock = record.policyLock && typeof record.policyLock === 'object' && !Array.isArray(record.policyLock)
+        ? (() => {
+            const raw = record.policyLock;
+            const mismatches = Array.isArray(raw.mismatches)
+                ? raw.mismatches
+                    .filter((item) => !!item && typeof item === 'object')
+                    .map((item) => ({
+                    code: typeof item.code === 'string' ? item.code : 'UNKNOWN',
+                    message: typeof item.message === 'string' ? item.message : '',
+                    expected: typeof item.expected === 'string' ? item.expected : undefined,
+                    actual: typeof item.actual === 'string' ? item.actual : undefined,
+                }))
+                : [];
+            return {
+                enforced: raw.enforced === true,
+                matched: raw.matched !== false,
+                path: typeof raw.path === 'string' ? raw.path : '',
+                mismatches,
+            };
+        })()
+        : undefined;
+    const policyExceptions = record.policyExceptions && typeof record.policyExceptions === 'object' && !Array.isArray(record.policyExceptions)
+        ? (() => {
+            const raw = record.policyExceptions;
+            const matchedExceptionIds = Array.isArray(raw.matchedExceptionIds)
+                ? raw.matchedExceptionIds.filter((item) => typeof item === 'string')
+                : [];
+            const suppressedViolations = Array.isArray(raw.suppressedViolations)
+                ? raw.suppressedViolations
+                    .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,
+                    exceptionId: typeof item.exceptionId === 'string' ? item.exceptionId : 'unknown',
+                    reason: typeof item.reason === 'string' ? item.reason : '',
+                    expiresAt: typeof item.expiresAt === 'string' ? item.expiresAt : '',
+                    startLine: typeof item.startLine === 'number' ? item.startLine : undefined,
+                }))
+                : [];
+            return {
+                configured: typeof raw.configured === 'number' ? raw.configured : 0,
+                active: typeof raw.active === 'number' ? raw.active : 0,
+                usable: typeof raw.usable === 'number' ? raw.usable : undefined,
+                matched: typeof raw.matched === 'number' ? raw.matched : matchedExceptionIds.length,
+                suppressed: typeof raw.suppressed === 'number' ? raw.suppressed : suppressedViolations.length,
+                blocked: typeof raw.blocked === 'number' ? raw.blocked : undefined,
+                matchedExceptionIds,
+                suppressedViolations,
+                blockedViolations: Array.isArray(raw.blockedViolations)
+                    ? raw.blockedViolations
+                        .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,
+                    }))
+                    : undefined,
+            };
+        })()
+        : undefined;
+    const policyGovernance = record.policyGovernance && typeof record.policyGovernance === 'object' && !Array.isArray(record.policyGovernance)
+        ? (() => {
+            const raw = record.policyGovernance;
+            const approvalsRaw = raw.exceptionApprovals && typeof raw.exceptionApprovals === 'object' && !Array.isArray(raw.exceptionApprovals)
+                ? raw.exceptionApprovals
+                : null;
+            const auditRaw = raw.audit && typeof raw.audit === 'object' && !Array.isArray(raw.audit)
+                ? raw.audit
+                : null;
+            return {
+                exceptionApprovals: approvalsRaw
+                    ? {
+                        required: approvalsRaw.required === true,
+                        minApprovals: typeof approvalsRaw.minApprovals === 'number' ? approvalsRaw.minApprovals : 1,
+                        disallowSelfApproval: approvalsRaw.disallowSelfApproval !== false,
+                        allowedApprovers: Array.isArray(approvalsRaw.allowedApprovers)
+                            ? approvalsRaw.allowedApprovers.filter((item) => typeof item === 'string')
+                            : [],
+                    }
+                    : undefined,
+                audit: auditRaw
+                    ? {
+                        requireIntegrity: auditRaw.requireIntegrity === true,
+                        valid: auditRaw.valid !== false,
+                        issues: Array.isArray(auditRaw.issues)
+                            ? auditRaw.issues.filter((item) => typeof item === 'string')
+                            : [],
+                        lastHash: typeof auditRaw.lastHash === 'string' ? auditRaw.lastHash : null,
+                        eventCount: typeof auditRaw.eventCount === 'number' ? auditRaw.eventCount : 0,
+                    }
+                    : undefined,
+            };
+        })()
+        : undefined;
     return {
         grade: record.grade,
         score: typeof record.score === 'number' ? record.score : 0,
@@ -170,6 +558,59 @@ function parseVerifyPayload(output) {
         plannedFilesModified: typeof record.plannedFilesModified === 'number' ? record.plannedFilesModified : undefined,
         totalPlannedFiles: typeof record.totalPlannedFiles === 'number' ? record.totalPlannedFiles : undefined,
         policyDecision: typeof record.policyDecision === 'string' ? record.policyDecision : undefined,
+        policyLock,
+        policyExceptions,
+        policyGovernance,
+    };
+}
+function parsePlanPayload(output) {
+    const parsed = extractLastJsonObject(output);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const record = parsed;
+    if (typeof record.success !== 'boolean') {
+        return null;
+    }
+    const planIdValue = record.planId;
+    const planId = typeof planIdValue === 'string' && planIdValue.trim().length > 0 ? planIdValue : null;
+    return {
+        success: record.success,
+        planId,
+        sessionId: typeof record.sessionId === 'string' ? record.sessionId : null,
+        projectId: typeof record.projectId === 'string' ? record.projectId : null,
+        mode: typeof record.mode === 'string' ? record.mode : undefined,
+        cached: typeof record.cached === 'boolean' ? record.cached : undefined,
+        timestamp: typeof record.timestamp === 'string' ? record.timestamp : undefined,
+        message: typeof record.message === 'string' ? record.message : undefined,
+    };
+}
+function parseApplyPayload(output) {
+    const parsed = extractLastJsonObject(output);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const record = parsed;
+    if (typeof record.success !== 'boolean' || typeof record.planId !== 'string') {
+        return null;
+    }
+    const files = Array.isArray(record.files)
+        ? record.files
+            .filter((item) => !!item && typeof item === 'object')
+            .map((item) => ({
+            path: typeof item.path === 'string' ? item.path : '',
+            content: typeof item.content === 'string' ? item.content : '',
+        }))
+            .filter((item) => item.path.length > 0)
+        : [];
+    const writtenFiles = Array.isArray(record.writtenFiles)
+        ? record.writtenFiles.filter((item) => typeof item === 'string')
+        : undefined;
+    return {
+        success: record.success,
+        planId: record.planId,
+        filesGenerated: typeof record.filesGenerated === 'number' ? record.filesGenerated : files.length,
+        files,
+        writtenFiles,
+        message: typeof record.message === 'string' ? record.message : undefined,
     };
 }
 function isInfoOnlyGovernanceResult(payload) {
@@ -238,11 +679,9 @@ function ensureCleanTreeOrExit(cwd, allowDirty) {
     });
     const hasDirtyFiles = relevantPaths.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.'));
-        console.error(chalk.dim(`   Dirty paths: ${relevantPaths.slice(0, 5).join(', ')}`));
-        process.exit(1);
+        const error = new Error(`WORKTREE_DIRTY:${relevantPaths.slice(0, 5).join(', ')}`);
+        error.dirtyPaths = relevantPaths;
+        throw error;
     }
     return relevantPaths;
 }
@@ -554,6 +993,11 @@ function writeMergeConfidenceArtifacts(cwd, card) {
         `- Grade: **${card.verification.grade}**`,
         `- Score: **${card.verification.adherenceScore ?? card.verification.score}**`,
         `- Violations: **${card.verification.violations.length}**`,
+        `- Policy Lock: **${card.verification.policyLock?.enforced ? `enforced (${card.verification.policyLock.matched ? 'matched' : 'mismatch'})` : 'not enforced'}**`,
+        `- Policy Exceptions Suppressed: **${card.verification.policyExceptions?.suppressed ?? 0}**`,
+        `- Policy Exceptions Blocked: **${card.verification.policyExceptions?.blocked ?? 0}**`,
+        `- Approval Governance: **${card.verification.policyGovernance?.exceptionApprovals?.required ? `required (${card.verification.policyGovernance.exceptionApprovals.minApprovals})` : 'not required'}**`,
+        `- Audit Integrity: **${card.verification.policyGovernance?.audit?.requireIntegrity ? (card.verification.policyGovernance.audit.valid ? 'required+valid' : 'required+invalid') : 'not required'}**`,
         '',
         '## Blast Radius',
         '',
@@ -586,6 +1030,19 @@ function writeMergeConfidenceArtifacts(cwd, card) {
         `- Passed: **${card.tests.passed ? 'yes' : 'no'}**`,
         card.tests.command ? `- Command: \`${card.tests.command}\`` : '- Command: none',
         '',
+        '## Execution Audit',
+        '',
+        `- Run ID: \`${card.audit.runId}\``,
+        `- Started: ${card.audit.startedAt}`,
+        `- Finished: ${card.audit.finishedAt}`,
+        `- Duration: **${card.audit.durationMs}ms**`,
+        `- Timeouts (ms): plan=${card.audit.timeoutMs.plan}, apply=${card.audit.timeoutMs.apply}, verify=${card.audit.timeoutMs.verify}, tests=${card.audit.timeoutMs.tests}`,
+        `- Heartbeat: ${card.audit.heartbeatMs}ms`,
+        '- Step Timeline:',
+        ...(card.audit.steps.length > 0
+            ? card.audit.steps.map((step) => `  - ${step.stage}#${step.attempt} ${step.status} (${step.durationMs}ms)${typeof step.exitCode === 'number' ? ` exit=${step.exitCode}` : ''}${step.planId ? ` plan=${step.planId}` : ''}${step.message ? ` :: ${step.message}` : ''}`)
+            : ['  - none']),
+        '',
         '## Top Changed Files',
         '',
         ...(card.blastRadius.topFiles.length > 0
@@ -603,17 +1060,110 @@ function writeMergeConfidenceArtifacts(cwd, card) {
     (0, fs_1.writeFileSync)(markdownPath, markdown, 'utf-8');
     return { jsonPath, markdownPath };
 }
+function sha256Hex(input) {
+    return (0, crypto_1.createHash)('sha256').update(input, 'utf-8').digest('hex');
+}
+function writeReleaseAttestation(cwd, card, artifacts) {
+    const outDir = (0, path_1.join)(cwd, '.neurcode', 'ship', 'attestations');
+    (0, fs_1.mkdirSync)(outDir, { recursive: true });
+    const attestationBase = {
+        schemaVersion: 1,
+        attestationId: `att_${Date.now()}_${Math.random().toString(16).slice(2, 10)}`,
+        generatedAt: new Date().toISOString(),
+        runId: card.audit.runId,
+        status: card.status,
+        repository: {
+            root: card.repository.root,
+            branch: card.repository.branch,
+            headSha: card.repository.headSha,
+        },
+        card: {
+            jsonPath: artifacts.jsonPath,
+            markdownPath: artifacts.markdownPath,
+            sha256: sha256Hex((0, fs_1.readFileSync)(artifacts.jsonPath, 'utf-8')),
+        },
+        plans: {
+            initialPlanId: card.plans.initialPlanId,
+            finalPlanId: card.plans.finalPlanId,
+            repairPlanIds: [...card.plans.repairPlanIds],
+        },
+        verification: {
+            verdict: card.verification.verdict,
+            grade: card.verification.grade,
+            score: Number.isFinite(card.verification.adherenceScore)
+                ? card.verification.adherenceScore
+                : card.verification.score,
+            violations: card.verification.violations.length,
+            policyLock: {
+                enforced: card.verification.policyLock?.enforced === true,
+                matched: card.verification.policyLock?.matched !== false,
+            },
+            policyExceptions: {
+                matched: card.verification.policyExceptions?.matched ?? 0,
+                suppressed: card.verification.policyExceptions?.suppressed ?? 0,
+                blocked: card.verification.policyExceptions?.blocked ?? 0,
+                matchedExceptionIds: card.verification.policyExceptions?.matchedExceptionIds
+                    ? [...card.verification.policyExceptions.matchedExceptionIds]
+                    : [],
+            },
+            policyGovernance: {
+                approvalRequired: card.verification.policyGovernance?.exceptionApprovals?.required === true,
+                minApprovals: card.verification.policyGovernance?.exceptionApprovals?.minApprovals ?? 1,
+                disallowSelfApproval: card.verification.policyGovernance?.exceptionApprovals?.disallowSelfApproval !== false,
+                allowedApprovers: card.verification.policyGovernance?.exceptionApprovals?.allowedApprovers
+                    ? [...card.verification.policyGovernance.exceptionApprovals.allowedApprovers]
+                    : [],
+                auditIntegrityRequired: card.verification.policyGovernance?.audit?.requireIntegrity === true,
+                auditIntegrityValid: card.verification.policyGovernance?.audit?.valid !== false,
+            },
+        },
+        tests: {
+            skipped: card.tests.skipped,
+            passed: card.tests.passed,
+            attempts: card.tests.attempts,
+            lastExitCode: card.tests.lastExitCode,
+        },
+        remediation: {
+            attemptsUsed: card.remediation.attemptsUsed,
+            maxAttempts: card.remediation.maxAttempts,
+        },
+    };
+    const hmacKey = process.env.NEURCODE_ATTEST_HMAC_KEY;
+    const signature = hmacKey
+        ? {
+            algorithm: 'hmac-sha256',
+            keyId: process.env.NEURCODE_ATTEST_KEY_ID || null,
+            value: (0, crypto_1.createHmac)('sha256', hmacKey)
+                .update(JSON.stringify(attestationBase), 'utf-8')
+                .digest('hex'),
+        }
+        : null;
+    const attestation = {
+        ...attestationBase,
+        signature,
+    };
+    const ts = attestation.generatedAt.replace(/[:.]/g, '-');
+    const attestationPath = (0, path_1.join)(outDir, `release-attestation-${ts}.json`);
+    (0, fs_1.writeFileSync)(attestationPath, JSON.stringify(attestation, null, 2) + '\n', 'utf-8');
+    return attestationPath;
+}
 async function runPlanAndApply(cwd, intent, projectId, controls) {
-    const planArgs = ['plan', intent, '--force-plan'];
+    const planArgs = ['plan', intent, '--force-plan', '--json'];
     if (projectId) {
         planArgs.push('--project-id', projectId);
     }
     const planRun = await runCliCommand(cwd, planArgs, {
         NEURCODE_PLAN_SKIP_SNAPSHOTS: '1',
+    }, {
+        timeoutMs: getPlanTimeoutMs(),
+        label: 'ship:plan',
     });
     const planOutput = `${planRun.stdout}\n${planRun.stderr}`;
-    const planId = extractPlanId(planOutput);
-    if (planRun.code !== 0 || !planId) {
+    const parsedPlan = parsePlanPayload(planOutput);
+    const planId = parsedPlan?.success && parsedPlan.planId
+        ? parsedPlan.planId
+        : extractPlanId(planOutput);
+    if (planRun.code !== 0 || !planId || parsedPlan?.success === false) {
         return { planId: null, planRun, applyRun: null, writtenFiles: [] };
     }
     if (controls?.enforceDocumentationScope) {
@@ -632,59 +1182,274 @@ async function runPlanAndApply(cwd, intent, projectId, controls) {
             };
         }
     }
-    const applyArgs = ['apply', planId, '--force'];
-    const applyRun = await runCliCommand(cwd, applyArgs);
-    const writtenFiles = collectApplyWrittenFiles(`${applyRun.stdout}\n${applyRun.stderr}`);
-    return { planId, planRun, applyRun, writtenFiles };
+    const applyArgs = ['apply', planId, '--force', '--json'];
+    const applyRun = await runCliCommand(cwd, applyArgs, undefined, {
+        timeoutMs: getApplyTimeoutMs(),
+        label: 'ship:apply',
+    });
+    const applyOutput = `${applyRun.stdout}\n${applyRun.stderr}`;
+    const parsedApply = parseApplyPayload(applyOutput);
+    const normalizedApplyRun = parsedApply?.success === false && applyRun.code === 0
+        ? { ...applyRun, code: 1 }
+        : applyRun;
+    const writtenFiles = parsedApply?.writtenFiles && parsedApply.writtenFiles.length > 0
+        ? Array.from(new Set(parsedApply.writtenFiles))
+        : parsedApply?.files && parsedApply.files.length > 0
+            ? Array.from(new Set(parsedApply.files.map((item) => item.path)))
+            : collectApplyWrittenFiles(applyOutput);
+    return { planId, planRun, applyRun: normalizedApplyRun, writtenFiles };
 }
 async function shipCommand(goal, options) {
-    const startedAt = Date.now();
+    const resumedStart = options.resumeStartedAtIso ? Date.parse(options.resumeStartedAtIso) : NaN;
+    const startedAt = Number.isFinite(resumedStart) && resumedStart > 0 ? resumedStart : Date.now();
+    const startedAtIso = new Date(startedAt).toISOString();
+    const runId = options.resumeRunId || `ship_${Date.now()}_${Math.random().toString(16).slice(2, 10)}`;
     const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
     const maxFixAttempts = clamp(options.maxFixAttempts ?? 2, 0, 5);
+    const requirePass = options.requirePass === true || process.env.NEURCODE_SHIP_REQUIRE_PASS === '1';
+    const requirePolicyLock = options.requirePolicyLock === true || process.env.NEURCODE_SHIP_REQUIRE_POLICY_LOCK === '1';
+    const skipPolicyLock = options.skipPolicyLock === true || process.env.NEURCODE_SHIP_SKIP_POLICY_LOCK === '1';
     const remediationActions = [];
-    const repairPlanIds = [];
+    const repairPlanIds = Array.isArray(options.resumeRepairPlanIds)
+        ? [...options.resumeRepairPlanIds]
+        : [];
     const recordVerify = options.record !== false;
+    const auditSteps = [];
+    const timeoutConfig = {
+        plan: getPlanTimeoutMs(),
+        apply: getApplyTimeoutMs(),
+        verify: getVerifyTimeoutMs(),
+        tests: getTestTimeoutMs(),
+    };
+    const heartbeatMs = getHeartbeatIntervalMs();
+    const buildAuditSnapshot = () => {
+        const finishedAt = new Date().toISOString();
+        return {
+            runId,
+            startedAt: startedAtIso,
+            finishedAt,
+            durationMs: Date.now() - startedAt,
+            timeoutMs: timeoutConfig,
+            heartbeatMs,
+            steps: auditSteps,
+        };
+    };
+    const checkpoint = createShipCheckpoint({
+        runId,
+        goal: goal || '',
+        cwd,
+        startedAt: startedAtIso,
+        maxFixAttempts,
+        options,
+        requirePass,
+        requirePolicyLock,
+        skipPolicyLock,
+    });
+    if (options.resumeFromPlanId) {
+        checkpoint.stage = 'planned';
+        checkpoint.initialPlanId = options.resumeInitialPlanId || options.resumeFromPlanId;
+        checkpoint.currentPlanId = options.resumeFromPlanId;
+        checkpoint.repairPlanIds = [...repairPlanIds];
+        checkpoint.remediationAttemptsUsed = Math.max(0, options.resumeRemediationAttempts ?? 0);
+    }
+    const persistCheckpoint = (mutate) => {
+        try {
+            if (mutate)
+                mutate(checkpoint);
+            checkpoint.updatedAt = new Date().toISOString();
+            saveShipCheckpoint(cwd, checkpoint);
+        }
+        catch {
+            // Checkpoint persistence is best-effort and must not break ship runs.
+        }
+    };
+    persistCheckpoint();
+    const emitShipErrorAndExit = (input) => {
+        const exitCode = input.exitCode ?? 1;
+        const auditSnapshot = buildAuditSnapshot();
+        persistCheckpoint((draft) => {
+            draft.status = 'failed';
+            draft.stage = 'error';
+            draft.currentPlanId = input.finalPlanId || draft.currentPlanId;
+            draft.resultStatus = 'ERROR';
+            draft.audit = auditSnapshot;
+            draft.error = {
+                stage: input.stage,
+                code: input.code,
+                message: input.message,
+                detail: input.detail,
+                exitCode,
+            };
+        });
+        if (options.json) {
+            emitShipJson({
+                success: false,
+                status: 'ERROR',
+                finalPlanId: input.finalPlanId ?? null,
+                mergeConfidence: null,
+                riskScore: null,
+                artifacts: null,
+                shareCard: null,
+                error: {
+                    stage: input.stage,
+                    code: input.code,
+                    message: input.message,
+                    detail: input.detail,
+                    exitCode,
+                },
+                audit: auditSnapshot,
+            });
+        }
+        process.exit(exitCode);
+    };
     if (!goal || !goal.trim()) {
         console.error(chalk.red('❌ Error: goal cannot be empty.'));
         console.log(chalk.dim('Usage: neurcode ship "<goal>"'));
-        process.exit(1);
+        emitShipErrorAndExit({
+            stage: 'input',
+            code: 'INVALID_GOAL',
+            message: 'goal cannot be empty',
+            exitCode: 1,
+        });
     }
     const normalizedGoal = goal.trim();
+    persistCheckpoint((draft) => {
+        draft.goal = normalizedGoal;
+    });
     const documentationOnlyGoal = isDocumentationOnlyGoal(normalizedGoal);
     const scopedGoal = documentationOnlyGoal
         ? buildDocumentationOnlyIntent(normalizedGoal, false)
         : normalizedGoal;
-    const baselineDirtyPaths = ensureCleanTreeOrExit(cwd, options.allowDirty === true);
+    let baselineDirtyPaths = Array.isArray(options.resumeBaselineDirtyPaths)
+        ? [...options.resumeBaselineDirtyPaths]
+        : [];
+    try {
+        if (baselineDirtyPaths.length === 0) {
+            baselineDirtyPaths = ensureCleanTreeOrExit(cwd, options.allowDirty === true);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const dirtyPaths = error.dirtyPaths ||
+            (message.startsWith('WORKTREE_DIRTY:') ? message.replace('WORKTREE_DIRTY:', '').split(',').map((v) => v.trim()).filter(Boolean) : []);
+        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.'));
+        if (dirtyPaths.length > 0) {
+            console.error(chalk.dim(`   Dirty paths: ${dirtyPaths.slice(0, 5).join(', ')}`));
+        }
+        emitShipErrorAndExit({
+            stage: 'bootstrap',
+            code: 'WORKTREE_DIRTY',
+            message: 'Working tree is not clean',
+            detail: dirtyPaths.slice(0, 5).join(', '),
+            exitCode: 1,
+        });
+    }
+    persistCheckpoint((draft) => {
+        draft.stage = 'bootstrap';
+        draft.baselineDirtyPaths = [...baselineDirtyPaths];
+    });
     const baselineDirtySet = new Set(baselineDirtyPaths.map((p) => p.replace(/\\/g, '/')));
     console.log(chalk.bold.cyan('\n🚀 Neurcode Ship\n'));
     console.log(chalk.dim(`Goal: ${normalizedGoal}`));
     console.log(chalk.dim(`Workspace: ${cwd}\n`));
+    if (requirePass) {
+        console.log(chalk.dim('ℹ️  strict governance: PASS verdict required (INFO will block this run).'));
+    }
     if (baselineDirtyPaths.length > 0 && options.allowDirty) {
         console.log(chalk.dim(`ℹ️  allow-dirty: preserving ${baselineDirtyPaths.length} pre-existing dirty path(s) during verification.`));
     }
-    console.log(chalk.dim('1/4 Planning and applying initial implementation...'));
-    let initial = await runPlanAndApply(cwd, scopedGoal, options.projectId, {
-        enforceDocumentationScope: documentationOnlyGoal,
-    });
-    if (documentationOnlyGoal &&
-        initial.applyRun &&
-        initial.applyRun.code === 9 &&
-        initial.applyRun.stderr.startsWith('DOC_SCOPE_VIOLATION')) {
-        console.log(chalk.yellow('⚠️  Plan attempted non-documentation files. Retrying with strict README-only scope...'));
-        const strictGoal = buildDocumentationOnlyIntent(normalizedGoal, true);
-        initial = await runPlanAndApply(cwd, strictGoal, options.projectId, {
-            enforceDocumentationScope: true,
-        });
-    }
-    if (!initial.planId || initial.planRun.code !== 0 || !initial.applyRun || initial.applyRun.code !== 0) {
-        console.error(chalk.red('\n❌ Ship failed during initial plan/apply.'));
-        const detail = initial.applyRun?.stderr || initial.planRun.stderr || initial.planRun.stdout;
-        if (detail) {
-            console.error(chalk.dim(`   Details: ${shellTailLines(stripAnsi(detail), 8)}`));
+    let initialPlanDurationMs = 0;
+    let initialApplyDurationMs = 0;
+    let remediationAttemptsUsed = Math.max(0, options.resumeRemediationAttempts ?? 0);
+    let initialPlanId;
+    let currentPlanId;
+    if (options.resumeFromPlanId) {
+        initialPlanId = options.resumeInitialPlanId || options.resumeFromPlanId;
+        currentPlanId = options.resumeFromPlanId;
+        console.log(chalk.dim('1/4 Resuming from existing ship checkpoint (skipping plan/apply)...'));
+        auditSteps.push({
+            stage: 'resume',
+            attempt: 1,
+            status: 'SUCCESS',
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+            durationMs: 0,
+            planId: currentPlanId,
+            message: `resume_from_plan=${currentPlanId}`,
+        });
+    }
+    else {
+        console.log(chalk.dim('1/4 Planning and applying initial implementation...'));
+        let planningAttempt = 1;
+        let initial = await runPlanAndApply(cwd, scopedGoal, options.projectId, {
+            enforceDocumentationScope: documentationOnlyGoal,
+        });
+        recordRunStep(auditSteps, {
+            stage: 'plan',
+            attempt: planningAttempt,
+            run: initial.planRun,
+            message: 'initial',
+            planId: initial.planId || undefined,
+        });
+        recordRunStep(auditSteps, {
+            stage: 'apply',
+            attempt: planningAttempt,
+            run: initial.applyRun,
+            message: 'initial',
+            planId: initial.planId || undefined,
+        });
+        if (documentationOnlyGoal &&
+            initial.applyRun &&
+            initial.applyRun.code === 9 &&
+            initial.applyRun.stderr.startsWith('DOC_SCOPE_VIOLATION')) {
+            console.log(chalk.yellow('⚠️  Plan attempted non-documentation files. Retrying with strict README-only scope...'));
+            remediationActions.push('documentation_scope_retry');
+            const strictGoal = buildDocumentationOnlyIntent(normalizedGoal, true);
+            planningAttempt += 1;
+            initial = await runPlanAndApply(cwd, strictGoal, options.projectId, {
+                enforceDocumentationScope: true,
+            });
+            recordRunStep(auditSteps, {
+                stage: 'plan',
+                attempt: planningAttempt,
+                run: initial.planRun,
+                message: 'documentation_scope_retry',
+                planId: initial.planId || undefined,
+            });
+            recordRunStep(auditSteps, {
+                stage: 'apply',
+                attempt: planningAttempt,
+                run: initial.applyRun,
+                message: 'documentation_scope_retry',
+                planId: initial.planId || undefined,
+            });
         }
-        process.exit(1);
+        if (!initial.planId || initial.planRun.code !== 0 || !initial.applyRun || initial.applyRun.code !== 0) {
+            console.error(chalk.red('\n❌ Ship failed during initial plan/apply.'));
+            const detail = initial.applyRun?.stderr || initial.planRun.stderr || initial.planRun.stdout;
+            if (detail) {
+                console.error(chalk.dim(`   Details: ${shellTailLines(stripAnsi(detail), 8)}`));
+            }
+            const failedStage = !initial.planId || initial.planRun.code !== 0 ? 'plan' : 'apply';
+            const exitCode = failedStage === 'plan'
+                ? initial.planRun.code || 1
+                : initial.applyRun?.code || 1;
+            emitShipErrorAndExit({
+                stage: failedStage,
+                code: failedStage === 'plan' ? 'PLAN_APPLY_INIT_FAILED_PLAN' : 'PLAN_APPLY_INIT_FAILED_APPLY',
+                message: 'Ship failed during initial plan/apply',
+                detail: detail ? shellTailLines(stripAnsi(detail), 12) : undefined,
+                exitCode,
+                finalPlanId: initial.planId,
+            });
+        }
+        initialPlanId = initial.planId;
+        currentPlanId = initialPlanId;
+        initialPlanDurationMs = initial.planRun.durationMs;
+        initialApplyDurationMs = initial.applyRun ? initial.applyRun.durationMs : 0;
     }
-    let currentPlanId = initial.planId;
     try {
         (0, state_1.setActivePlanId)(currentPlanId);
         (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
@@ -692,9 +1457,15 @@ async function shipCommand(goal, options) {
     catch {
         // Non-critical state write.
     }
+    persistCheckpoint((draft) => {
+        draft.stage = 'planned';
+        draft.initialPlanId = initialPlanId;
+        draft.currentPlanId = currentPlanId;
+        draft.repairPlanIds = [...repairPlanIds];
+        draft.remediationAttemptsUsed = remediationAttemptsUsed;
+    });
     let verifyTotalMs = 0;
     let testsTotalMs = 0;
-    let remediationAttemptsUsed = 0;
     let verifyPayload = null;
     let verifyExitCode = 1;
     let testsPassed = options.skipTests === true;
@@ -703,25 +1474,57 @@ async function shipCommand(goal, options) {
     let testCommand = inferTestCommand(cwd, options.testCommand);
     while (true) {
         console.log(chalk.dim('\n2/4 Running governance verification...'));
+        const verifyAttempt = remediationAttemptsUsed + 1;
         const verifyArgs = ['verify', '--plan-id', currentPlanId, '--json'];
         if (recordVerify) {
             verifyArgs.push('--record');
         }
+        if (requirePolicyLock) {
+            verifyArgs.push('--require-policy-lock');
+        }
+        if (skipPolicyLock) {
+            verifyArgs.push('--skip-policy-lock');
+        }
         const verifyRun = await runCliCommand(cwd, verifyArgs, baselineDirtyPaths.length > 0
             ? { NEURCODE_VERIFY_IGNORE_PATHS: JSON.stringify(baselineDirtyPaths) }
-            : undefined);
+            : undefined, {
+            timeoutMs: getVerifyTimeoutMs(),
+            label: 'ship:verify',
+        });
         verifyTotalMs += verifyRun.durationMs;
         verifyExitCode = verifyRun.code;
+        recordRunStep(auditSteps, {
+            stage: 'verify',
+            attempt: verifyAttempt,
+            run: verifyRun,
+            planId: currentPlanId,
+        });
         const parsedVerify = parseVerifyPayload(`${verifyRun.stdout}\n${verifyRun.stderr}`);
         if (!parsedVerify) {
             console.error(chalk.red('\n❌ Could not parse verify JSON output.'));
-            process.exit(1);
+            emitShipErrorAndExit({
+                stage: 'verify',
+                code: 'VERIFY_JSON_PARSE_FAILED',
+                message: 'Could not parse verify JSON output',
+                detail: shellTailLines(stripAnsi(`${verifyRun.stdout}\n${verifyRun.stderr}`), 12),
+                exitCode: verifyRun.code === 0 ? 1 : verifyRun.code,
+                finalPlanId: currentPlanId,
+            });
         }
-        verifyPayload = parsedVerify;
+        const verifiedPayload = parsedVerify;
+        verifyPayload = verifiedPayload;
+        persistCheckpoint((draft) => {
+            draft.stage = 'verify';
+            draft.currentPlanId = currentPlanId;
+            draft.repairPlanIds = [...repairPlanIds];
+            draft.remediationAttemptsUsed = remediationAttemptsUsed;
+            draft.verifyExitCode = verifyRun.code;
+            draft.verifyPayload = verifiedPayload;
+        });
         const verifyPassed = verifyRun.code === 0 &&
-            (parsedVerify.verdict === 'PASS' || isInfoOnlyGovernanceResult(parsedVerify));
+            (verifiedPayload.verdict === 'PASS' || (!requirePass && isInfoOnlyGovernanceResult(verifiedPayload)));
         if (verifyPassed) {
-            if (parsedVerify.verdict === 'PASS') {
+            if (verifiedPayload.verdict === 'PASS') {
                 console.log(chalk.green('✅ Governance verification passed.'));
             }
             else {
@@ -729,13 +1532,21 @@ async function shipCommand(goal, options) {
             }
             break;
         }
+        if (verifyRun.code === 0 && requirePass && isInfoOnlyGovernanceResult(verifiedPayload)) {
+            remediationActions.push('strict_pass_required_info_block');
+            console.log(chalk.red('❌ Governance strict mode requires PASS verdict; verify returned INFO.'));
+            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
+        persistCheckpoint((draft) => {
+            draft.remediationAttemptsUsed = remediationAttemptsUsed;
+        });
+        const scopeDriftFiles = verifiedPayload.violations
             .filter((v) => v.rule === 'scope_guard' && v.file)
             .map((v) => v.file)
             .filter((path) => !baselineDirtySet.has(path.replace(/\\/g, '/')));
@@ -744,7 +1555,7 @@ async function shipCommand(goal, options) {
             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);
+        const policyFixes = applySimplePolicyFixes(cwd, verifiedPayload.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).`));
@@ -753,8 +1564,22 @@ async function shipCommand(goal, options) {
             continue;
         }
         console.log(chalk.dim('   Falling back to constrained repair plan...'));
-        const repairIntent = buildVerifyRepairIntent(normalizedGoal, currentPlanId, parsedVerify, remediationAttemptsUsed);
+        const repairIntent = buildVerifyRepairIntent(normalizedGoal, currentPlanId, verifiedPayload, remediationAttemptsUsed);
         const repair = await runPlanAndApply(cwd, repairIntent, options.projectId);
+        recordRunStep(auditSteps, {
+            stage: 'plan',
+            attempt: remediationAttemptsUsed + 1,
+            run: repair.planRun,
+            message: 'verify_repair',
+            planId: repair.planId || undefined,
+        });
+        recordRunStep(auditSteps, {
+            stage: 'apply',
+            attempt: remediationAttemptsUsed + 1,
+            run: repair.applyRun,
+            message: 'verify_repair',
+            planId: repair.planId || undefined,
+        });
         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.'));
@@ -763,6 +1588,12 @@ async function shipCommand(goal, options) {
         currentPlanId = repair.planId;
         repairPlanIds.push(repair.planId);
         remediationActions.push(`repair_plan_applied=${repair.planId}`);
+        persistCheckpoint((draft) => {
+            draft.stage = 'planned';
+            draft.currentPlanId = currentPlanId;
+            draft.repairPlanIds = [...repairPlanIds];
+            draft.remediationAttemptsUsed = remediationAttemptsUsed;
+        });
         try {
             (0, state_1.setActivePlanId)(currentPlanId);
             (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
@@ -773,23 +1604,46 @@ async function shipCommand(goal, options) {
     }
     if (!verifyPayload) {
         console.error(chalk.red('❌ Verification did not produce a valid payload.'));
-        process.exit(1);
+        emitShipErrorAndExit({
+            stage: 'verify',
+            code: 'VERIFY_PAYLOAD_MISSING',
+            message: 'Verification did not produce a valid payload',
+            exitCode: 1,
+            finalPlanId: currentPlanId,
+        });
     }
+    const finalVerifyPayload = verifyPayload;
     const verifyPassedFinal = verifyExitCode === 0 &&
-        (verifyPayload.verdict === 'PASS' || isInfoOnlyGovernanceResult(verifyPayload));
+        (finalVerifyPayload.verdict === 'PASS' || (!requirePass && isInfoOnlyGovernanceResult(finalVerifyPayload)));
     if (verifyPassedFinal && !options.skipTests) {
         testsAttempts += 1;
         if (!testCommand) {
             console.log(chalk.yellow('\n⚠️  No test command detected. Skipping tests.'));
             testsPassed = true;
             testsExitCode = 0;
+            recordRunStep(auditSteps, {
+                stage: 'tests',
+                attempt: testsAttempts,
+                run: null,
+                message: 'no_test_command_detected',
+                planId: currentPlanId,
+            });
         }
         else {
             console.log(chalk.dim(`\n3/4 Running tests: ${testCommand}`));
-            const testRun = await runShellCommand(cwd, testCommand);
+            const testRun = await runShellCommand(cwd, testCommand, {
+                timeoutMs: getTestTimeoutMs(),
+                label: 'ship:tests',
+            });
             testsTotalMs += testRun.durationMs;
             testsExitCode = testRun.code;
             testsPassed = testRun.code === 0;
+            recordRunStep(auditSteps, {
+                stage: 'tests',
+                attempt: testsAttempts,
+                run: testRun,
+                planId: currentPlanId,
+            });
             const testOutput = `${testRun.stdout}\n${testRun.stderr}`;
             if (!testsPassed && isNonRemediableTestFailure(testOutput)) {
                 remediationActions.push('test_infra_failure');
@@ -797,13 +1651,36 @@ async function shipCommand(goal, options) {
             }
             else if (!testsPassed && remediationAttemptsUsed < maxFixAttempts) {
                 remediationAttemptsUsed += 1;
+                persistCheckpoint((draft) => {
+                    draft.remediationAttemptsUsed = remediationAttemptsUsed;
+                });
                 console.log(chalk.yellow(`⚠️  Test failure auto-remediation attempt ${remediationAttemptsUsed}/${maxFixAttempts}`));
                 const repairIntent = buildTestRepairIntent(normalizedGoal, currentPlanId, testOutput, remediationAttemptsUsed);
                 const repair = await runPlanAndApply(cwd, repairIntent, options.projectId);
+                recordRunStep(auditSteps, {
+                    stage: 'plan',
+                    attempt: remediationAttemptsUsed + 1,
+                    run: repair.planRun,
+                    message: 'test_repair',
+                    planId: repair.planId || undefined,
+                });
+                recordRunStep(auditSteps, {
+                    stage: 'apply',
+                    attempt: remediationAttemptsUsed + 1,
+                    run: repair.applyRun,
+                    message: 'test_repair',
+                    planId: repair.planId || undefined,
+                });
                 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}`);
+                    persistCheckpoint((draft) => {
+                        draft.stage = 'planned';
+                        draft.currentPlanId = currentPlanId;
+                        draft.repairPlanIds = [...repairPlanIds];
+                        draft.remediationAttemptsUsed = remediationAttemptsUsed;
+                    });
                     try {
                         (0, state_1.setActivePlanId)(currentPlanId);
                         (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
@@ -811,20 +1688,56 @@ async function shipCommand(goal, options) {
                     catch {
                         // Non-critical state write.
                     }
-                    const verifyAfterTestRepair = await runCliCommand(cwd, ['verify', '--plan-id', currentPlanId, '--json', ...(recordVerify ? ['--record'] : [])], baselineDirtyPaths.length > 0
+                    const verifyAfterTestRepair = await runCliCommand(cwd, [
+                        'verify',
+                        '--plan-id',
+                        currentPlanId,
+                        '--json',
+                        ...(recordVerify ? ['--record'] : []),
+                        ...(requirePolicyLock ? ['--require-policy-lock'] : []),
+                        ...(skipPolicyLock ? ['--skip-policy-lock'] : []),
+                    ], baselineDirtyPaths.length > 0
                         ? { NEURCODE_VERIFY_IGNORE_PATHS: JSON.stringify(baselineDirtyPaths) }
-                        : undefined);
+                        : undefined, {
+                        timeoutMs: getVerifyTimeoutMs(),
+                        label: 'ship:verify',
+                    });
                     verifyTotalMs += verifyAfterTestRepair.durationMs;
+                    recordRunStep(auditSteps, {
+                        stage: 'verify',
+                        attempt: remediationAttemptsUsed + 1,
+                        run: verifyAfterTestRepair,
+                        message: 'post_test_repair',
+                        planId: currentPlanId,
+                    });
                     const parsedAfterRepair = parseVerifyPayload(`${verifyAfterTestRepair.stdout}\n${verifyAfterTestRepair.stderr}`);
                     if (parsedAfterRepair) {
                         verifyPayload = parsedAfterRepair;
                         verifyExitCode = verifyAfterTestRepair.code;
+                        persistCheckpoint((draft) => {
+                            draft.stage = 'verify';
+                            draft.currentPlanId = currentPlanId;
+                            draft.verifyExitCode = verifyExitCode;
+                            draft.verifyPayload = parsedAfterRepair;
+                            draft.repairPlanIds = [...repairPlanIds];
+                            draft.remediationAttemptsUsed = remediationAttemptsUsed;
+                        });
                     }
                     testsAttempts += 1;
-                    const finalTestRun = await runShellCommand(cwd, testCommand);
+                    const finalTestRun = await runShellCommand(cwd, testCommand, {
+                        timeoutMs: getTestTimeoutMs(),
+                        label: 'ship:tests',
+                    });
                     testsTotalMs += finalTestRun.durationMs;
                     testsExitCode = finalTestRun.code;
                     testsPassed = finalTestRun.code === 0;
+                    recordRunStep(auditSteps, {
+                        stage: 'tests',
+                        attempt: testsAttempts,
+                        run: finalTestRun,
+                        message: 'post_test_repair',
+                        planId: currentPlanId,
+                    });
                 }
                 else {
                     remediationActions.push('test_repair_plan_failed');
@@ -832,8 +1745,43 @@ async function shipCommand(goal, options) {
             }
         }
     }
+    else if (options.skipTests === true) {
+        recordRunStep(auditSteps, {
+            stage: 'tests',
+            attempt: 0,
+            run: null,
+            message: 'skipped_by_flag',
+            planId: currentPlanId,
+        });
+    }
+    else {
+        recordRunStep(auditSteps, {
+            stage: 'tests',
+            attempt: 0,
+            run: null,
+            message: 'skipped_due_to_verify_failure',
+            planId: currentPlanId,
+        });
+    }
+    persistCheckpoint((draft) => {
+        draft.stage = 'tests';
+        draft.currentPlanId = currentPlanId;
+        draft.repairPlanIds = [...repairPlanIds];
+        draft.remediationAttemptsUsed = remediationAttemptsUsed;
+        draft.tests = {
+            skipped: options.skipTests === true || !verifyPassedFinal,
+            passed: testsPassed,
+            exitCode: testsExitCode,
+            attempts: testsAttempts,
+            command: testCommand || null,
+        };
+        draft.verifyExitCode = verifyExitCode;
+        draft.verifyPayload = verifyPayload;
+    });
     const blast = collectBlastRadius(cwd);
     let simulatorSummary;
+    const simulatorStartedMs = Date.now();
+    const simulatorStartedAt = new Date(simulatorStartedMs).toISOString();
     try {
         const simulation = await (0, breakage_simulator_1.runBreakageSimulation)(cwd, {
             mode: 'working',
@@ -850,11 +1798,29 @@ async function shipCommand(goal, options) {
                 confidence: item.confidence,
             })),
         };
+        auditSteps.push({
+            stage: 'simulate',
+            attempt: 1,
+            status: 'SUCCESS',
+            startedAt: simulatorStartedAt,
+            endedAt: new Date().toISOString(),
+            durationMs: Date.now() - simulatorStartedMs,
+            message: `impacted=${simulatorSummary.impactedFiles};predicted_regressions=${simulatorSummary.predictedRegressions}`,
+        });
     }
     catch {
         simulatorSummary = undefined;
+        auditSteps.push({
+            stage: 'simulate',
+            attempt: 1,
+            status: 'FAILED',
+            startedAt: simulatorStartedAt,
+            endedAt: new Date().toISOString(),
+            durationMs: Date.now() - simulatorStartedMs,
+            message: 'simulation_failed',
+        });
     }
-    const riskScore = computeRiskScore(verifyPayload, blast, testsPassed, remediationAttemptsUsed);
+    const riskScore = computeRiskScore(finalVerifyPayload, blast, testsPassed, remediationAttemptsUsed);
     const riskLabel = classifyRiskLabel(riskScore);
     const status = verifyPassedFinal && testsPassed ? 'READY_TO_MERGE' : 'BLOCKED';
     const branch = (() => {
@@ -875,11 +1841,11 @@ async function shipCommand(goal, options) {
             headSha,
         },
         plans: {
-            initialPlanId: initial.planId,
+            initialPlanId,
             finalPlanId: currentPlanId,
             repairPlanIds,
         },
-        verification: verifyPayload,
+        verification: finalVerifyPayload,
         tests: {
             skipped: options.skipTests === true,
             command: testCommand || undefined,
@@ -900,16 +1866,34 @@ async function shipCommand(goal, options) {
         },
         simulator: simulatorSummary,
         timingsMs: {
-            initialPlan: initial.planRun.durationMs,
-            initialApply: initial.applyRun ? initial.applyRun.durationMs : 0,
+            initialPlan: initialPlanDurationMs,
+            initialApply: initialApplyDurationMs,
             verifyTotal: verifyTotalMs,
             testsTotal: testsTotalMs,
             total: Date.now() - startedAt,
         },
+        audit: buildAuditSnapshot(),
     };
-    const artifactPaths = writeMergeConfidenceArtifacts(cwd, card);
+    persistCheckpoint((draft) => {
+        draft.stage = 'finalize';
+        draft.currentPlanId = currentPlanId;
+        draft.repairPlanIds = [...repairPlanIds];
+        draft.remediationAttemptsUsed = remediationAttemptsUsed;
+        draft.verifyExitCode = verifyExitCode;
+        draft.verifyPayload = finalVerifyPayload;
+        draft.tests = {
+            skipped: options.skipTests === true || !verifyPassedFinal,
+            passed: testsPassed,
+            exitCode: testsExitCode,
+            attempts: testsAttempts,
+            command: testCommand || null,
+        };
+        draft.resultStatus = status;
+    });
     let publishedCard = null;
     if (options.publishCard !== false) {
+        const publishStartedMs = Date.now();
+        const publishStartedAt = new Date(publishStartedMs).toISOString();
         try {
             const config = (0, config_1.loadConfig)();
             if (config.apiKey) {
@@ -935,19 +1919,85 @@ async function shipCommand(goal, options) {
                     card: sanitizeCardForCloud(card),
                 });
                 publishedCard = publishResponse;
+                auditSteps.push({
+                    stage: 'publish_card',
+                    attempt: 1,
+                    status: 'SUCCESS',
+                    startedAt: publishStartedAt,
+                    endedAt: new Date().toISOString(),
+                    durationMs: Date.now() - publishStartedMs,
+                    message: `card_id=${publishResponse.id}`,
+                });
             }
             else {
                 console.log(chalk.dim('ℹ️  Merge card publish skipped (no API key found in current org scope).'));
+                auditSteps.push({
+                    stage: 'publish_card',
+                    attempt: 1,
+                    status: 'SKIPPED',
+                    startedAt: publishStartedAt,
+                    endedAt: new Date().toISOString(),
+                    durationMs: Date.now() - publishStartedMs,
+                    message: 'missing_api_key',
+                });
             }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             console.log(chalk.yellow(`⚠️  Merge card publish failed (non-blocking): ${message}`));
+            auditSteps.push({
+                stage: 'publish_card',
+                attempt: 1,
+                status: 'FAILED',
+                startedAt: publishStartedAt,
+                endedAt: new Date().toISOString(),
+                durationMs: Date.now() - publishStartedMs,
+                message,
+            });
         }
     }
+    else {
+        auditSteps.push({
+            stage: 'publish_card',
+            attempt: 1,
+            status: 'SKIPPED',
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+            durationMs: 0,
+            message: 'publish_disabled',
+        });
+    }
+    card.audit = buildAuditSnapshot();
+    const artifactPaths = writeMergeConfidenceArtifacts(cwd, card);
+    artifactPaths.attestationPath = writeReleaseAttestation(cwd, card, artifactPaths);
+    persistCheckpoint((draft) => {
+        draft.status = 'completed';
+        draft.stage = 'completed';
+        draft.initialPlanId = initialPlanId;
+        draft.currentPlanId = currentPlanId;
+        draft.repairPlanIds = [...repairPlanIds];
+        draft.remediationAttemptsUsed = remediationAttemptsUsed;
+        draft.verifyExitCode = verifyExitCode;
+        draft.verifyPayload = finalVerifyPayload;
+        draft.tests = {
+            skipped: options.skipTests === true || !verifyPassedFinal,
+            passed: testsPassed,
+            exitCode: testsExitCode,
+            attempts: testsAttempts,
+            command: testCommand || null,
+        };
+        draft.resultStatus = card.status;
+        draft.artifacts = artifactPaths;
+        draft.shareCard = publishedCard;
+        draft.audit = card.audit;
+        draft.error = null;
+    });
     console.log(chalk.dim('\n4/4 Merge Confidence Card generated.'));
     console.log(chalk.dim(`   JSON: ${artifactPaths.jsonPath}`));
     console.log(chalk.dim(`   Markdown: ${artifactPaths.markdownPath}`));
+    if (artifactPaths.attestationPath) {
+        console.log(chalk.dim(`   Attestation: ${artifactPaths.attestationPath}`));
+    }
     if (publishedCard?.shareUrl) {
         console.log(chalk.dim(`   Share URL: ${publishedCard.shareUrl}`));
     }
@@ -958,14 +2008,15 @@ async function shipCommand(goal, options) {
     }
     else {
         console.log(chalk.bold.red('❌ Blocked'));
-        console.log(chalk.red(`   Verdict: ${verifyPayload.verdict} | Tests: ${testsPassed ? 'PASS' : 'FAIL'}`));
+        console.log(chalk.red(`   Verdict: ${finalVerifyPayload.verdict} | Tests: ${testsPassed ? 'PASS' : 'FAIL'}`));
         console.log(chalk.red(`   Confidence: ${card.risk.mergeConfidence}/100 | Risk: ${card.risk.label}`));
     }
     if (card.simulator) {
         console.log(chalk.dim(`   Simulator: impacted=${card.simulator.impactedFiles}, predicted_regressions=${card.simulator.predictedRegressions}`));
     }
     if (options.json) {
-        console.log(JSON.stringify({
+        emitShipJson({
+            success: card.status === 'READY_TO_MERGE',
             status: card.status,
             finalPlanId: card.plans.finalPlanId,
             mergeConfidence: card.risk.mergeConfidence,
@@ -983,8 +2034,286 @@ async function shipCommand(goal, options) {
             simulator: card.simulator,
             artifacts: artifactPaths,
             shareCard: publishedCard,
-        }, null, 2));
+            audit: card.audit,
+        });
     }
     process.exit(status === 'READY_TO_MERGE' ? 0 : 2);
 }
+function emitResumeErrorJson(input) {
+    const now = new Date().toISOString();
+    const exitCode = input.exitCode ?? 1;
+    emitShipJson({
+        success: false,
+        status: 'ERROR',
+        finalPlanId: null,
+        mergeConfidence: null,
+        riskScore: null,
+        artifacts: null,
+        shareCard: null,
+        error: {
+            stage: 'resume',
+            code: input.code,
+            message: input.message,
+            detail: input.detail,
+            exitCode,
+        },
+        audit: {
+            runId: input.runId,
+            startedAt: now,
+            finishedAt: now,
+            durationMs: 0,
+            timeoutMs: {
+                plan: getPlanTimeoutMs(),
+                apply: getApplyTimeoutMs(),
+                verify: getVerifyTimeoutMs(),
+                tests: getTestTimeoutMs(),
+            },
+            heartbeatMs: getHeartbeatIntervalMs(),
+            steps: [],
+        },
+    });
+}
+async function shipResumeCommand(runId, options) {
+    const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+    const normalizedRunId = String(runId || '').trim();
+    if (!normalizedRunId) {
+        if (options.json) {
+            emitResumeErrorJson({
+                runId: 'unknown',
+                code: 'RUN_ID_REQUIRED',
+                message: 'runId is required',
+            });
+        }
+        else {
+            console.error(chalk.red('❌ ship-resume requires a run ID.'));
+            console.log(chalk.dim('Usage: neurcode ship-resume <run-id>'));
+        }
+        process.exit(1);
+    }
+    const checkpoint = loadShipCheckpoint(cwd, normalizedRunId);
+    if (!checkpoint) {
+        if (options.json) {
+            emitResumeErrorJson({
+                runId: normalizedRunId,
+                code: 'CHECKPOINT_NOT_FOUND',
+                message: `No ship checkpoint found for run ${normalizedRunId}`,
+            });
+        }
+        else {
+            console.error(chalk.red(`❌ No ship checkpoint found for run ${normalizedRunId}.`));
+            console.log(chalk.dim('Run `neurcode ship-runs` to list resumable runs.'));
+        }
+        process.exit(1);
+    }
+    if (checkpoint.status === 'completed') {
+        const completedStatus = checkpoint.resultStatus || 'BLOCKED';
+        if (options.json) {
+            emitShipJson({
+                success: completedStatus === 'READY_TO_MERGE',
+                status: completedStatus,
+                finalPlanId: checkpoint.currentPlanId,
+                mergeConfidence: null,
+                riskScore: null,
+                verification: checkpoint.verifyPayload
+                    ? {
+                        verdict: checkpoint.verifyPayload.verdict,
+                        grade: checkpoint.verifyPayload.grade,
+                        score: checkpoint.verifyPayload.adherenceScore ?? checkpoint.verifyPayload.score,
+                        violations: checkpoint.verifyPayload.violations.length,
+                    }
+                    : undefined,
+                tests: {
+                    skipped: checkpoint.tests.skipped,
+                    passed: checkpoint.tests.passed,
+                },
+                artifacts: checkpoint.artifacts,
+                shareCard: checkpoint.shareCard,
+                audit: checkpoint.audit || {
+                    runId: checkpoint.runId,
+                    startedAt: checkpoint.startedAt,
+                    finishedAt: checkpoint.updatedAt,
+                    durationMs: Math.max(0, Date.parse(checkpoint.updatedAt) - Date.parse(checkpoint.startedAt)),
+                    timeoutMs: {
+                        plan: getPlanTimeoutMs(),
+                        apply: getApplyTimeoutMs(),
+                        verify: getVerifyTimeoutMs(),
+                        tests: getTestTimeoutMs(),
+                    },
+                    heartbeatMs: getHeartbeatIntervalMs(),
+                    steps: [],
+                },
+            });
+        }
+        else {
+            console.log(chalk.yellow(`ℹ️  Run ${normalizedRunId} is already completed (${completedStatus}).`));
+            if (checkpoint.artifacts) {
+                console.log(chalk.dim(`   JSON: ${checkpoint.artifacts.jsonPath}`));
+                console.log(chalk.dim(`   Markdown: ${checkpoint.artifacts.markdownPath}`));
+                if (checkpoint.artifacts.attestationPath) {
+                    console.log(chalk.dim(`   Attestation: ${checkpoint.artifacts.attestationPath}`));
+                }
+            }
+        }
+        process.exit(completedStatus === 'READY_TO_MERGE' ? 0 : completedStatus === 'BLOCKED' ? 2 : 1);
+    }
+    if (!checkpoint.currentPlanId) {
+        if (options.json) {
+            emitResumeErrorJson({
+                runId: normalizedRunId,
+                code: 'CHECKPOINT_MISSING_PLAN',
+                message: `Run ${normalizedRunId} has no resumable plan`,
+            });
+        }
+        else {
+            console.error(chalk.red(`❌ Run ${normalizedRunId} has no resumable plan checkpoint.`));
+            console.log(chalk.dim('Start a new run with `neurcode ship "<goal>"`.'));
+        }
+        process.exit(1);
+    }
+    await shipCommand(checkpoint.goal, {
+        projectId: options.projectId || checkpoint.options.projectId || undefined,
+        maxFixAttempts: Number.isFinite(options.maxFixAttempts)
+            ? options.maxFixAttempts
+            : checkpoint.options.maxFixAttempts,
+        allowDirty: true,
+        skipTests: options.skipTests ?? checkpoint.options.skipTests,
+        testCommand: options.testCommand || checkpoint.options.testCommand || undefined,
+        record: options.record ?? checkpoint.options.record,
+        requirePass: options.requirePass ?? checkpoint.options.requirePass,
+        requirePolicyLock: options.requirePolicyLock ?? checkpoint.options.requirePolicyLock,
+        skipPolicyLock: options.skipPolicyLock ?? checkpoint.options.skipPolicyLock,
+        publishCard: options.publishCard ?? checkpoint.options.publishCard,
+        json: options.json === true,
+        resumeRunId: checkpoint.runId,
+        resumeFromPlanId: checkpoint.currentPlanId,
+        resumeInitialPlanId: checkpoint.initialPlanId || checkpoint.currentPlanId,
+        resumeRepairPlanIds: checkpoint.repairPlanIds,
+        resumeRemediationAttempts: checkpoint.remediationAttemptsUsed,
+        resumeBaselineDirtyPaths: checkpoint.baselineDirtyPaths,
+        resumeStartedAtIso: checkpoint.startedAt,
+    });
+}
+function shipRunsCommand(options) {
+    const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+    const limitRaw = Number.isFinite(options.limit) ? Number(options.limit) : 20;
+    const limit = Math.max(1, Math.min(200, Math.floor(limitRaw)));
+    const runs = listShipRunSummaries(cwd).slice(0, limit);
+    if (options.json) {
+        console.log(JSON.stringify({ runs }, null, 2));
+        return;
+    }
+    if (runs.length === 0) {
+        console.log(chalk.yellow('\n⚠️  No ship runs found for this repository.\n'));
+        console.log(chalk.dim('Start one with: neurcode ship "<goal>"\n'));
+        return;
+    }
+    console.log(chalk.bold('\n🧭 Ship Runs\n'));
+    for (const run of runs) {
+        console.log(chalk.cyan(`• ${run.runId}`));
+        console.log(chalk.dim(`  status=${run.status} stage=${run.stage} result=${run.resultStatus || 'n/a'}`));
+        if (run.currentPlanId) {
+            console.log(chalk.dim(`  plan=${run.currentPlanId}`));
+        }
+        console.log(chalk.dim(`  updated=${run.updatedAt}`));
+        console.log(chalk.dim(`  goal=${run.goal}`));
+        console.log('');
+    }
+    console.log(chalk.dim('Resume a run with: neurcode ship-resume <run-id>\n'));
+}
+function shipAttestationVerifyCommand(attestationPathInput, options) {
+    const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+    const attestationPath = (0, path_1.resolve)(cwd, String(attestationPathInput || '').trim());
+    if (!(0, fs_1.existsSync)(attestationPath)) {
+        const message = `Attestation file not found: ${attestationPath}`;
+        if (options.json) {
+            console.log(JSON.stringify({ pass: false, message }, null, 2));
+        }
+        else {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        process.exit(1);
+    }
+    let payload;
+    try {
+        payload = JSON.parse((0, fs_1.readFileSync)(attestationPath, 'utf-8'));
+    }
+    catch (error) {
+        const message = `Failed to parse attestation JSON: ${error instanceof Error ? error.message : 'Unknown error'}`;
+        if (options.json) {
+            console.log(JSON.stringify({ pass: false, message }, null, 2));
+        }
+        else {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        process.exit(1);
+    }
+    const cardPathRaw = payload?.card?.jsonPath;
+    const expectedSha = payload?.card?.sha256;
+    const signature = payload?.signature;
+    const cardPath = typeof cardPathRaw === 'string' ? (0, path_1.resolve)(cwd, cardPathRaw) : '';
+    const cardExists = cardPath ? (0, fs_1.existsSync)(cardPath) : false;
+    const actualSha = cardExists && typeof expectedSha === 'string'
+        ? sha256Hex((0, fs_1.readFileSync)(cardPath, 'utf-8'))
+        : null;
+    const digestMatched = typeof expectedSha === 'string' && actualSha === expectedSha;
+    const hmacKey = options.hmacKey || process.env.NEURCODE_ATTEST_HMAC_KEY;
+    let signatureVerified = null;
+    let signatureMessage = null;
+    if (signature && typeof signature === 'object' && typeof signature.value === 'string') {
+        if (!hmacKey) {
+            signatureVerified = false;
+            signatureMessage = 'signature present but no HMAC key provided';
+        }
+        else {
+            const basePayload = { ...payload };
+            delete basePayload.signature;
+            const expectedSignature = (0, crypto_1.createHmac)('sha256', hmacKey)
+                .update(JSON.stringify(basePayload), 'utf-8')
+                .digest('hex');
+            signatureVerified = expectedSignature === signature.value;
+            signatureMessage = signatureVerified ? null : 'signature mismatch';
+        }
+    }
+    const pass = digestMatched && (signatureVerified === null || signatureVerified === true);
+    const response = {
+        pass,
+        attestationPath,
+        cardPath,
+        cardExists,
+        digest: {
+            expected: typeof expectedSha === 'string' ? expectedSha : null,
+            actual: actualSha,
+            matched: digestMatched,
+        },
+        signature: {
+            present: Boolean(signature && typeof signature === 'object' && typeof signature.value === 'string'),
+            verified: signatureVerified,
+            keyId: signature && typeof signature === 'object' && typeof signature.keyId === 'string' ? signature.keyId : null,
+            message: signatureMessage,
+        },
+    };
+    if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+    }
+    else if (pass) {
+        console.log(chalk.green('\n✅ Attestation verified.\n'));
+        console.log(chalk.dim(`Attestation: ${attestationPath}`));
+        console.log(chalk.dim(`Card: ${cardPath}`));
+        console.log(chalk.dim(`Digest: ${response.digest.actual}\n`));
+    }
+    else {
+        console.log(chalk.red('\n❌ Attestation verification failed.\n'));
+        if (!cardExists) {
+            console.log(chalk.red(`- Card file missing: ${cardPath}`));
+        }
+        if (!digestMatched) {
+            console.log(chalk.red(`- Digest mismatch (expected=${response.digest.expected}, actual=${response.digest.actual})`));
+        }
+        if (response.signature.verified === false && response.signature.message) {
+            console.log(chalk.red(`- Signature: ${response.signature.message}`));
+        }
+        console.log('');
+    }
+    process.exit(pass ? 0 : 1);
+}
 //# sourceMappingURL=ship.js.map