codehere 0.8.0 → 1.0.1

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

@@ -19,11 +19,11 @@ import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } fr
 import { homedir, hostname } from 'os';
 import { dirname, join, isAbsolute, resolve } from 'path';
 import { colors, symbols } from '../../../ui.js';
-import { signBundle, verifyBundle, shortFingerprint, } from '../../../application/use-cases/thread-export.js';
+import { signBundle, verifyBundle, shortFingerprint, collectAuditEntriesForSession, verifyEmbeddedAuditChain, } from '../../../application/use-cases/thread-export.js';
 import { loadOrCreateKeypair, localPublicKeyBase64, trustKey, untrustKey, trustedKeySet, loadTrustedKeys, isKeyTrusted, } from '../../../infrastructure/orchestration/thread-key-store.js';
 import { loadSessionById } from '../../../infrastructure/orchestration/session-persistence.js';
 import { getVersion } from '../../../utils/version.js';
-export function executeThreadCommand(sub, arg, extra, options = {}) {
+export function executeThreadCommand(sub, arg, _extra, options = {}) {
     switch (sub) {
         case 'export':
             return exportThread(arg, options);
@@ -60,6 +60,9 @@ function exportThread(sessionId, options) {
         kind: 'thread',
         sessionId: session.sessionId,
         session,
+        // Embed the session's tool-call audit so a teammate can inspect what the
+        // agent did (signer-attested; see ThreadBundleBody.auditChain trust model).
+        auditChain: collectAuditEntriesForSession(session.sessionId),
         exporter: {
             hostname: safeHostname(),
             codehereVersion: getVersion(),
@@ -132,6 +135,15 @@ function importThread(filePath, options) {
     // status: 'valid' or 'unknown_key'
     const bundle = verdict.status === 'valid' ? verdict.bundle : verdict.bundle;
     const fp_key = shortFingerprint(bundle.publicKey);
+    // Re-verify the embedded tool-call audit so the recipient SEES what the agent
+    // did — not just the narration. Honest semantics: "verified" is gated on
+    // verified>0 (a valid AuditChainCheck is true even for an empty set), and a
+    // tampered entry is surfaced loudly. The bundle SIGNATURE already proved the
+    // chain is signer-attested + unaltered-in-transit; this confirms each entry's
+    // self-hash on top.
+    const auditCheck = bundle.body.auditChain
+        ? verifyEmbeddedAuditChain(bundle.body.auditChain)
+        : undefined;
     if (verdict.status === 'unknown_key') {
         if (!options.trust) {
             if (options.json) {
@@ -160,6 +172,18 @@ function importThread(filePath, options) {
     }
     // Persist into ~/.codehere/sessions.jsonl as 3 records (spawned, completed, finalReport)
     const ses = bundle.body.session;
+    // No-clobber / idempotent import (Phase 2.5 multi-human): re-importing the same
+    // session must not duplicate it in a shared room. Append-only never LOSES work,
+    // but a second import would double the records (and any count-based view).
+    if (loadSessionById(ses.sessionId)) {
+        if (options.json) {
+            process.stdout.write(JSON.stringify({ ok: true, sessionId: ses.sessionId, alreadyImported: true, fingerprint: fp_key }) + '\n');
+        }
+        else {
+            process.stdout.write(colors.dim(`${symbols.info} session ${ses.sessionId.slice(0, 8)} is already imported · nothing to do\n`));
+        }
+        return 0;
+    }
     const home = process.env.CODEHERE_HOME || homedir();
     const sessionsPath = join(home, '.codehere', 'sessions.jsonl');
     mkdirSync(dirname(sessionsPath), { recursive: true });
@@ -171,6 +195,28 @@ function importThread(filePath, options) {
         prompt: ses.prompt,
         cwd: ses.cwd,
         startedAt: ses.startedAt,
+        // S18 · practice classification is a property of the RUN on the exporter's
+        // machine, carried by the bundle — never the importing daemon's env.
+        // Absent in a legacy bundle = the work was real and audit-attested; an
+        // import performed on a mock daemon must never demote a teammate's real
+        // work to practice. Stamped explicitly so no spawned-record writer leaves
+        // the field env-classified.
+        mockRun: ses.mockRun === true,
+        // Provenance: attribute this session to the signer it was imported from,
+        // so a shared room shows "from teammate <fingerprint>", not as if local.
+        importedFrom: fp_key,
+        // Persist the audit attestation — the bundle isn't stored, so the room
+        // needs this to show the proof badge. attested gated on verified>0 && no tamper.
+        ...(auditCheck
+            ? {
+                importAudit: {
+                    total: auditCheck.total,
+                    verified: auditCheck.verified,
+                    tampered: auditCheck.tampered.length,
+                    attested: auditCheck.verified > 0 && auditCheck.tampered.length === 0,
+                },
+            }
+            : {}),
     }));
     lines.push(JSON.stringify({
         t: 'completed',
@@ -197,17 +243,53 @@ function importThread(filePath, options) {
             sessionId: ses.sessionId,
             trusted: verdict.status === 'valid' ? true : 'just-added',
             fingerprint: fp_key,
+            audit: auditCheck
+                ? {
+                    total: auditCheck.total,
+                    verified: auditCheck.verified,
+                    tampered: auditCheck.tampered.length,
+                    legacy: auditCheck.legacy,
+                    // "verified" is true ONLY when entries were actually checked +
+                    // none tampered — never on a bare/empty chain.
+                    attested: auditCheck.verified > 0 && auditCheck.tampered.length === 0,
+                }
+                : null,
         }) + '\n');
     }
     else {
         process.stdout.write(colors.green(`${symbols.success} Imported`) +
-            colors.dim(`  session ${ses.sessionId.slice(0, 8)} · signed by ${fp_key}\n`) +
-            colors.dim(`   view it:  `) +
+            colors.dim(`  session ${ses.sessionId.slice(0, 8)} · signed by ${fp_key}\n`));
+        process.stdout.write(formatAuditLine(auditCheck));
+        process.stdout.write(colors.dim(`   view it:  `) +
             colors.bold(`codehere start`) +
             colors.dim(` then click the task in the dashboard\n`));
     }
     return 0;
 }
+/**
+ * Honest one-line summary of the embedded audit chain for the import surface.
+ * The "✓ verified" claim is gated on verified>0 (NOT bare check.valid, which is
+ * true for an empty/all-legacy set where nothing was checked); a tampered entry
+ * is surfaced as a loud warning. Returns '' when there's no chain to report.
+ */
+function formatAuditLine(check) {
+    if (!check || check.total === 0) {
+        return colors.dim(`   (no tool-call audit was included in this bundle)\n`);
+    }
+    if (check.tampered.length > 0) {
+        return colors.error(`   ${symbols.error} audit chain INCONSISTENT · ${check.tampered.length} of ${check.total} entr${check.tampered.length === 1 ? 'y was' : 'ies were'} altered after writing · the signer's tool-call record is not internally consistent\n`);
+    }
+    if (check.verified > 0) {
+        // Honest framing: this is signer ATTESTATION, not independent provenance —
+        // the hashes match and the bundle is signed, but trust reduces to the signer's
+        // key (a malicious signer could fabricate a consistent chain). Say exactly that
+        // rather than a bare "verified" that implies more than self-hash + signature.
+        return colors.green(`   ${symbols.success} ${check.verified} agent tool call${check.verified === 1 ? '' : 's'} recorded` +
+            colors.dim(` · hashes intact, as attested by this signer (your trust = the key above)\n`));
+    }
+    // total>0 but nothing verifiable (all legacy/no chain fields).
+    return colors.dim(`   ${check.legacy} audit entr${check.legacy === 1 ? 'y' : 'ies'} present but unverifiable (no chain fields)\n`);
+}
 /* ──────────────────────────────────────────────────────────────────────── */
 /* keys / trust / untrust                                                    */
 /* ──────────────────────────────────────────────────────────────────────── */
@@ -271,7 +353,7 @@ function untrustCmd(pubkey, json) {
         process.stdout.write(colors.green(`${symbols.success} untrusted ${shortFingerprint(pubkey)}\n`));
     }
     else {
-        process.stdout.write(colors.gray(`${symbols.dot} key not in trust store (or it's this machine's own key — can't remove)\n`));
+        process.stdout.write(colors.gray(`${symbols.dot} key not in trust store (or it's this machine's own key · can't remove)\n`));
     }
     return 0;
 }

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

@@ -21,7 +21,7 @@
 import { existsSync } from 'fs';
 import { join, relative, isAbsolute } from 'path';
 import { execFileSync } from 'child_process';
-import { scoreFile } from '../../../infrastructure/security/trust-scorer.js';
+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';
@@ -174,24 +174,35 @@ export async function executeTrustCommand(target, options = {}) {
     }
     // ── Scan ──────────────────────────────────────────────────────────────────
     const results = filesToScan.map((f) => scoreFile(f.filepath, f.code));
-    const totalFindings = results.reduce((s, r) => s + r.findings.length, 0);
-    const criticalCount = results.reduce((s, r) => s + r.findings.filter((f) => f.severity === 'critical').length, 0);
-    const highCount = results.reduce((s, r) => s + r.findings.filter((f) => f.severity === 'high').length, 0);
-    const mediumCount = results.reduce((s, r) => s + r.findings.filter((f) => f.severity === 'medium').length, 0);
-    const lowCount = results.reduce((s, r) => s + r.findings.filter((f) => f.severity === 'low').length, 0);
-    const overallScore = results.length > 0 ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length) : 100;
-    const grade = overallScore >= 90 ? 'A' : overallScore >= 75 ? 'B' : overallScore >= 60 ? 'C' : overallScore >= 40 ? 'D' : 'F';
-    const baseRecommendation = 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.';
+    // 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,
@@ -203,11 +214,11 @@ export async function executeTrustCommand(target, options = {}) {
         scannedAt: new Date().toISOString(),
     };
     // Track CI failure — will throw after display so the CLI action handler catches it
-    const ciFailed = options.ci && (overallScore < 60 || criticalCount > 0);
+    const ciFailed = options.ci && (!scanned || overallScore < 60 || criticalCount > 0);
     // ── Output ────────────────────────────────────────────────────────────────
     if (options.json) {
         console.log(JSON.stringify(report, null, 2));
-        if (options.ci && (overallScore < 60 || criticalCount > 0))
+        if (options.ci && (!scanned || overallScore < 60 || criticalCount > 0))
             process.exit(1);
         return;
     }
@@ -219,21 +230,32 @@ export async function executeTrustCommand(target, options = {}) {
     newline();
     sectionHeader('codehere Trust Report');
     newline();
-    // Score
-    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()}`);
+    // 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(`  ${parts.join(colors.dim('  ·  '))}`);
+        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)
@@ -241,7 +263,7 @@ export async function executeTrustCommand(target, options = {}) {
         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('✗');
+            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) {

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

@@ -23,7 +23,9 @@
  */
 import { colors, symbols } from '../../../ui.js';
 import { loadSessionById, loadRecent, } from '../../../infrastructure/orchestration/session-persistence.js';
-import { verifyClaim } from '../../../application/use-cases/verify-claim.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) {
@@ -44,16 +46,13 @@ export async function executeVerifyCommand(sessionId, options = {}) {
         }
         return 2;
     }
-    const result = verifyClaim({
-        summary: session.finalReport?.summary,
-        artifacts: session.artifacts,
-        steps: session.steps,
-    });
+    const result = assessSession(session);
+    const crossVendor = buildCrossVendorVerdict(session);
     if (options.json) {
-        process.stdout.write(JSON.stringify(serializeResult(session, result), null, 2) + '\n');
+        process.stdout.write(JSON.stringify({ ...serializeResult(session, result), crossVendor: crossVendor ?? null }, null, 2) + '\n');
     }
     else {
-        printHumanReadable(session, result);
+        printHumanReadable(session, result, crossVendor);
     }
     // Exit code: only `broken` is a hard failure (CI-friendly).
     return result.status === 'broken' ? 1 : 0;
@@ -97,9 +96,24 @@ function showSessionPicker(json) {
     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) {
+function printHumanReadable(session, result, crossVendor) {
     const shortId = session.sessionId.slice(0, 8);
     const when = formatRelativeTime(session.completedAt);
     // Header
@@ -136,6 +150,10 @@ function printHumanReadable(session, result) {
     // 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'));
@@ -155,6 +173,50 @@ function printHumanReadable(session, result) {
     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) {
@@ -166,6 +228,9 @@ function verdictLine(result) {
             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) {

package/dist/presentation/cli/error-display.js

@@ -325,12 +325,4 @@ function getErrorSuggestions(errorType, errorMessage, _context) {
     }
     return suggestions;
 }
-/**
- * Display error and exit with appropriate code
- */
-export function displayErrorAndExit(error, options = {}) {
-    const { exitCode = 1, ...displayOptions } = options;
-    displayError(error, displayOptions);
-    process.exit(exitCode);
-}
 //# sourceMappingURL=error-display.js.map

package/dist/presentation/cli/repl.js

@@ -135,6 +135,14 @@ const SLASH_COMMANDS = [
         noKey: true,
         subcommand: 'audit',
     },
+    {
+        name: 'search',
+        args: '<query>',
+        description: 'Search past sessions · every hit cites its evidence',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'search',
+    },
     {
         name: 'context-source',
         args: '[list|connect|disconnect]',
@@ -271,11 +279,11 @@ export function buildWelcomeLines(state, version) {
         '',
     ];
     if (!state.hasHooks) {
-        lines.push('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+        lines.push('  ' + colors.yellow('›') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
     }
     else if (!state.hasAgents) {
         lines.push('  ' +
-            colors.yellow('→') +
+            colors.yellow('›') +
             ' Install ' +
             colors.cyan('claude-code') +
             colors.dim(' / ') +
@@ -596,7 +604,7 @@ async function handleSlash(cmd, args, state) {
         return;
     }
     if (cmd === 'exit' || cmd === 'quit' || cmd === 'q') {
-        console.log(colors.dim('Goodbye! 👋'));
+        console.log(colors.dim('Goodbye!'));
         process.exit(0);
     }
     if (cmd === 'agents') {
@@ -694,7 +702,7 @@ async function spawnViaConductor(prompt, state) {
     // UAT-002 guard — exit-intent before any spawn / API call.
     const trimmed = prompt.trim().toLowerCase();
     if (EXIT_INTENT_WORDS.has(trimmed)) {
-        console.log(colors.dim('Goodbye! 👋'));
+        console.log(colors.dim('Goodbye!'));
         process.exit(0);
     }
     const installed = availableAgents().filter((a) => a.installed);
@@ -735,7 +743,7 @@ function renderEvent(event) {
         case 'codehere:conductor-routing': {
             const data = event.data;
             console.log(colors.dim('  │ ') +
-                colors.bold('routing → ') +
+                colors.bold('routing › ') +
                 colors.cyan(data.delegatedTo ?? '?') +
                 colors.dim(' · ' + (data.reason ?? '')));
             return null;
@@ -755,7 +763,7 @@ function renderEvent(event) {
                 return label;
             }
             if (state === 'done' || state === 'failed') {
-                const icon = state === 'done' ? colors.green('✓') : colors.red('✗');
+                const icon = state === 'done' ? colors.green('✓') : colors.red('✕');
                 console.log(colors.dim('  │ ') + icon + ' ' + label);
                 // P22 / Track B #8 — render last 3 lines of step output for done/failed
                 if (lastStep.output && String(lastStep.output).trim()) {
@@ -787,7 +795,7 @@ function renderEvent(event) {
         case 'error': {
             const data = event.data;
             if (data?.message)
-                console.log(colors.red('  │ ✗ ') + data.message);
+                console.log(colors.red('  │ ✕ ') + data.message);
             return null;
         }
         default:

package/dist/presentation/cli/task-deliverable.js

@@ -12,6 +12,7 @@
  */
 import http from 'http';
 import { colors } from '../../ui.js';
+import { VERDICT_WORDS, corroborationClause } from '../../application/services/verdict-service.js';
 /** Pull one session's full result from a running daemon's /api/tasks. Matches
  *  by exact id or short prefix. Returns null if the daemon is unreachable or
  *  the id isn't found. */
@@ -106,17 +107,42 @@ export function formatDeliverable(r) {
         lines.push(colors.dim('Files: none changed.'));
     }
     // 3 · Did the report's claims check out? (verifier cross-check)
-    if (r.verifyResult) {
-        const v = r.verifyResult;
-        const label = v.status === 'verified'
-            ? colors.success('verified')
-            : v.status === 'broken'
-                ? colors.error('does not match reality')
-                : v.status === 'partial'
-                    ? colors.warning('partly unverifiable')
-                    : colors.dim('nothing to check');
+    if (r.verdict?.claim) {
+        const v = r.verdict.claim;
+        // Read the one reconciled verdict (the composite grade owns it), falling back
+        // to the raw claim status only for legacy/seeded tasks with no grade. The
+        // words come from the shared VERDICT_WORDS so the CLI says exactly what the
+        // web app says for the same state — a green composite grade reads "Verified"
+        // (a single cross-vendor review CORROBORATES; the CLI never says "Proven"
+        // for one reviewer, matching the web seal's "Corroborated by <vendor>").
+        const byHeadline = {
+            proven: 'verified',
+            broken: 'caught',
+            reported: 'reported',
+            'nothing-to-verify': 'unverified',
+            'no-report': 'unverified',
+        };
+        const byStatus = {
+            verified: 'verified',
+            broken: 'caught',
+            partial: 'partial',
+        };
+        const grade = r.verdict.grade;
+        const key = (grade && byHeadline[grade.headline]) || byStatus[v.status] || 'unverified';
+        const tone = key === 'proven' || key === 'verified'
+            ? colors.success
+            : key === 'caught'
+                ? colors.error
+                : key === 'reported' || key === 'partial'
+                    ? colors.warning
+                    : colors.dim;
+        // For a green composite grade the sub-clause names the ACTUAL independent
+        // signal that earned it (matching the web seal) — not the claim summary,
+        // which for a nothing-to-verify claim would contradict the green ("Verified
+        // · the report makes no checkable claim").
+        const sub = grade && grade.green ? corroborationClause(grade) : v.summary;
         lines.push('');
-        lines.push(`${colors.bold('Check:')} ${label} — ${v.summary}`);
+        lines.push(`${colors.bold('Check:')} ${tone(VERDICT_WORDS[key])} · ${sub}`);
         for (const f of v.findings.filter((x) => x.severity !== 'info')) {
             lines.push(colors.dim(`    • ${f.message}`));
         }

package/dist/testing/replay-adapter.js

@@ -31,7 +31,6 @@
  */
 import { EventEmitter } from 'events';
 import { Readable, Writable } from 'stream';
-import { loadCassette } from './cassette.js';
 // ── Active cassette holder (single-cassette-per-test pattern) ───────────────
 let _activeCassette;
 export function setActiveCassette(c) {
@@ -145,22 +144,4 @@ function makeReplayChild(cassette) {
     timers.push(termHandle);
     return child;
 }
-/** Test convenience: load cassette, set it active, spawn via SessionManager.
- *
- *  Callers MUST install `vi.mock('child_process', factory)` at the top of
- *  their test file with a factory that delegates `spawn` to
- *  `createReplaySpawn(getActiveCassette())`. See cassette-replay.test.ts
- *  for the canonical setup.
- *
- *  Returns the spawned TaskSession (typed loosely to avoid pulling the
- *  whole adapter type tree into src/testing/).
- */
-export async function replayThroughAdapter(cassettePath, sessionManager) {
-    const cassette = loadCassette(cassettePath);
-    setActiveCassette(cassette);
-    const session = sessionManager.spawn(cassette.header.meta.prompt, cassette.header.meta.adapter, {
-        cwd: cassette.header.meta.cwd_hint,
-    });
-    return session;
-}
 //# sourceMappingURL=replay-adapter.js.map