codehere 0.8.0 → 1.0.1

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

@@ -19,13 +19,19 @@
 import { existsSync, readFileSync } from 'fs';
 import { colors, symbols } from '../../../ui.js';
 import { AUDIT_FILE, verifyAuditChain } from '../../../infrastructure/hooks/claude-sdk-hook.js';
+import { verifyAuditTip, tipBlocksVerification } from '../../../infrastructure/hooks/audit-tip-signature.js';
+import { exportAat, aatToJsonl } from '../../../application/use-cases/export-aat.js';
+import { writeFileSync as writeFileSyncFs } from 'fs';
+import { trustedKeySet } from '../../../infrastructure/orchestration/thread-key-store.js';
 export function executeAuditCommand(sub, arg, options = {}) {
     if (!sub || sub === 'verify')
         return verify(options.json ?? false);
     if (sub === 'show')
         return show(arg, options.json ?? false);
+    if (sub === 'export')
+        return exportAatCmd(arg);
     process.stderr.write(colors.error(`${symbols.error} Unknown audit subcommand: ${sub}\n`) +
-        colors.dim('Try: codehere audit verify   |   codehere audit show <seq>\n'));
+        colors.dim('Try: codehere audit verify   |   codehere audit show <seq>   |   codehere audit export [out.jsonl]\n'));
     return 2;
 }
 /* ──────────────────────────────────────────────────────────────────────── */
@@ -33,16 +39,45 @@ export function executeAuditCommand(sub, arg, options = {}) {
 /* ──────────────────────────────────────────────────────────────────────── */
 function verify(json) {
     const result = verifyAuditChain(AUDIT_FILE);
+    // R2 · the tip signature catches a re-walked forgery the hash chain alone
+    // can't (a determined edit + recomputed hashes verifies green, but the signed
+    // entry's hash changes). ANCESTOR check: honest appends since signing are
+    // expected and pass; an edit at/below the signed seq, truncation, an untrusted
+    // re-sign, or a deleted .tipsig on a previously-signed chain all fail.
+    const tip = verifyAuditTip(AUDIT_FILE, trustedKeySet());
+    const tipTampered = tipBlocksVerification(tip);
+    // An empty or missing log has nothing to verify, and a chain walk over zero entries
+    // trivially succeeds. Reporting that as valid:true is the failure this product exists to
+    // catch: deleting the audit log is exactly the attack the hash chain is meant to detect,
+    // and the machine interface was answering "intact" to a machine that asked. The human
+    // path already says "No audit entries yet" and claims nothing, so only --json was lying.
+    // "Is my chain intact?" over no chain is not answered by yes.
+    const verifiable = result.totalEntries > 0;
+    const ok = verifiable && result.valid && !tipTampered;
     if (json) {
         process.stdout.write(JSON.stringify({
             path: AUDIT_FILE,
-            valid: result.valid,
+            valid: ok,
+            verifiable,
+            ...(verifiable ? {} : { reason: 'no audit entries — nothing to verify (is the hook installed?)' }),
+            chainHashesValid: result.valid,
+            writerMix: result.writerMix,
+            tipSignature: {
+                present: tip.present,
+                expectedButMissing: tip.expectedButMissing,
+                signatureValid: tip.signatureValid,
+                ancestorIntact: tip.ancestorIntact,
+                matchesTip: tip.matchesTip,
+                trusted: tip.trusted,
+                signer: tip.signerKeyB64,
+                reason: tip.reason,
+            },
             totalEntries: result.totalEntries,
             chainedEntries: result.chainedEntries,
             legacyEntries: result.legacyEntries,
             errors: result.errors,
         }, null, 2) + '\n');
-        return result.valid ? 0 : 1;
+        return ok ? 0 : 1;
     }
     // Human output · header, verdict line, counts, then errors if any.
     process.stdout.write('\n' + colors.dim('audit log: ') + colors.gray(AUDIT_FILE) + '\n\n');
@@ -63,6 +98,24 @@ function verify(json) {
             colors.dim(`  ${result.errors.length} break point${result.errors.length === 1 ? '' : 's'} detected.`) +
             '\n\n');
     }
+    // R1.5 · writer-provenance mix — honest about WHO wrote the entries. The
+    // verify surface must never imply everything went through the daemon when
+    // some entries are the hook's direct fallback or predate provenance.
+    const wm = result.writerMix;
+    if (result.chainedEntries > 0) {
+        process.stdout.write(colors.dim(`  written by: ${wm.daemon} daemon \u00B7 ${wm.hookDirect} hook-direct (no daemon reachable) \u00B7 ${wm.unattributed} unattributed (no writer field)\n\n`));
+    }
+    // R2 · tip-signature line — catches a re-walked forgery the hash chain can't.
+    if (tip.present && tip.signatureValid && tip.ancestorIntact && tip.trusted) {
+        process.stdout.write(colors.green(`${symbols.success} Chain signed`) +
+            colors.dim(tip.matchesTip
+                ? "  by a trusted key · no edits by anyone without this machine's key."
+                : '  by a trusted key · the signed prefix is intact (the chain has grown since).') +
+            '\n\n');
+    }
+    else if (tipTampered) {
+        process.stdout.write(colors.error(`${symbols.error} Tip signature FAILED`) + colors.dim(`  ${tip.reason}.`) + '\n\n');
+    }
     process.stdout.write(colors.bold('Counts:\n'));
     process.stdout.write(`  ${result.totalEntries.toString().padStart(6)} total entries\n`);
     process.stdout.write(`  ${result.chainedEntries.toString().padStart(6)} hash-chained (verifiable)\n`);
@@ -80,7 +133,7 @@ function verify(json) {
         }
         process.stdout.write('\n');
     }
