codehere 0.7.1 → 1.0.1

package/dist/index.js

@@ -15,15 +15,67 @@ import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
+import { readFileSync } from 'fs';
 // ── Global crash safety ───────────────────────────────────────────────────
-// Unhandled rejections and exceptions must never silently kill the daemon.
-process.on('unhandledRejection', (reason) => {
-    console.error('[codehere] unhandledRejection:', reason instanceof Error ? reason.stack : reason);
-});
+// The old comment here said these "must never silently kill the daemon", and the
+// code delivered the opposite of safety: `process.exitCode = 1` is only honoured
+// once the event loop DRAINS, which for a daemon is never. Measured 2026-08-08 —
+// after an uncaught exception the process was still running and still serving a
+// second later, and would have gone on appending to a hash chain from a state
+// Node itself considers undefined. Staying up is not resilience when the thing
+// you are protecting is a record of what happened.
+//
+// One copy-pasteable block, no secrets: version/platform/node/state-dir are what
+// a bug report needs, and none of them is sensitive. The error's own message may
+// contain a path, which is why the state dir is named rather than dumped.
+// Read from package.json rather than the getVersion() imported further down:
+// the crash guard installs before most module init, and must not itself throw
+// while reporting a throw.
+function safeVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf-8')).version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function crashReport(kind, err) {
+    const e = err instanceof Error ? err : new Error(String(err));
+    return [
+        '',
+        `[codehere] ${kind} — this process is stopping.`,
+        `  version : ${safeVersion()}`,
+        `  node    : ${process.version} on ${process.platform} ${process.arch}`,
+        `  state   : ${process.env.CODEHERE_HOME ? '$CODEHERE_HOME' : '~/.codehere'}`,
+        `  pid     : ${process.pid}`,
+        '',
+        (e.stack ?? e.message)
+            .split('\n')
+            .map((l) => `  ${l}`)
+            .join('\n'),
+        '',
+        '  Report at https://github.com/muhammadegaa/codehere/issues with the block above.',
+        '',
+    ].join('\n');
+}
 process.on('uncaughtException', (err) => {
-    console.error('[codehere] uncaughtException:', err.stack);
-    // persist what we can before dying
-    process.exitCode = 1;
+    // Node's own guidance: after this the process state is undefined. Exiting is
+    // the honest move — a restarted daemon re-reads the chain from disk and is
+    // correct again; a surviving one is silently guessing.
+    console.error(crashReport('uncaughtException', err));
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    // Deliberately NOT fatal, unlike the above. The codebase has 17 explicitly
+    // `void`-marked fire-and-forget promises (re-persist, enrichment) whose
+    // rejection does not mean the process is corrupt, and killing the daemon on
+    // one would be a worse regression than the bug being fixed. It is made loud
+    // and attributed instead, so it cannot hide.
+    // The residual risk is real and worth naming: a rejected audit-append would be
+    // logged here and the process would continue. Closing that belongs at the
+    // write site, not in a global handler.
+    console.error(crashReport('unhandledRejection (non-fatal, continuing)', reason).replace(' — this process is stopping.', ' — continuing, but something is wrong.'));
 });
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeInitCommand } from './presentation/cli/commands/init-command.js';
@@ -35,11 +87,15 @@ import { executeStatusCommand } from './presentation/cli/commands/status-command
 import { executeHookCommand } from './presentation/cli/commands/hook-command.js';
 import { executePermissionCommand } from './presentation/cli/commands/permission-command.js';
 import { executeBudgetCommand } from './presentation/cli/commands/budget-command.js';
+import { executeTeamCommand } from './presentation/cli/commands/team-command.js';
 import { executeNarratorCommand } from './presentation/cli/commands/narrator-command.js';
 import { executeTrustCommand } from './presentation/cli/commands/trust-command.js';
+import { executeCheckCommand } from './presentation/cli/commands/check-command.js';
+import { executeScanCommand } from './presentation/cli/commands/scan-command.js';
 import { executeReportCommand } from './presentation/cli/commands/report-command.js';
 import { executeScanToolCommand } from './presentation/cli/commands/scan-tool-command.js';
 import { executeVerifyCommand } from './presentation/cli/commands/verify-command.js';
