codehere 1.0.1 → 1.0.2

package/dist/presentation/cli/commands/trust-command.js

@@ -1,328 +0,0 @@
-/**
- * CLI Command: trust
- *
- * Layer 0 trust scorer — instant static analysis, zero API calls.
- * Runs on a file, directory, or piped git diff.
- *
- * Produces a trust score 0–100 with plain-English explanation:
- *   100 = no findings
- *   80+ = minor issues, safe to merge
- *   60-79 = review recommended
- *   40-59 = high-risk, human review required
- *   < 40 = block until resolved
- *
- * Usage:
- *   codehere trust src/utils.ts          # score a file
- *   codehere trust .                     # score all files in directory
- *   git diff HEAD | codehere trust       # score a diff
- *   codehere trust --diff HEAD           # equivalent using git directly
- *   codehere trust --badge               # output badge markdown
- */
-import { existsSync } from 'fs';
-import { join, relative, isAbsolute } from 'path';
-import { execFileSync } from 'child_process';
-import { scoreFile, aggregateTrust } from '../../../infrastructure/security/trust-scorer.js';
-import { collectCodeFiles } from '../../../infrastructure/security/file-collection.js';
-import { colors, sectionHeader, error, newline, info, randomCleanScan } from '../../../ui.js';
-import { loadProductContext, adjustRecommendation } from '../../../infrastructure/config/product-context.js';
-// ── File collection ──────────────────────────────────────────────────────────
-// See src/infrastructure/security/file-collection.ts for exclusion rules.
-/**
- * Read a file safely — handles iCloud-evicted files on macOS.
- * readFileSync blocks forever on iCloud-evicted files (dehydrated placeholders in ~/Documents).
- * We use cat with a timeout as a subprocess so the main thread never blocks.
- */
-function safeReadFile(filepath) {
-    try {
-        return execFileSync('cat', [filepath], { encoding: 'utf-8', timeout: 2000, maxBuffer: 5 * 1024 * 1024 });
-    }
-    catch {
-        return null; // File unreadable (iCloud-evicted, permissions, too large) — skip silently
-    }
-}
-// ── Git diff mode ────────────────────────────────────────────────────────────
-function parseDiffFiles(diff) {
-    const files = [];
-    const fileBlocks = diff.split(/^diff --git /m).filter(Boolean);
-    for (const block of fileBlocks) {
-        const filenameMatch = block.match(/^a\/(.+?) b\/(.+?)$/m);
-        if (!filenameMatch)
-            continue;
-        const filepath = filenameMatch[2];
-        // Skip internal backup/cache directories to avoid false findings from old code
-        if (filepath.startsWith('.codehere/') || filepath.startsWith('.codehere-cache/'))
-            continue;
-        // Extract added lines only (lines starting with +, excluding +++)
-        const addedLines = block
-            .split('\n')
-            .filter((l) => l.startsWith('+') && !l.startsWith('+++'))
-            .map((l) => l.substring(1))
-            .join('\n');
-        if (addedLines.trim()) {
-            files.push({ filepath, code: addedLines });
-        }
-    }
-    return files;
-}
-// ── Report formatting ────────────────────────────────────────────────────────
-function gradeColor(grade) {
-    switch (grade) {
-        case 'A':
-            return colors.green(grade);
-        case 'B':
-            return colors.cyan(grade);
-        case 'C':
-            return colors.yellow(grade);
-        case 'D':
-            return colors.red(grade);
-        case 'F':
-            return colors.red(colors.bold(grade));
-        default:
-            return grade;
-    }
-}
-function scoreBar(score, width = 20) {
-    const filled = Math.round((score / 100) * width);
-    const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
-    if (score >= 75)
-        return colors.green(bar);
-    if (score >= 60)
-        return colors.yellow(bar);
-    return colors.red(bar);
-}
-function badgeMarkdown(report) {
-    const color = report.grade === 'A'
-        ? 'brightgreen'
-        : report.grade === 'B'
-            ? 'green'
-            : report.grade === 'C'
-                ? 'yellow'
-                : report.grade === 'D'
-                    ? 'orange'
-                    : 'red';
-    return `![codehere trust](https://img.shields.io/badge/codehere%20trust-${report.overallScore}%25%20${report.grade}-${color}?logo=shield)`;
-}
-// ── Main command ─────────────────────────────────────────────────────────────
-export async function executeTrustCommand(target, options = {}) {
-    const cwd = process.cwd();
-    let filesToScan = [];
-    // ── Input source ──────────────────────────────────────────────────────────
-    if (options.diff !== undefined) {
-        // Run git diff and scan added lines
-        try {
-            // THREAT-2 fix · ref comes from a user-supplied CLI flag. Using template-
-            // string interpolation with execSync allows shell metacharacters in `ref`
-            // (e.g. `--diff "main; rm -rf /"`) to escape the git invocation. Use the
-            // execFileSync array form so the shell is never invoked.
-            const ref = options.diff || 'HEAD';
-            const diffOutput = execFileSync('git', ['diff', ref], { cwd, encoding: 'utf-8' });
-            filesToScan = parseDiffFiles(diffOutput);
-            if (filesToScan.length === 0) {
-                console.log(info('No changed files to scan'));
-                return;
-            }
-        }
-        catch (e) {
-            console.error(error('git diff failed: ' + String(e)));
-            process.exit(1);
-        }
-    }
-    else if (!process.stdin.isTTY && !target) {
-        // Piped input (e.g., git diff HEAD | codehere trust)
-        let diffInput = '';
-        for await (const chunk of process.stdin) {
-            diffInput += chunk;
-        }
-        if (diffInput.trim().startsWith('diff --git')) {
-            filesToScan = parseDiffFiles(diffInput);
-        }
-        else {
-            // Treat as raw code
-            filesToScan = [{ filepath: 'stdin', code: diffInput }];
-        }
-        if (filesToScan.length === 0) {
-            console.log(info('No content to scan'));
-            return;
-        }
-    }
-    else {
-        // File or directory
-        const resolved = target ? (isAbsolute(target) ? target : join(cwd, target)) : cwd;
-        if (!existsSync(resolved)) {
-            console.error(error(`Not found: ${resolved}`));
-            process.exit(1);
-        }
-        const paths = collectCodeFiles(resolved);
-        let skippedCount = 0;
-        for (const p of paths) {
-            const code = safeReadFile(p);
-            if (code !== null) {
-                filesToScan.push({ filepath: relative(cwd, p), code });
-            }
-            else {
-                skippedCount++;
-            }
-        }
-        if (skippedCount > 0) {
-            console.log(colors.dim(`  Skipped ${skippedCount} unreadable file${skippedCount > 1 ? 's' : ''}`));
-        }
-        if (filesToScan.length === 0 && skippedCount > 0) {
-            console.log(info('No readable files to scan.'));
-            console.log(colors.dim('  Check file permissions or availability and retry.'));
-            return;
-        }
-    }
-    // ── Scan ──────────────────────────────────────────────────────────────────
-    const results = filesToScan.map((f) => scoreFile(f.filepath, f.code));
-    // S8 · score + grade come from the ONE shared aggregation (trust-scorer's
-    // aggregateTrust) — `trust`, `--badge`, and `report` can no longer drift.
-    const { overallScore, grade, criticalCount, highCount, mediumCount, lowCount, totalFindings } = aggregateTrust(results);
-    // Nothing scanned is not a clean scan.
-    //
-    // aggregateTrust over zero files returns 100/A, and the recommendation below then read
-    // "Clean scan. Nothing blocking a merge." — an explicit merge recommendation earned by
-    // looking at nothing. `trust --ci` advertises itself as a gate ("Exit 1 on critical
-    // findings"), so a CI job pointed at the wrong path, or one whose diff resolution returned
-    // no files, went green and told the reader the code was fine. Same defect as `audit verify
-    // --json` reporting valid:true over an empty chain (f030769): a walk over nothing trivially
-    // succeeds, and success over nothing is not success.
-    const scanned = filesToScan.length > 0;
-    const baseRecommendation = !scanned
-        ? 'No files scanned — nothing was graded. Point trust at a path with source in it, or check your diff range.'
-        : criticalCount > 0
-            ? `${criticalCount} critical ${criticalCount === 1 ? 'issue' : 'issues'} · worth sorting before this merges.`
-            : highCount > 0
-                ? `Nothing critical, but ${highCount} high-severity ${highCount === 1 ? 'pattern' : 'patterns'} worth a look.`
-                : mediumCount + lowCount > 0
-                    ? `${mediumCount + lowCount} low-priority ${mediumCount + lowCount === 1 ? 'finding' : 'findings'} · nothing blocking, but worth a pass.`
-                    : 'Clean scan. Nothing blocking a merge.';
-    const productCtx = loadProductContext(process.cwd());
-    const recommendation = adjustRecommendation(baseRecommendation, criticalCount, highCount, overallScore, productCtx);
-    const report = {
-        files: results,
-        // `scanned` is the field a machine should branch on. Without it, files:[] plus grade:'A'
-        // reads as a pass to anything that only looks at the grade.
-        scanned,
-        overallScore,
-        grade,
-        totalFindings,
-        criticalCount,
-        highCount,
-        mediumCount,
-        lowCount,
-        recommendation,
-        scannedAt: new Date().toISOString(),
-    };
-    // Track CI failure — will throw after display so the CLI action handler catches it
-    const ciFailed = options.ci && (!scanned || overallScore < 60 || criticalCount > 0);
-    // ── Output ────────────────────────────────────────────────────────────────
-    if (options.json) {
-        console.log(JSON.stringify(report, null, 2));
-        if (options.ci && (!scanned || overallScore < 60 || criticalCount > 0))
-            process.exit(1);
-        return;
-    }
-    if (options.badge) {
-        console.log(badgeMarkdown(report));
-        return;
-    }
-    // Human-readable report
-    newline();
-    sectionHeader('codehere Trust Report');
-    newline();
-    // Score — but only when something was scored.
-    //
-    // A full green bar reading 100/100 A over zero files is the headline lie, and it survived
-    // fixing the JSON and the exit code: those matter to a pipeline, this is what the human
-    // reads. DESIGN.md §1 reserves green for a measurement, and an aggregation over nothing is
-    // not one. No score, no grade, no green tick — just what happened.
-    if (!scanned) {
-        console.log(`  ${colors.dim('—')}  no files scanned, so there is no score`);
-        newline();
-    }
-    else {
-        console.log(`  Score    ${scoreBar(overallScore)}  ${colors.bold(String(overallScore))}/100  ${gradeColor(grade)}`);
-        newline();
-        // Findings summary (inline, compact)
-        const parts = [
-            criticalCount > 0 ? colors.red(`${criticalCount} critical`) : null,
-            highCount > 0 ? colors.yellow(`${highCount} high`) : null,
-            mediumCount > 0 ? colors.dim(`${mediumCount} medium`) : null,
-            lowCount > 0 ? colors.dim(`${lowCount} low`) : null,
-        ].filter(Boolean);
-        if (parts.length === 0) {
-            console.log(`  ${colors.green('✓')} ${randomCleanScan()}`);
-        }
-        else {
-            console.log(`  ${parts.join(colors.dim('  ·  '))}`);
-        }
-    }
-    newline();
-    // Per-file results (show worst first)
-    if (results.length > 1) {
-        const sorted = [...results].sort((a, b) => a.score - b.score);
-        console.log(colors.dim('  FILES'));
-        for (const r of sorted.slice(0, 10)) {
-            const icon = r.score >= 75 ? colors.green('✓') : r.score >= 60 ? colors.yellow('!') : colors.red('✕');
-            console.log(`  ${icon} ${gradeColor(r.grade)}  ${String(r.score).padStart(3)}/100  ${r.filepath}`);
-        }
-        if (sorted.length > 10) {
-            console.log(colors.dim(`  + ${sorted.length - 10} more files`));
-        }
-        newline();
-    }
-    // Findings detail
-    if (options.verbose) {
-        console.log(colors.dim('  FINDINGS'));
-        for (const r of results) {
-            if (r.findings.length === 0)
-                continue;
-            console.log(`  ${colors.bold(r.filepath)}`);
-            for (const f of r.findings) {
-                const sev = f.severity === 'critical'
-                    ? colors.red('crit')
-                    : f.severity === 'high'
-                        ? colors.yellow('high')
-                        : colors.dim(f.severity.slice(0, 4));
-                const ln = f.line ? colors.dim(`L${f.line}`) : '';
-                console.log(`    ${sev}  ${ln.padEnd(6)} ${f.description}`);
-            }
-        }
-        newline();
-    }
-    else if (totalFindings > 0) {
-        console.log(colors.dim('  FINDINGS'));
-        const severityRank = { critical: 0, high: 1, medium: 2, low: 3 };
-        const allFindings = results.flatMap((r) => r.findings.map((f) => ({ ...f, filepath: r.filepath })));
-        const sorted = allFindings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity]);
-        for (const f of sorted.slice(0, 5)) {
-            const sev = f.severity === 'critical'
-                ? colors.red('crit')
-                : f.severity === 'high'
-                    ? colors.yellow('high')
-                    : colors.dim(f.severity.slice(0, 4));
-            const ln = f.line ? `:${f.line}` : '';
-            console.log(`  ${sev}  ${f.filepath}${ln}`);
-            console.log(`        ${colors.dim(f.description)}`);
-        }
-        if (sorted.length > 5) {
-            console.log(colors.dim(`  + ${sorted.length - 5} more findings (use --verbose to see all)`));
-        }
-        newline();
-    }
-    // Recommendation
-    const recColor = criticalCount > 0 ? colors.red : highCount > 0 ? colors.yellow : colors.green;
-    console.log(recColor(recommendation));
-    newline();
-    // Tips footer (quiet, separated)
-    if (results.length > 0 && !options.ci) {
-        console.log(colors.dim('  ─────'));
-        console.log(colors.dim('  trust --badge  Add a badge to your README'));
-        console.log(colors.dim('  trust --ci     Exit 1 on critical findings'));
-        newline();
-    }
-    if (ciFailed) {
-        throw new Error(`CI_FAIL:${criticalCount > 0 ? criticalCount + ' critical finding(s)' : 'score ' + overallScore + ' below threshold 60'}`);
-    }
-}
-//# sourceMappingURL=trust-command.js.map