-    return result.valid ? 0 : 1;
+    return ok ? 0 : 1;
 }
 function show(seqStr, json) {
     if (!seqStr || !/^\d+$/.test(seqStr)) {
@@ -123,4 +176,26 @@ function show(seqStr, json) {
         colors.dim('   Tip: run `codehere audit verify` to see the chained-entry count.\n'));
     return 2;
 }
+/* ──────────────────────────────────────────────────────────────────────── */
+/** R-AAT · export the chain as IETF draft-sharif-agent-audit-trail-00 JSONL.
+ *  The header line carries the honest scope notes (L0 trust level, codehere
+ *  canonicalization, hashed inputs) so the FILE can't claim more than it is. */
+function exportAatCmd(outPath) {
+    const exp = exportAat(AUDIT_FILE);
+    const target = outPath && outPath.trim() ? outPath.trim() : 'codehere-audit-aat.jsonl';
+    try {
+        writeFileSyncFs(target, aatToJsonl(exp), 'utf-8');
+    }
+    catch (e) {
+        process.stderr.write(colors.error(`${symbols.error} Could not write ${target}: ${e instanceof Error ? e.message : String(e)}\n`));
+        return 2;
+    }
+    process.stdout.write(colors.green(`${symbols.success} Exported ${exp.header.record_count} records`) +
+        colors.dim(` › ${target} (AAT draft-00 JSONL)\n`) +
+        (exp.skippedLegacy > 0
+            ? colors.dim(`  ${exp.skippedLegacy} legacy pre-chain entries skipped (no hash-chained position to export)\n`)
+            : '') +
+        colors.dim('  trust_level=L0 throughout · agents carry no cryptographic identity; the daemon signs the chain tip (recorder identity). Details in the header line.\n'));
+    return 0;
+}
 //# sourceMappingURL=audit-command.js.map

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

@@ -41,7 +41,7 @@ function showBudget() {
     newline();
     console.log(info("Today's estimated spend:"), fmtUsd(spend.totalUsd), `(${spend.sessionCount} session${spend.sessionCount === 1 ? '' : 's'})`);
     if (cfg.dailyUsd === null) {
-        console.log(info('Daily budget:'), 'none — no enforcement');
+        console.log(info('Daily budget:'), 'none · no enforcement');
         console.log(info('Set one with:'), 'codehere budget set 5');
     }
     else {
@@ -60,7 +60,7 @@ function showBudget() {
 function setBudget(value) {
     const n = Number(value.replace(/[$,]/g, ''));
     if (!Number.isFinite(n) || n <= 0) {
-        console.error(error('Invalid amount:'), value, '— expected a positive USD number.');
+        console.error(error('Invalid amount:'), value, '· expected a positive USD number.');
         process.exit(1);
     }
     const cfg = loadBudget();

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

@@ -0,0 +1,96 @@
+/**
+ * CLI: check — the simplest proof. codehere independently RE-RUNS your project's
+ * tests and reports the real result, so you trust what the AI actually did, not
+ * what it claimed. Zero setup, no daemon, no API. Exit 1 on failure (CI-usable).
+ */
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { colors, symbols } from '../../../ui.js';
+import { rerunTests } from '../../../application/use-cases/rerun-tests.js';
+/** Short commit SHA of `cwd`'s repo, or null when it isn't a git checkout. */
+function gitShortSha(cwd) {
+    try {
+        return execFileSync('git', ['rev-parse', '--short', 'HEAD'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * A paste-ready "verified outcome receipt": the one thing a reviewer can trust
+ * without re-running anything — codehere independently re-ran the suite, here's the
+ * observed result, pinned to a commit + timestamp, WITH the exact command to
+ * reproduce it independently. Plain markdown so it drops into a PR description or
+ * review comment as-is.
+ *
+ * Why reproducibility is the trust mechanism (not a digest): a self-computed hash
+ * over self-reported facts proves nothing — a sender could edit the facts AND the
+ * hash. What a third party can actually trust is REPRODUCING it: check out the
+ * pinned commit, run `codehere check`, get the same exit code. So the receipt leads
+ * with the reproduce command and is honest about SCOPE (a test re-run, not a
+ * security/logic audit) — it never says more than it verified.
+ *
+ * ponytail: this is the standalone (no-daemon) receipt. Upgrade path to true
+ * tamper-EVIDENCE (authenticity, not just reproducibility): when a ~/.codehere audit
+ * chain covers this commit, fold in its verified hash (audit-chain.ts) so the receipt
+ * also carries a digest a third party can check against an append-only log.
+ */
+function buildProofBlock(cwd, r) {
+    const sha = gitShortSha(cwd);
+    const when = new Date().toISOString().replace('T', ' ').slice(0, 16) + ' UTC';
+    const at = sha ? `commit \`${sha}\`` : 'the working tree';
+    if (!r.ran) {
+        return `> **codehere · verified outcome receipt** — no suite re-run (${r.skippedReason || 'none detected'}) · nothing verified · ${when}\n`;
+    }
+    if (r.exitCode === 126 || r.exitCode === 127) {
+        return `> **codehere · verified outcome receipt** — couldn't run \`${r.command}\` on ${at} (runner not installed, exit ${r.exitCode}) · unverified · ${when}\n`;
+    }
+    const passed = (r.exitCode ?? 1) === 0;
+    const counts = typeof r.passed === 'number' || typeof r.failed === 'number'
+        ? ` (${r.passed ?? '?'} passed · ${r.failed ?? 0} failed)`
+        : '';
+    const verdict = passed ? '✓ tests pass' : '✕ tests FAIL';
+    // Reproduce line: the real, verifiable trust — anyone can re-run and confirm.
+    const reproduce = sha ? `> Reproduce independently: \`git checkout ${sha} && codehere check\`\n` : '';
+    return (`> **codehere · verified outcome receipt** · ${verdict}${counts}\n` +
+        `> codehere independently re-ran \`${r.command}\` on ${at} — exit ${r.exitCode}. Observed, not the AI's claim. · ${when}\n` +
+        reproduce +
+        `> Scope: the project's test suite — not a security or logic audit.\n`);
+}
+export async function executeCheckCommand(target, options = {}) {
+    const cwd = resolve(target || '.');
+    const r = await rerunTests(cwd);
+    if (options.json) {
+        process.stdout.write(JSON.stringify({ cwd, ...r }, null, 2) + '\n');
+        return r.ran && (r.exitCode ?? 1) !== 0 ? 1 : 0;
+    }
+    if (options.proof) {
+        process.stdout.write(buildProofBlock(cwd, r));
+        return r.ran && (r.exitCode ?? 1) !== 0 ? 1 : 0;
+    }
+    if (!r.ran) {
+        process.stdout.write(colors.dim(`No test suite codehere can run here — ${r.skippedReason || 'none detected'}.\n`) +
+            colors.dim('codehere proves the AI by re-running your tests; add one (npm test / node --test / pytest / go test / cargo test) and run check again.\n'));
+        return 0; // nothing to verify is not a failure
+    }
+    // Honesty: exit 126/127 means the test command couldn't be RUN (binary missing /
+    // deps not installed), not that the tests failed. Never report "FAIL" for that.
+    if (r.exitCode === 126 || r.exitCode === 127) {
+        process.stdout.write('\n' +
+            colors.error(`${symbols.error} Couldn't run the tests`) +
+            colors.dim(`  — '${r.command}' exited ${r.exitCode} (the runner isn't installed; try installing deps, then re-run).\n\n`));
+        return 1; // non-zero for CI (unverified), but NOT a false "tests failed"
+    }
+    const passed = (r.exitCode ?? 1) === 0;
+    const counts = typeof r.passed === 'number' || typeof r.failed === 'number'
+        ? `  ${r.passed ?? '?'} passed · ${r.failed ?? 0} failed`
+        : '';
+    process.stdout.write('\n' +
+        (passed ? colors.success(`${symbols.success} Tests pass`) : colors.error(`${symbols.error} Tests FAIL`)) +
+        colors.dim(`  — codehere re-ran them itself (${r.command}, exit ${r.exitCode})${counts}\n`) +
+        colors.dim("This is observed reality, not the agent's claim.\n\n"));
+    return passed ? 0 : 1;
+}
+//# sourceMappingURL=check-command.js.map

package/dist/presentation/cli/commands/context-source-command.js

@@ -92,6 +92,10 @@ function statusTag(s) {
             return colors.gray('● manual      ');
         case 'disconnected':
             return colors.gray('○ disconnected');
+        default:
+            // A status this CLI doesn't know yet must never print "undefined"
+            // (2026-06-07 audit, Lane C: draw.io/GitHub rows did exactly that).
+            return colors.gray(('○ ' + String(s ?? 'unknown')).padEnd(14).slice(0, 14));
     }
 }
 /* ──────────────────────────────────────────────────────────────────────── */
@@ -128,9 +132,24 @@ async function connect(providerArg, json, openBrowser) {
         if (json) {
             process.stdout.write(JSON.stringify({ error: 'connect_failed', detail: r.error }, null, 2) + '\n');
         }
-        else {
+        else if (r.status === 0) {
+            // Only a NETWORK failure means the daemon is unreachable.
             process.stderr.write(daemonUnreachableNote(r.error ?? ''));
         }
+        else {
+            // The daemon answered — show ITS message, don't blame the connection
+            // (2026-06-07 audit, Lane C: a 404 from a live daemon printed
+            // "Daemon not reachable").
+            let msg = r.error ?? `request failed (${r.status})`;
+            try {
+                const j = JSON.parse(msg);
+                msg = j.error || j.message || msg;
+            }
+            catch {
+                /* raw text is fine */
+            }
+            process.stderr.write(colors.error(`${symbols.error} ${providerArg}: ${msg}\n`));
+        }
         return 2;
     }
     const url = r.data?.authorizeUrl;

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

@@ -47,7 +47,7 @@ const COMMAND_INFO = {
     },
     trust: {
         name: 'trust',
-        description: 'Scan your project for security issues — instant score, no API key needed',
+        description: 'Scan your project for security issues · instant score, no API key needed',
         usage: 'codehere trust [path] [options]',
         examples: [
             'codehere trust .',
@@ -82,7 +82,7 @@ const COMMAND_INFO = {
     },
     status: {
         name: 'status',
-        description: 'Dashboard — sessions, blocked calls, audit trends',
+        description: 'Dashboard · sessions, blocked calls, audit trends',
         usage: 'codehere status [options]',
         examples: ['codehere status', 'codehere status --sessions', 'codehere status --weekly', 'codehere status --json'],
         options: [
@@ -172,7 +172,7 @@ const COMMAND_INFO = {
     },
     health: {
         name: 'health',
-        description: 'System health check — filesystem, memory, audit log accessible',
+        description: 'System health check · filesystem, memory, audit log accessible',
         usage: 'codehere health [options]',
         examples: ['codehere health', 'codehere health --json'],
         options: [{ flag: '--json', description: 'Output as JSON' }],
@@ -269,7 +269,7 @@ function displayCommandHelp(commandName) {
         return;
     }
     newline();
-    console.log(colors.bold(command.name) + colors.dim(' — ' + command.description));
+    console.log(colors.bold(command.name) + colors.dim(' · ' + command.description));
     newline();
     console.log(colors.bold('Usage'));
     console.log('  ' + colors.cyan(command.usage));
@@ -302,7 +302,7 @@ function printCmd(name, desc) {
 }
 function displayGeneralHelp() {
     newline();
-    console.log(colors.bold('codehere') + colors.dim(' — A PM for your AI coding agents'));
+    console.log(colors.bold('codehere') + colors.dim(' · Your AI coding agents: audited, cost-bounded, cross-vendor'));
     newline();
     console.log(colors.bold('Delegate'));
     for (const cmd of ['start', 'task', 'kill']) {

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

@@ -132,10 +132,10 @@ export async function executeHookCommand(subcommand, options = {}) {
                 console.log(colors.dim(`  Skills installed to: ${SKILLS_TARGET_DIR}`));
                 newline();
                 console.log(colors.bold('Slash commands now available in your AI assistant:'));
-                console.log(colors.dim('  /codehere:trust        — scan current project'));
-                console.log(colors.dim('  /codehere:report       — generate shareable audit report'));
-                console.log(colors.dim('  /codehere:audit        — pre-merge security check'));
-                console.log(colors.dim('  /codehere:hook-status  — check hook health'));
+                console.log(colors.dim('  /codehere:trust        · scan current project'));
+                console.log(colors.dim('  /codehere:report       · generate shareable audit report'));
+                console.log(colors.dim('  /codehere:audit        · pre-merge security check'));
+                console.log(colors.dim('  /codehere:hook-status  · check hook health'));
             }
             newline();
             console.log(colors.dim('  Restart your AI assistant for changes to take effect.'));
@@ -219,7 +219,7 @@ export async function executeHookCommand(subcommand, options = {}) {
                 }
             }
             else {
-                console.log(colors.dim("  No events logged yet — run Claude Code and it'll start tracking."));
+                console.log(colors.dim("  No events logged yet · run Claude Code and it'll start tracking."));
                 newline();
             }
             break;

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

@@ -117,7 +117,7 @@ Things you've been burned by.]
 
 ## Implement a change
 
-> "Read .codehere/CONTEXT.md. [Describe the change in user-visible terms — what
+> "Read .codehere/CONTEXT.md. [Describe the change in user-visible terms · what
 > behavior is added, removed, or changed.] Match existing conventions. Don't
 > touch unrelated files. Don't add new dependencies."
 
@@ -225,7 +225,7 @@ export const F3_TEMPLATES = [
   "version": "v0.5",
   "patterns_builtin": [],
   "patterns_project": [],
-  "_note": "Run 'codehere protocols export' to populate patterns_builtin[] from the trust-scorer pattern bank. Add project-specific patterns to patterns_project[] — those are preserved across re-exports. Do NOT hand-edit patterns_builtin[] — it's regenerated on each export."
+  "_note": "Run 'codehere protocols export' to populate patterns_builtin[] from the trust-scorer pattern bank. Add project-specific patterns to patterns_project[] · those are preserved across re-exports. Do NOT hand-edit patterns_builtin[] · it's regenerated on each export."
 }
 `,
     },
@@ -436,13 +436,25 @@ export function scaffoldProjectAt(root, options = {}) {
     const noEpisodic = { result: 'failed', sourcePath: '', targetPath: '' };
     // Refuse if .codehere itself is a symlink — would redirect every subsequent write.
     if (existsSync(codehereDir) && isSymlink(codehereDir)) {
-        return { ok: false, reason: 'codehere-dir-is-symlink', ...empty, episodic: noEpisodic, gitignore: { result: 'skipped' } };
+        return {
+            ok: false,
+            reason: 'codehere-dir-is-symlink',
+            ...empty,
+            episodic: noEpisodic,
+            gitignore: { result: 'skipped' },
+        };
     }
     if (!existsSync(codehereDir)) {
         mkdirSync(codehereDir, { recursive: true });
     }
     else if (!statSync(codehereDir).isDirectory()) {
-        return { ok: false, reason: 'codehere-not-a-directory', ...empty, episodic: noEpisodic, gitignore: { result: 'skipped' } };
+        return {
+            ok: false,
+            reason: 'codehere-not-a-directory',
+            ...empty,
+            episodic: noEpisodic,
+            gitignore: { result: 'skipped' },
+        };
     }
     // F3 layout: ensure all directories exist before writing any seeds.
     // Per-segment symlink check on EACH directory's ancestors; if .codehere/memory
@@ -495,7 +507,7 @@ export function executeInitCommand(options = {}) {
         const r = scaffoldProjectAt(root, options);
         if (!r.ok) {
             if (r.reason === 'codehere-dir-is-symlink') {
-                console.log(`  ${error('refused')} .codehere is a symlink — refusing to follow. Remove it first.`);
+                console.log(`  ${error('refused')} .codehere is a symlink · refusing to follow. Remove it first.`);
             }
             else {
                 console.log(`  ${error('refused')} .codehere exists but is not a directory.`);
@@ -512,31 +524,31 @@ export function executeInitCommand(options = {}) {
             console.log(`  ${info(`exists `)} .codehere/${f}  ${colors.dim('(use --force to overwrite)')}`);
         }
         for (const f of refused) {
-            console.log(`  ${error(`refused`)} .codehere/${f}  ${colors.dim('(symlink — remove it first)')}`);
+            console.log(`  ${error(`refused`)} .codehere/${f}  ${colors.dim('(symlink · remove it first)')}`);
         }
         for (const d of refusedDirs) {
-            console.log(`  ${error(`refused`)} .codehere/${d}/  ${colors.dim('(intermediate symlink — remove it first)')}`);
+            console.log(`  ${error(`refused`)} .codehere/${d}/  ${colors.dim('(intermediate symlink · remove it first)')}`);
         }
         // F3 Task 3 — episodic AGENT_LEARNINGS.jsonl symlink to user's session log.
         const episodic = r.episodic;
         switch (episodic.result) {
             case 'created':
-                console.log(`  ${success('linked  ')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl → ${episodic.targetPath}`);
+                console.log(`  ${success('linked  ')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl › ${episodic.targetPath}`);
                 break;
             case 're-linked':
-                console.log(`  ${success('re-linked')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl → ${episodic.targetPath}  ${colors.dim('(target updated)')}`);
+                console.log(`  ${success('re-linked')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl › ${episodic.targetPath}  ${colors.dim('(target updated)')}`);
                 break;
             case 'exists':
                 // Quiet on the no-op case to avoid output noise on re-runs.
                 break;
             case 'refused':
-                console.log(`  ${error('refused ')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl  ${colors.dim('(real file or symlinked ancestor present — remove it first to enable the symlink)')}`);
+                console.log(`  ${error('refused ')} .codehere/memory/episodic/AGENT_LEARNINGS.jsonl  ${colors.dim('(real file or symlinked ancestor present · remove it first to enable the symlink)')}`);
                 break;
             case 'root-skipped':
-                console.log(`  ${warning('skipped ')} episodic symlink  ${colors.dim('(running as root — would create root-owned files in HOME; re-run as your normal user)')}`);
+                console.log(`  ${warning('skipped ')} episodic symlink  ${colors.dim('(running as root · would create root-owned files in HOME; re-run as your normal user)')}`);
                 break;
             case 'failed':
-                console.log(`  ${warning('skipped ')} episodic symlink  ${colors.dim('(could not write — HOME may be read-only)')}`);
+                console.log(`  ${warning('skipped ')} episodic symlink  ${colors.dim('(could not write · HOME may be read-only)')}`);
                 break;
         }
         if (!options.noGitignore) {
@@ -553,7 +565,7 @@ export function executeInitCommand(options = {}) {
                     console.log(`  ${warning('skipped')} .gitignore  ${colors.dim('(no .git directory at root)')}`);
                     break;
                 case 'refused-symlink':
-                    console.log(`  ${error('refused')} .gitignore is a symlink — left untouched.`);
+                    console.log(`  ${error('refused')} .gitignore is a symlink · left untouched.`);
                     break;
             }
         }
@@ -571,7 +583,7 @@ export function executeInitCommand(options = {}) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        console.error(`\n  ${error('failed')} codehere init — ${msg}\n`);
+        console.error(`\n  ${error('failed')} codehere init · ${msg}\n`);
         process.exitCode = 1;
     }
 }