+import { executeSearchCommand } from './presentation/cli/commands/search-command.js';
 import { executeAuditCommand } from './presentation/cli/commands/audit-command.js';
 import { executeContextSourceCommand } from './presentation/cli/commands/context-source-command.js';
 import { executeThreadCommand } from './presentation/cli/commands/thread-command.js';
@@ -62,7 +118,7 @@ import { checkTypo, looksLikeUnknownCommand } from './utils/typo-guard.js';
 const program = new Command();
 program
     .name('codehere')
-    .description('A PM for your AI coding agents. Delegate a task, watch it run, and get a plain-English report with a trust score on every file it changed.')
+    .description('Your AI coding agents: audited, cost-bounded, cross-vendor. Delegate a task, watch it run, and get a plain-English report with a trust score on every file it changed.')
     .version(getVersion())
     .configureHelp({ helpWidth: 80, sortSubcommands: true })
     // rc.18: many users hit `codehere --help` first and get Commander's flat
@@ -272,7 +328,6 @@ program
     .command('status')
     .description('Security dashboard — hook activity, blocked calls, cost routing')
     .option('--json', 'Machine-readable JSON')
-    .option('--tasks', 'Show recent tasks (experimental)')
     .option('--sessions', 'Show per-session audit trail (multi-agent analysis)')
     .option('--session <id>', 'Drill into a specific session (first 8+ chars of session ID)')
     .option('--trust', 'Include a quick trust scan of the current directory')
@@ -330,6 +385,37 @@ program
         process.exit(1);
     }
 });