package/dist/presentation/cli/commands/verify-command.js

@@ -1,298 +0,0 @@
-/**
- * CLI command: verify
- *
- * v0.7 verifier-agent · Slice 2 (CLI surface for the pure verify-claim use case).
- *
- * Compares what the agent's Final Report TEXT claims against the structured
- * reality (artifacts + steps) captured during the session. Catches the
- * easy lies before they reach a PR description.
- *
- * Usage:
- *   codehere verify <session-id>          # run verifier on a completed session
- *   codehere verify <session-id> --json   # machine-readable output for CI
- *   codehere verify                       # list recent sessions to pick from
- *
- * Exit codes:
- *   0 = verified OR partial (warnings only · unverifiable claims)
- *   0 = no-report (nothing to verify; not a failure)
- *   1 = broken (at least one claim contradicts recorded reality)
- *   2 = session not found / invalid input
- *
- * The verifier is intentionally conservative: only claims that map to
- * structured data are checked. Prose claims pass through silently.
- */
-import { colors, symbols } from '../../../ui.js';
-import { loadSessionById, loadRecent, } from '../../../infrastructure/orchestration/session-persistence.js';
-import { assessSession } from '../../../application/services/verdict-service.js';
-import { describeCompleted } from '../../../domain/task.js';
-import { buildCrossVendorVerdict } from '../../../application/use-cases/build-cross-vendor-verdict.js';
-export async function executeVerifyCommand(sessionId, options = {}) {
-    // No session id: show a picker list and exit gracefully.
-    if (!sessionId) {
-        return showSessionPicker(options.json ?? false);
-    }
-    const session = loadSessionById(sessionId);
-    if (!session) {
-        if (options.json) {
-            process.stdout.write(JSON.stringify({
-                error: 'session-not-found',
-                sessionId,
-                hint: 'Run `codehere verify` (no args) to list recent sessions.',
-            }, null, 2) + '\n');
-        }
-        else {
-            process.stderr.write(colors.error(`${symbols.error} No completed session found matching "${sessionId}".\n`) +
-                colors.dim('   Tip: run `codehere verify` (no args) to see recent sessions.\n'));
-        }
-        return 2;
-    }
-    const result = assessSession(session);
-    const crossVendor = buildCrossVendorVerdict(session);
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ ...serializeResult(session, result), crossVendor: crossVendor ?? null }, null, 2) + '\n');
-    }
-    else {
-        printHumanReadable(session, result, crossVendor);
-    }
-    // Exit code: only `broken` is a hard failure (CI-friendly).
-    return result.status === 'broken' ? 1 : 0;
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Picker mode · no session id given                                         */
-/* ──────────────────────────────────────────────────────────────────────── */
-function showSessionPicker(json) {
-    const recent = loadRecent(15);
-    if (recent.length === 0) {
-        if (json) {
-            process.stdout.write(JSON.stringify({ sessions: [], note: 'No completed sessions found.' }, null, 2) + '\n');
-        }
-        else {
-            process.stdout.write(colors.dim('No completed sessions found. Run a task first, then verify it:\n') +
-                colors.dim('   codehere task "describe what you want done"\n'));
-        }
-        return 0;
-    }
-    if (json) {
-        const items = recent.map((s) => ({
-            sessionId: s.sessionId,
-            agent: s.agent,
-            prompt: s.prompt,
-            completedAt: s.completedAt,
-            hasFinalReport: Boolean(s.finalReport),
-        }));
-        process.stdout.write(JSON.stringify({ sessions: items }, null, 2) + '\n');
-        return 0;
-    }
-    process.stdout.write('\n' + colors.bold('Recent sessions') + colors.dim('  (pass --json for machine output)\n\n'));
-    for (const s of recent) {
-        const shortId = s.sessionId.slice(0, 8);
-        const when = formatRelativeTime(s.completedAt);
-        const reportTag = s.finalReport ? colors.gray('· report ✓') : colors.gray('· no report');
-        const promptLine = truncate(s.prompt.replace(/\s+/g, ' ').trim(), 70);
-        process.stdout.write(`  ${colors.cyan(shortId)}  ${colors.gray(s.agent.padEnd(11))}${colors.dim(when.padEnd(14))} ${reportTag}\n` +
-            `             ${colors.dim(promptLine)}\n\n`);
-    }
-    process.stdout.write(colors.dim('To verify one of these:  ') + colors.bold('codehere verify <id>') + '\n\n');
-    return 0;
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Cross-vendor review rendering                                             */
-/* ──────────────────────────────────────────────────────────────────────── */
-function printCrossVendor(cv) {
-    process.stdout.write(colors.bold('Cross-vendor review\n'));
-    const lead = cv.proven ? colors.success(`${symbols.success} `) : '  ';
-    process.stdout.write(`${lead}${cv.summary}\n`);
-    for (const c of cv.caveats)
-        process.stdout.write(colors.dim(`  · ${c}\n`));
-    if (cv.reviewText) {
-        process.stdout.write('\n' + colors.dim(`${cv.reviewer.agent}'s findings (verbatim · codehere does not judge them):\n`));
-        process.stdout.write(colors.gray(truncate(cv.reviewText.replace(/\s+/g, ' ').trim(), 400)) + '\n');
-    }
-    process.stdout.write('\n');
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Human-readable output                                                     */
-/* ──────────────────────────────────────────────────────────────────────── */
-function printHumanReadable(session, result, crossVendor) {
-    const shortId = session.sessionId.slice(0, 8);
-    const when = formatRelativeTime(session.completedAt);
-    // Header
-    process.stdout.write('\n' +
-        colors.dim('session ') +
-        colors.cyan(shortId) +
-        colors.dim(' · ') +
-        colors.gray(session.agent) +
-        colors.dim(' · ') +
-        colors.gray(when) +
-        '\n' +
-        colors.dim('task: ') +
-        truncate(session.prompt.replace(/\s+/g, ' ').trim(), 80) +
-        '\n\n');
-    // What the agent did — lead with the deliverable, not the audit. A
-    // non-technical user opening this wants "what happened" first, then "does
-    // it check out". Both come straight from recorded state (no screen lies).
-    if (session.finalReport?.summary) {
-        process.stdout.write(session.finalReport.summary.trim() + '\n\n');
-    }
-    // Files changed + trust, or the honest can't-track note.
-    const files = session.artifacts?.files ?? [];
-    if (session.artifacts?.noGitTracking) {
-        process.stdout.write(colors.dim("Files: codehere couldn't track changes here (this folder isn't a git repository).\n\n"));
-    }
-    else if (files.length > 0) {
-        process.stdout.write(colors.bold('Files changed:\n'));
-        for (const f of files) {
-            const trust = typeof f.trust === 'number' ? colors.dim(` · trust ${f.trust}/100`) : '';
-            process.stdout.write(`  • ${f.path}  ${colors.success('+' + f.added)}/${colors.error('-' + f.removed)}${trust}\n`);
-        }
-        process.stdout.write('\n');
-    }
-    // Verdict line · color-coded by status
-    const verdict = verdictLine(result);
-    process.stdout.write(colors.bold('Fact-check: ') + verdict + '\n\n');
-    // Cross-vendor review — when a DIFFERENT vendor reviewed an earlier writer in
-    // this room, this is the receipt no single-vendor tool can produce.
-    if (crossVendor)
-        printCrossVendor(crossVendor);
-    // Findings detail
-    if (result.findings.length > 0 && result.status !== 'no-report') {
-        process.stdout.write(colors.bold('Findings:\n\n'));
-        for (let i = 0; i < result.findings.length; i++) {
-            const f = result.findings[i];
-            const num = colors.dim(`  ${(i + 1).toString().padStart(2)}. `);
-            const sev = severityTag(f.severity);
-            const kind = colors.gray(`[${f.kind}]`);
-            process.stdout.write(`${num}${sev} ${kind} ${f.message}\n`);
-            process.stdout.write(`      ${colors.dim('claim:')}   ${colors.gray(f.claim)}\n`);
-            process.stdout.write(`      ${colors.dim('reality:')} ${colors.gray(f.reality)}\n\n`);
-        }
-    }
-    // What was checked (so users know the verifier's scope)
-    process.stdout.write(colors.dim('What was checked:\n'));
-    process.stdout.write(colors.dim('  · numeric test claims (X tests passed, X of Y, etc) vs artifacts.tests\n'));
-    process.stdout.write(colors.dim('  · universal claims (all tests pass, no failures) vs artifacts.tests.failed\n'));
-    process.stdout.write(colors.dim('  · file claims (X files changed, no files changed) vs artifacts.files\n'));
-    process.stdout.write(colors.dim('Not checked: prose claims, intent, semantic correctness of changes.\n\n'));
-    // Tier 1.1/0.2 · be explicit about which kind of test ✓ this is. A re-run is
-    // ground truth (exit-code observed); a scrape is the agent's own claim. The
-    // skeptic deserves to know which one they're looking at.
-    const tests = session.artifacts?.tests;
-    if (tests) {
-        if (tests.observed) {
-            process.stdout.write(colors.green(`${symbols.success} tests RE-RUN by codehere`) +
-                colors.dim(` (${tests.command || 'test suite'}, exit ${tests.exitCode}) · observed, not just reported\n\n`));
-        }
-        else {
-            process.stdout.write(colors.dim('Note: test counts above are AS REPORTED by the agent · codehere did not re-run the suite, so the exit code is not independently confirmed.\n\n'));
-        }
-    }
-    // R13/M3 · the typed completeness invariant — every verdict input is either
-    // present or carries the explicit honest reason it isn't. This block is what
-    // makes "the verdict said X" auditable: the reader sees exactly what fed it
-    // and what couldn't (e.g. "couldn't observe — no test runner detected"),
-    // never a silent blank.
-    const completeness = describeCompleted({
-        sessionId: session.sessionId,
-        agent: session.agent,
-        status: session.status,
-        completedAt: session.completedAt,
-        durationMs: session.durationMs,
-        steps: session.steps,
-        artifacts: session.artifacts,
-        finalReport: session.finalReport,
-    });
-    process.stdout.write(colors.bold('What fed this verdict\n'));
-    const inputLine = (label, input) => 'present' in input
-        ? `  ${colors.green(symbols.success)} ${label}\n`
-        : `  ${colors.dim(symbols.dot)} ${label} ${colors.dim('· ' + input.absent)}\n`;
-    process.stdout.write(inputLine('file changes', completeness.files));
-    // A trust surface must say WHICH kind of test ✓ this is: a codehere re-run
-    // (exit-code observed) or the agent's own scrape (a claim, not ground truth).
-    const testsLabel = 'present' in completeness.tests
-        ? completeness.tests.present.observed
-            ? 'test result (re-run by codehere)'
-            : 'test result (agent-reported, not re-run)'
-        : 'test result';
-    process.stdout.write(inputLine(testsLabel, completeness.tests));
-    process.stdout.write(inputLine('written report', completeness.report));
-    process.stdout.write(inputLine('audit reconciliation', completeness.audit));
-    process.stdout.write('\n');
-}
-function verdictLine(result) {
-    switch (result.status) {
-        case 'verified':
-            return colors.green(`${symbols.success} Verified`) + colors.dim('  ' + result.summary);
-        case 'partial':
-            return colors.warning(`${symbols.warning} Partial`) + colors.dim('  ' + result.summary);
-        case 'broken':
-            return colors.error(`${symbols.error} Broken`) + colors.dim('  ' + result.summary);
-        case 'no-report':
-            return colors.gray(`${symbols.dot} No report`) + colors.dim('  ' + result.summary);
-        case 'nothing-to-verify':
-            // Honest neutral, not a green pass — the report made no checkable claim.
-            return colors.gray(`${symbols.dot} Nothing to verify`) + colors.dim('  ' + result.summary);
-    }
-}
-function severityTag(sev) {
-    switch (sev) {
-        case 'fail':
-            return colors.error('fail');
-        case 'warn':
-            return colors.warning('warn');
-        case 'info':
-            return colors.info('info');
-    }
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* JSON serialization                                                        */
-/* ──────────────────────────────────────────────────────────────────────── */
-function serializeResult(session, result) {
-    return {
-        sessionId: session.sessionId,
-        agent: session.agent,
-        prompt: session.prompt,
-        completedAt: session.completedAt,
-        durationMs: session.durationMs,
-        hasFinalReport: Boolean(session.finalReport),
-        verdict: {
-            status: result.status,
-            summary: result.summary,
-            findings: result.findings.map((f) => ({
-                severity: f.severity,
-                kind: f.kind,
-                claim: f.claim,
-                reality: f.reality,
-                message: f.message,
-            })),
-        },
-    };
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Small utilities                                                            */
-/* ──────────────────────────────────────────────────────────────────────── */
-function formatRelativeTime(ts) {
-    if (!ts || ts <= 0)
-        return 'unknown';
-    const deltaMs = Date.now() - ts;
-    if (deltaMs < 0)
-        return 'just now';
-    const seconds = Math.floor(deltaMs / 1000);
-    if (seconds < 60)
-        return `${seconds}s ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    if (days < 30)
-        return `${days}d ago`;
-    return new Date(ts).toISOString().split('T')[0];
-}
-function truncate(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max - 1).trimEnd() + '…';
-}
-//# sourceMappingURL=verify-command.js.map