+// ── check ────────────────────────────────────────────────────────────────────
+program
+    .command('check')
+    .description('Re-run your tests independently — proof of what the AI actually did, not what it claimed')
+    .argument('[target]', 'Repo or directory to check (default: current directory)')
+    .option('--json', 'Machine-readable output')
+    .option('--proof', 'Emit a paste-ready proof block for a PR description or review comment')
+    .action(async (target, options) => {
+    try {
+        process.exitCode = await executeCheckCommand(target, { json: options?.json, proof: options?.proof });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+// ── scan ───────────────────────────────────────────────────────────────────────
+program
+    .command('scan')
+    .description('Find the ONE thing that will get your app hacked — fast pass (gitleaks + semgrep), no API key')
+    .argument('[target]', 'App directory to scan (default: current directory)')
+    .option('--json', 'Machine-readable output')
+    .action(async (target, options) => {
+    try {
+        process.exitCode = await executeScanCommand(target, { json: options?.json });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
 // ── report ───────────────────────────────────────────────────────────────────
 program
     .command('report')
@@ -395,6 +481,21 @@ Exit codes:
         process.exitCode = 1;
     }
 });
+program
+    .command('search')
+    .description('Search your past agent sessions — with provenance (which agent, whether it succeeded)')
+    .argument('<query>', 'What to look for across your past sessions')
+    .option('--json', 'Machine-readable JSON')
+    .option('--limit <n>', 'Max results (default 10)')
+    .action((query, options) => {
+    try {
+        process.exitCode = executeSearchCommand(query, options);
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+});
 // ── audit ────────────────────────────────────────────────────────────────────
 // F-05 of the demo v12 backlog · expose the hash-chain verifier as a CLI.
 program
@@ -564,6 +665,22 @@ program
         process.exit(1);
     }
 });
+// ── team (local-first team spend ledger) ─────────────────────────────────────
+program
+    .command('team')
+    .description("Merge each machine's daily spend into one team total (local-first, no cloud)")
+    .argument('[subcommand]', 'sync | set-dir | budget')
+    .argument('[value]', 'path (for set-dir) or amount in USD (for budget)')
+    .option('--strict', 'exit non-zero if any share is tampered or its audit chain is broken (for CI / enterprise gating)')
+    .action(async (subcommand, value, options) => {
+    try {
+        await executeTeamCommand(subcommand, value, { strict: Boolean(options?.strict) });
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
 // ── serve (MCP server) ───────────────────────────────────────────────────────
 program
     .command('serve')
@@ -577,25 +694,42 @@ program
     const host = options?.host ?? '127.0.0.1';
     const token = options?.token;
     if (options?.showConfig) {
+        const url = `http://${host}:${port}/mcp`;
+        const authHeader = token ? ` --header "Authorization: Bearer ${token}"` : '';
         const configBlock = {
             mcpServers: {
                 codehere: {
-                    url: `http://${host}:${port}/mcp`,
+                    url,
                     ...(token ? { headers: { Authorization: `Bearer ${token}` } } : {}),
                 },
             },
         };
-        console.log('\nAdd to Claude Desktop or Cursor MCP settings:\n');
+        newline();
+        console.log(colors.bold('Connect codehere to your coding agent') + colors.dim('  (codehere must be running)'));
+        newline();
+        console.log(colors.bold('Claude Code:'));
+        console.log('  claude mcp add --transport http codehere ' + url + authHeader);
+        newline();
+        console.log(colors.bold('Cursor') + colors.dim('  (.cursor/mcp.json in the project, or ~/.cursor/mcp.json):'));
         console.log(JSON.stringify(configBlock, null, 2));
         newline();
-        console.log(colors.dim('Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json'));
-        console.log(colors.dim('Cursor: Settings > MCP Servers'));
+        console.log(colors.bold('Claude Desktop') +
+            colors.dim('  (~/Library/Application Support/Claude/claude_desktop_config.json):'));
+        console.log(JSON.stringify(configBlock, null, 2));
         newline();
         return;
     }
     try {
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
         const server = startMCPServer({ port, host, token });
+        // Wait until the port is actually bound before claiming success — otherwise
+        // a listen() failure (e.g. port in use) crashes with a raw stack trace
+        // AFTER the "running" banner already printed. The catch below then renders
+        // a friendly message instead.
+        await new Promise((resolve, reject) => {
+            server.once('listening', () => resolve());
+            server.once('error', reject);
+        });
         newline();
         console.log(success(`codehere MCP server running`));
         newline();
@@ -607,6 +741,8 @@ program
         console.log('  codehere_scan    — scan text for injection/threats');
         console.log('  codehere_review  — scan a directory, return riskiest files');
         console.log('  codehere_audit   — read hook audit log');
+        console.log("  codehere_spend   — today's spend by agent and project, vs budget");
+        console.log('  codehere_team    — merged team cost and record across machines');
         newline();
         console.log(colors.dim('  Run with --show-config to get the MCP client config block'));
         console.log(colors.dim('  Press Ctrl+C to stop'));
@@ -633,11 +769,18 @@ program
     .option('-p, --port <number>', 'Port to listen on', '3773')
     .option('--host <host>', 'Host to bind to', '127.0.0.1')
     .option('--no-open', "Don't auto-open the browser")
+    .option('--token <token>', 'Require a Bearer token for every request (use when binding to a non-localhost host)')
     .option('--cloud', 'Enable cloud sync — push session state to codehere.uk/app for remote monitoring')
     .action(async (options) => {
     const port = parseInt(options?.port ?? '3773', 10);
     const host = options?.host ?? '127.0.0.1';
-    const shouldOpen = options?.open !== false;
+    const token = options?.token;
+    // Auto-open only for a real human at a terminal. A daemon spawned with
+    // piped stdio (tests, CI, scripts, nohup) must NEVER pop a browser —
+    // suite runs were opening 2 tabs per run at the test daemons' ports
+    // (Ega, 2026-06-07: 6 stray tabs from 3 runs). Machine-guard, not a
+    // convention the next test has to remember.
+    const shouldOpen = options?.open !== false && process.stdout.isTTY === true;
     const cloud = options?.cloud === true;
     const url = `http://${host}:${port}/`;
     const openBrowser = async () => {
@@ -661,8 +804,8 @@ program
             try {
                 const { migrate } = await import('./infrastructure/storage/project-thread-migration.js');
                 const result = migrate({
-                    sourceJsonl: join(homedir(), '.codehere/sessions.jsonl'),
-                    targetDir: join(homedir(), '.codehere/projects'),
+                    sourceJsonl: join(process.env.CODEHERE_HOME || homedir(), '.codehere/sessions.jsonl'),
+                    targetDir: join(process.env.CODEHERE_HOME || homedir(), '.codehere/projects'),
                 });
                 if (result.threadsWritten > 0) {
                     console.log(colors.dim(`  v0.6 migration: created ${result.threadsWritten} project thread(s) from ${result.sessionsProcessed} sessions (${result.durationMs}ms)`));
@@ -690,8 +833,12 @@ program
                 }
             })();
         }
+        const localhostOnly = host === '127.0.0.1' || host === 'localhost' || host === '::1';
+        if (!localhostOnly && !token) {
+            console.warn(colors.warning(`  Exposed on ${host} with no token — anyone who can reach this host can drive your agents. Add --token <secret> to require auth.`));
+        }
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
-        const server = startMCPServer({ port, host });
+        const server = startMCPServer({ port, host, token });
         // Wait for the server to either start listening or fail. The default
         // Node behavior on listen() failure is an unhandled 'error' event which
         // crashes the process with a stack trace. We catch it here so the user
@@ -704,7 +851,7 @@ program
         console.log(success('codehere is running'));
         newline();
         console.log(colors.bold('Tasks:') + '    ' + url);
-        console.log(colors.bold('History:') + '  ' + `http://${host}:${port}/history`);
+        console.log(colors.bold('Verify:') + '   ' + `http://${host}:${port}/verify`);
         console.log(colors.bold('MCP:') + '      ' + `http://${host}:${port}/mcp`);
         if (cloud) {
             console.log(colors.bold('Cloud:') + '     ' + 'https://codehere.uk/app');
@@ -765,8 +912,12 @@ program
                     console.log(colors.dim(`  version: ${existing.version}`));
                 }
                 newline();
-                console.log(colors.dim('  Opening browser...'));
-                await openBrowser();
+                // Honor --no-open here too — found via the v1 stranger walk: a second
+                // `start --no-open` against a running daemon popped a browser anyway.
+                if (shouldOpen) {
+                    console.log(colors.dim('  Opening browser...'));
+                    await openBrowser();
+                }
                 process.exit(0);
             }
             console.error(error(`Port ${port} is in use by another process.`));
@@ -777,6 +928,83 @@ program
         process.exit(1);
     }
 });
+// ── reply (continue a goal — follow-up turn to an existing session) ──────────
+// Multi-turn IS supported (claude --resume etc.) + context carries, but the
+// only surface was the web UI; the CLI had no way to continue a goal. Also the
+// message API needs the exact UUID while reports show an 8-char prefix — so this
+// resolves a prefix → full id (dogfood findings 2026-06-09).
+program
+    .command('reply <id> <text...>')
+    .description('Continue a goal — send a follow-up turn to an existing session (context carries).')
+    .option('-p, --port <number>', 'Daemon port', '3773')
+    .option('--host <host>', 'Daemon host', '127.0.0.1')
+    .addHelpText('after', `
+Examples:
+  $ codehere reply a5a39692 "now add a clear() method and a test"
+  The id may be the 8-char prefix that \`codehere task\` printed.`)
+    .action(async (idArg, textParts, options) => {
+    const text = textParts.join(' ').trim();
+    if (!text) {
+        console.error(error('No message. Usage: codehere reply <id> "your follow-up"'));
+        process.exit(1);
+    }
+    const port = parseInt(options?.port ?? '3773', 10);
+    const host = options?.host ?? '127.0.0.1';
+    const base = `http://${host}:${port}`;
+    const http = await import('http');
+    // Resolve a prefix id → full session id (reports show 8-char prefixes).
+    const fullId = await new Promise((resolve) => {
+        http
+            .get(`${base}/api/tasks`, (res) => {
+            let b = '';
+            res.on('data', (c) => (b += c.toString()));
+            res.on('end', () => {
+                try {
+                    const j = JSON.parse(b);
+                    const all = [...(j.spawned ?? []), ...(j.persisted ?? [])];
+                    const m = all.find((s) => s.sessionId === idArg) ?? all.find((s) => s.sessionId.startsWith(idArg));
+                    resolve(m ? m.sessionId : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        })
+            .on('error', () => resolve(null));
+    });
+    if (!fullId) {
+        console.error(error(`No session matching "${idArg}". See recent ones: codehere search`));
+        process.exit(1);
+    }
+    console.log(colors.dim(`  Continuing session ${fullId.slice(0, 8)}… (context carries; the agent keeps the prior turns)`));
+    const body = JSON.stringify({ text });
+    const result = await new Promise((resolve) => {
+        const r = http.request(`${base}/api/task/${fullId}/message`, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } }, (res) => {
+            let b = '';
+            res.on('data', (c) => (b += c.toString()));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(b));
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        r.on('error', () => resolve(null));
+        r.write(body);
+        r.end();
+    });
+    if (!result) {
+        console.error(error(`Could not reach the daemon at ${base}. Start it with: codehere start`));
+        process.exit(1);
+    }
+    if (result.error) {
+        console.error(error(result.error));
+        process.exit(1);
+    }
+    console.log('\n' + (result.result ?? '(the agent left no text response)') + '\n');
+});
 // ── task (spawn an agent session via CLI) ────────────────────────────────────
 program
     .command('task <prompt...>')
@@ -785,6 +1013,7 @@ program
     .option('--host <host>', 'Daemon host', '127.0.0.1')
     .option('--agent <id>', 'Which agent to run (claude-code, codex, aider, gemini, opencode). Default: auto.')
     .option('--watch', 'Watch it work and print the report when it finishes')
+    .option('--cwd <path>', 'Repo/directory the agent works in (default: where you run this)')
     .addHelpText('after', `
 Examples:
   $ codehere task "fix the totalValue bug in inventory.js"          # assign, get a session id
@@ -802,9 +1031,13 @@ Needs a running daemon: start one with \`codehere start\` (or \`codehere serve\`
     const host = options?.host ?? '127.0.0.1';
     const base = `http://${host}:${port}`;
     const http = await import('http');
+    const { resolve: resolvePath } = await import('path');
     const { waitForDeliverable, formatDeliverable } = await import('./presentation/cli/task-deliverable.js');
+    // The agent must run in the repo the USER targets — not the daemon's dir.
+    // Default to where `codehere task` was invoked; allow an explicit --cwd.
+    const cwd = resolvePath(options?.cwd ?? process.cwd());
     const spawnResult = await new Promise((resolve) => {
-        const body = JSON.stringify({ prompt, ...(options?.agent ? { agent: options.agent } : {}) });
+        const body = JSON.stringify({ prompt, cwd, ...(options?.agent ? { agent: options.agent } : {}) });
         const r = http.request(`${base}/api/task`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
@@ -867,7 +1100,7 @@ Needs a running daemon: start one with \`codehere start\` (or \`codehere serve\`
                                 if (printed.has(s.label))
                                     continue; // one line per step, on first settle
                                 printed.add(s.label);
-                                const mark = s.state === 'failed' ? colors.error('✗') : colors.success('✓');
+                                const mark = s.state === 'failed' ? colors.error('✕') : colors.success('✓');
                                 const text = s.kind === 'say' ? colors.dim(s.label) : s.label;
                                 console.log(`  ${mark} ${text}`);
                             }
@@ -931,13 +1164,22 @@ program
             res.on('end', () => {
                 if (res.statusCode === 200)
                     console.log(success(`Killed ${sessionId}`));
-                else
-                    console.error(error(`Failed (${res.statusCode}): ${buf}`));
+                else if (res.statusCode === 404) {
+                    // Plain English + nonzero exit — scripts must be able to trust us
+                    // (audit 2026-06-07: kill exited 0 and leaked raw JSON on failure).
+                    console.error(error(`No running task found for "${sessionId}". See active tasks with: codehere status`));
+                    process.exitCode = 1;
+                }
+                else {
+                    console.error(error(`Could not kill ${sessionId} — the daemon said ${res.statusCode}. Details: ${buf}`));
+                    process.exitCode = 1;
+                }
                 resolve();
             });
         });
-        r.on('error', (err) => {
-            console.error(error(err.message));
+        r.on('error', () => {
+            console.error(error(`Could not reach the daemon at http://${host}:${port}. Start it with: codehere start`));
+            process.exitCode = 1;
             resolve();
         });
         r.end();
@@ -947,8 +1189,8 @@ program
 program
     .command('migrate-threads', { hidden: true }) // hidden from --help (v0.6.0 internal — auto-runs on daemon start once wired)
     .description('Migrate sessions.jsonl into per-project thread.jsonl files (v0.6.0 schema)')
-    .option('--source <path>', 'Source sessions.jsonl', `${homedir()}/.codehere/sessions.jsonl`)
-    .option('--target <dir>', 'Target projects dir', `${homedir()}/.codehere/projects`)
+    .option('--source <path>', 'Source sessions.jsonl', `${process.env.CODEHERE_HOME || homedir()}/.codehere/sessions.jsonl`)
+    .option('--target <dir>', 'Target projects dir', `${process.env.CODEHERE_HOME || homedir()}/.codehere/projects`)
     .option('--dry-run', 'Report what migrate WOULD do, write nothing', false)
     .option('--rollback', 'Remove the projects dir; sessions.jsonl untouched', false)
     .option('--keep-temp-dirs', 'Include /tmp + /var/folders cwds (default skips them)', false)
@@ -999,20 +1241,26 @@ program
     .argument('<shell>', 'Shell type: bash, zsh, or fish')
     .action(async (shell) => {
     try {
+        // The REAL visible command set — completions must never drift from
+        // registration again (audit 2026-06-07: the generators shipped a
+        // fictional alpha-era command list).
+        const cmds = program.commands
+            .filter((c) => !c._hidden)
+            .map((c) => ({ name: c.name(), description: c.description().split('\n')[0] }));
         switch (shell.toLowerCase()) {
             case 'bash': {
                 const { generateBashCompletion } = await import('./infrastructure/completion/bash-completion.js');
-                console.log(generateBashCompletion());
+                console.log(generateBashCompletion(cmds));
                 break;
             }
             case 'zsh': {
                 const { generateZshCompletion } = await import('./infrastructure/completion/zsh-completion.js');
-                console.log(generateZshCompletion());
+                console.log(generateZshCompletion(cmds));
                 break;
             }
             case 'fish': {
                 const { generateFishCompletion } = await import('./infrastructure/completion/fish-completion.js');
-                console.log(generateFishCompletion());
+                console.log(generateFishCompletion(cmds));
                 break;
             }
             default:

package/dist/infrastructure/completion/bash-completion.js

@@ -1,16 +1,20 @@
 /**
  * Bash Completion Script Generator
  *
- * Phase 1: v0.5.0-alpha.0
+ * Completions are generated from the REAL registered command list passed by
+ * the caller — the alpha-era hardcoded set (`ask plan orchestrate …`) shipped
+ * completions for commands that never existed (caught by the 2026-06-07
+ * v1-readiness audit, Lane C).
  */
-export function generateBashCompletion() {
+export function generateBashCompletion(commands) {
+    const opts = commands.map((c) => c.name).join(' ');
     return `# Codehere bash completion
 _complete_codehere() {
   local cur prev opts
   COMPREPLY=()
   cur="\${COMP_WORDS[COMP_CWORD]}"
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  opts="ask plan orchestrate fix suggest run review status help version"
+  opts="${opts}"
 
   if [[ \${cur} == -* ]]; then
     COMPREPLY=($(compgen -W "--help --version" -- \${cur}))

package/dist/infrastructure/completion/fish-completion.js

@@ -1,22 +1,17 @@
 /**
  * Fish Completion Script Generator
  *
- * Phase 1: v0.5.0-alpha.0
+ * Completions are generated from the REAL registered command list passed by
+ * the caller (see bash-completion.ts header for the audit history).
  */
-export function generateFishCompletion() {
+export function generateFishCompletion(commands) {
+    const lines = commands
+        .map((c) => `complete -c codehere -n __fish_use_subcommand -a ${c.name} -d "${c.description.replace(/"/g, '')}"`)
+        .join('\n');
     return `# Codehere fish completion
 complete -c codehere -f
 
-complete -c codehere -n __fish_use_subcommand -a ask -d "Answer questions about codebase"
-complete -c codehere -n __fish_use_subcommand -a plan -d "Generate execution plan"
-complete -c codehere -n __fish_use_subcommand -a orchestrate -d "Multi-agent orchestration"
-complete -c codehere -n __fish_use_subcommand -a fix -d "Apply AI edits to file"
-complete -c codehere -n __fish_use_subcommand -a suggest -d "Read-only assistant mode"
-complete -c codehere -n __fish_use_subcommand -a run -d "Unified agentic execution"
-complete -c codehere -n __fish_use_subcommand -a review -d "Task review interface"
-complete -c codehere -n __fish_use_subcommand -a status -d "Show agent status"
-complete -c codehere -n __fish_use_subcommand -a help -d "Show help"
-complete -c codehere -n __fish_use_subcommand -a version -d "Show version"
+${lines}
 `;
 }
 //# sourceMappingURL=fish-completion.js.map

package/dist/infrastructure/completion/zsh-completion.js

@@ -1,24 +1,19 @@
 /**
  * Zsh Completion Script Generator
  *
- * Phase 1: v0.5.0-alpha.0
+ * Completions are generated from the REAL registered command list passed by
+ * the caller (see bash-completion.ts header for the audit history).
  */
-export function generateZshCompletion() {
+export function generateZshCompletion(commands) {
+    // zsh _describe entries are 'name:description' — strip colons/quotes from
+    // descriptions so they can't break the entry syntax.
+    const entries = commands.map((c) => `    '${c.name}:${c.description.replace(/['":]/g, '')}'`).join('\n');
     return `#compdef codehere
 
 _codehere() {
   local -a commands
   commands=(
-    'ask:Answer questions about codebase'
-    'plan:Generate execution plan'
-    'orchestrate:Multi-agent orchestration'
-    'fix:Apply AI edits to file'
-    'suggest:Read-only assistant mode'
-    'run:Unified agentic execution'
-    'review:Task review interface'
-    'status:Show agent status'
-    'help:Show help'
-    'version:Show version'
+${entries}
   )
 
   _describe 'codehere' commands

package/dist/infrastructure/config/config-manager.js

@@ -1,14 +1,15 @@
+import { writeFileAtomic } from '../storage/atomic-write.js';
 /**
  * Configuration Manager
  * Manages user preferences and settings for Codehere
  * Stores configuration in data/config.json
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { getVersion } from '../../utils/version.js';
 function detectDefaultProvider() {
     if (process.env.ANTHROPIC_API_KEY)
-        return { provider: 'anthropic', model: 'claude-sonnet-4-20250514' };
+        return { provider: 'anthropic', model: 'claude-fable-5' };
     if (process.env.OPENAI_API_KEY)
         return { provider: 'openai', model: 'gpt-4o-mini' };
     if (process.env.COHERE_API_KEY)
@@ -100,7 +101,7 @@ export class ConfigManager {
             if (!existsSync(dataDir)) {
                 mkdirSync(dataDir, { recursive: true });
             }
-            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+            writeFileAtomic(this.configPath, JSON.stringify(this.config, null, 2));
         }
         catch (error) {
             throw new Error(`Failed to save config to ${this.configPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });

package/dist/infrastructure/config/product-context.js

@@ -7,7 +7,7 @@
  *
  * Stored in: .codehere/product.json (per-project, gitignore-friendly)
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 const CONFIG_DIR = '.codehere';
 const CONFIG_FILE = 'product.json';
@@ -25,24 +25,6 @@ export function loadProductContext(cwd = process.cwd()) {
         return null;
     }
 }
-export function saveProductContext(ctx, cwd = process.cwd()) {
-    const dir = join(cwd, CONFIG_DIR);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    writeFileSync(getConfigPath(cwd), JSON.stringify(ctx, null, 2) + '\n');
-}
-/**
- * Returns a plain-English risk label for use in recommendations.
- */
-export function riskLabel(level) {
-    return level === 'critical'
-        ? 'critical-risk'
-        : level === 'high'
-            ? 'high-risk'
-            : level === 'medium'
-                ? 'production'
-                : 'low-risk';
-}
 /**
  * Adjusts a trust recommendation based on product context.
  * If no context is available, returns the base recommendation unchanged.