codehere 0.3.0-rc.12 → 0.3.0-rc.27

package/dist/domain/services/codebase-detector.js

@@ -9,7 +9,7 @@ import { join, dirname, resolve } from 'path';
  */
 export function findCodebaseRoot(startPath = process.cwd()) {
     const resolvedStart = resolve(startPath);
-    let currentDir = resolvedStart;
+    const currentDir = resolvedStart;
     // Try to find git root first
     const gitRoot = findGitRoot(currentDir);
     if (gitRoot) {

package/dist/index.js

@@ -37,12 +37,19 @@ catch {
 }
 config();
 import { getVersion } from './utils/version.js';
+import { checkTypo } 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, get a plain-English report with a trust score on every file.')
     .version(getVersion())
-    .configureHelp({ helpWidth: 80, sortSubcommands: true });
+    .configureHelp({ helpWidth: 80, sortSubcommands: true })
+    // rc.18: many users hit `codehere --help` first and get Commander's flat
+    // list. The grouped `codehere help` is more useful for discovery. Surface
+    // it inline so muscle-memory `--help` users find the better page.
+    // (Pin: no raw ANSI in --help output — existing commands.test.ts asserts
+    // this, see test/cli/commands.test.ts "no raw ANSI escape codes in --help".)
+    .addHelpText('after', '\nTip: `codehere help` shows commands grouped by use case (Delegate · Safety & Trust · Configuration).');
 // Default action · show welcome, then drop into the interactive REPL on TTY.
 // codehere offers TWO surfaces, both first-class: the CLI REPL (here) and the
 // web UI (`codehere start`). Users pick whichever fits their workflow.
@@ -52,8 +59,23 @@ program
     // One-shot delegate: `codehere "review src/auth.ts"` runs that task and exits.
     // Useful for scripting or quick one-offs without entering the REPL.
     if (query && query.trim()) {
+        const trimmed = query.trim();
+        // Typo guard — see src/utils/typo-guard.ts for heuristics.
+        // Returns suggestions when input looks like a typo; null falls through.
+        const known = program.commands.map((c) => c.name());
+        const suggestions = checkTypo(trimmed, known);
+        if (suggestions) {
+            console.error(`codehere: unknown command '${trimmed}'.`);
+            console.error('');
+            console.error('  Did you mean:');
+            for (const s of suggestions)
+                console.error(`    codehere ${s}`);
+            console.error('');
+            console.error(`  If you meant to ask a question, quote it: codehere "${trimmed}"`);
+            process.exit(1);
+        }
         const { runOneShot } = await import('./presentation/cli/repl.js');
-        await runOneShot(query.trim());
+        await runOneShot(trimmed);
         return;
     }
     if (!process.stdin.isTTY) {
@@ -103,8 +125,23 @@ program
     .command('health')
     .description('Check system health and metrics')
     .option('-m, --metrics', 'Show detailed metrics')
+    .option('--json', 'Machine-readable JSON (for monitoring/CI)')
     .action((options) => {
     const health = performHealthCheck();
+    if (options.json) {
+        // Machine-readable: status + checks (+ metrics when --metrics).
+        // Stdout is the contract — never mix with the human banner.
+        // Use process.exitCode (not process.exit) so a piped consumer sees the
+        // full JSON before the process tears down (rc.16: Codex flagged the old
+        // process.exit call as a truncation hazard under stdout redirection).
+        const payload = { status: health.status, checks: health.checks };
+        if (options.metrics)
+            payload.metrics = getMetrics();
+        console.log(JSON.stringify(payload, null, 2));
+        if (health.status === 'unhealthy')
+            process.exitCode = 1;
+        return;
+    }
     if (isMinimalStyle()) {
         printMinimalHeader('health', '');
     }
@@ -202,9 +239,9 @@ program
     .command('report')
     .description('Generate a shareable security audit report — narrative, not just a score')
     .argument('[target]', 'File or directory to audit (default: current directory)')
-    .option('--out <file>', 'Write report to a specific file (default: codehere-audit.md)')
-    .option('--stdout', 'Print the report to stdout instead of writing a file')
-    .option('--json', 'Output machine-readable JSON instead of markdown')
+    .option('--out <file>', 'Write report to a specific file (default: codehere-audit.md for markdown)')
+    .option('--stdout', 'Print the report to stdout (already the default for --json)')
+    .option('--json', 'Output machine-readable JSON to stdout (pipe to jq, etc.)')
     .option('--simple', 'Plain English output — no jargon, for non-technical stakeholders')
     .addHelpText('after', `
 Examples:

package/dist/infrastructure/hooks/session-analyzer.js

@@ -76,17 +76,26 @@ export function detectAmplificationAlerts(sessions) {
             continue;
         let message = '';
         const risk = session.amplificationRisk;
-        if (session.blockedCalls > 0 && session.totalCalls > 20) {
-            message = `${session.totalCalls} tool calls with ${session.blockedCalls} blocked — possible injection in multi-agent chain`;
+        // rc.17 framing: don't accuse "injection" by default — that wording scares
+        // users on perfectly normal long attended sessions. Reserve the strong
+        // language for cases where the *blocked-call ratio* is high (real signal
+        // of prompts trying things they shouldn't), not just call volume.
+        // UX_OBSERVATIONS.md P1.
+        const blockRatio = session.totalCalls > 0 ? session.blockedCalls / session.totalCalls : 0;
+        if (session.blockedCalls > 0 && session.totalCalls > 20 && blockRatio > 0.05) {
+            message = `${session.totalCalls} tool calls, ${session.blockedCalls} blocked (${(blockRatio * 100).toFixed(0)}%) — high block ratio, review for injection`;
+        }
+        else if (session.blockedCalls > 0 && session.totalCalls > 20) {
+            message = `${session.totalCalls} tool calls, ${session.blockedCalls} blocked — long session, review if unattended`;
         }
         else if (session.totalCalls > 50) {
-            message = `${session.totalCalls} tool calls in one session — check for amplification`;
+            message = `${session.totalCalls} tool calls in one session — high density, review if unattended`;
         }
         else if ((session.toolMix['Bash'] ?? 0) > 10) {
-            message = `${session.toolMix['Bash']} Bash calls in one session — elevated risk`;
+            message = `${session.toolMix['Bash']} Bash calls in one session — elevated tool-mix`;
         }
         else {
-            message = `${session.totalCalls} calls, ${session.blockedCalls} blocked — worth reviewing`;
+            message = `${session.totalCalls} calls, ${session.blockedCalls} blocked — worth a glance`;
         }
         alerts.push({
             sessionId: session.sessionId,

package/dist/infrastructure/orchestration/conductor-adapter.js

@@ -91,7 +91,12 @@ function tokenize(prompt) {
     //   "add tests"  "add-tests"  "add_tests"  "add/tests"  "add:tests"  "add.tests"
     // Note: must NOT collapse the leading/trailing spaces — they're load-bearing
     // for the boundary check below (`.includes(' ' + t + ' ')`).
-    const normalized = ' ' + prompt.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim() + ' ';
+    const normalized = ' ' +
+        prompt
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, ' ')
+            .trim() +
+        ' ';
     return { tokens, normalized };
 }
 /**
@@ -240,7 +245,6 @@ function spawnConductor(prompt, options, lookup) {
             },
         };
         buffer.push(errEvent);
-        queueMicrotask(() => emitter.emit('event', errEvent));
         return synthesizeSession({ sessionId, startedAt, prompt, statusValue, emitter, buffer });
     }
     // Emit the routing-decision event FIRST so the audit log records WHY this
@@ -255,8 +259,11 @@ function spawnConductor(prompt, options, lookup) {
             promptExcerpt: prompt.slice(0, 200),
         },
     };
+    // Buffer replay on subscribe() handles delivery to the first subscriber. Do
+    // NOT also queueMicrotask(emit) — the microtask fires AFTER subscribe attaches
+    // its handler, so the handler would receive routingEvent twice (rc.13 bug:
+    // duplicate "routing → ..." line in the REPL).
     buffer.push(routingEvent);
-    queueMicrotask(() => emitter.emit('event', routingEvent));
     // Find the chosen specialist adapter and spawn against it.
     const specialist = lookup().find((a) => a.id === decision.agentId);
     if (!specialist) {
@@ -269,7 +276,6 @@ function spawnConductor(prompt, options, lookup) {
             data: { message: `Conductor picked '${decision.agentId}' but no adapter with that ID is registered.` },
         };
         buffer.push(errEvent);
-        queueMicrotask(() => emitter.emit('event', errEvent));
         return synthesizeSession({ sessionId, startedAt, prompt, statusValue, emitter, buffer });
     }
     // Spawn the specialist session and proxy every event through.
@@ -284,7 +290,12 @@ function spawnConductor(prompt, options, lookup) {
             stepsSnapshot = specialistSession.steps;
         if (specialistSession.artifacts)
             artifactsSnapshot = specialistSession.artifacts;
-        if (evt.type === 'codehere:complete' || evt.type === 'codehere:error') {
+        // Specialist adapters terminate with an 'exit' event — never emit
+        // 'codehere:complete' / 'codehere:error'. Without mirroring on 'exit',
+        // session.status stayed 'running' forever and the REPL printed
+        // "✗ └─ running" (rc.13 bug). Also keep the legacy types for safety in
+        // case a future adapter emits them.
+        if (evt.type === 'exit' || evt.type === 'codehere:complete' || evt.type === 'codehere:error') {
             statusValue = specialistSession.status;
         }
     });

package/dist/infrastructure/orchestration/generic-cli-adapter.js

@@ -478,7 +478,6 @@ export function compileSafePattern(source, fallback, agentId) {
     // Layer 1 · static shape check — this is the only fully reliable defense.
     const danger = detectRedosShape(source);
     if (danger) {
-        // eslint-disable-next-line no-console
         console.warn(`[codehere] Regex for "${agentId}" rejected (${danger}) — using fallback`);
         return fallback;
     }
@@ -487,7 +486,6 @@ export function compileSafePattern(source, fallback, agentId) {
         candidate = new RegExp(source);
     }
     catch {
-        // eslint-disable-next-line no-console
         console.warn(`[codehere] Invalid regex in agents.yaml for "${agentId}" — using fallback`);
         return fallback;
     }
@@ -496,7 +494,6 @@ export function compileSafePattern(source, fallback, agentId) {
         const start = Date.now();
         candidate.test('a'.repeat(1000));
         if (Date.now() - start > 100) {
-            // eslint-disable-next-line no-console
             console.warn(`[codehere] Regex for "${agentId}" too slow (likely ReDoS) — using fallback`);
             return fallback;
         }

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -20,7 +20,8 @@
  */
 import http from 'http';
 import { readFileSync, existsSync, statSync, watchFile, unwatchFile } from 'fs';
-import { join, relative } from 'path';
+import { join, relative, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
 import { scanPayload, calculateRiskScore, AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
 import { getVersion } from '../../utils/version.js';
@@ -589,8 +590,14 @@ export function startMCPServer(options = {}) {
             res.end(JSON.stringify({ error: 'Method not allowed for this path' }));
             return;
         }
-        // MCP endpoint
-        if (req.method === 'POST' && req.url === '/mcp') {
+        // MCP endpoint — POST jsonrpc; reject other verbs with 405 + Allow header
+        // (rc.17: was 404, which is wrong HTTP semantic — UX_OBSERVATIONS P3).
+        if (req.url === '/mcp') {
+            if (req.method !== 'POST') {
+                res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'POST' });
+                res.end(JSON.stringify({ error: 'MCP endpoint accepts POST only', method: req.method }));
+                return;
+            }
             let body = '';
             req.on('data', (chunk) => {
                 body += chunk;
@@ -612,6 +619,29 @@ export function startMCPServer(options = {}) {
             });
             return;
         }
+        // /api/version — small completeness item for ops monitoring (rc.17).
+        // ESM-friendly: resolve package.json relative to the compiled module's
+        // own URL via fileURLToPath. Works in both src/ (during dev) and dist/
+        // because the relative path up to package.json is the same in both.
+        if (req.url === '/api/version' && req.method === 'GET') {
+            try {
+                const moduleDir = dirname(fileURLToPath(import.meta.url));
+                const pkgPath = join(moduleDir, '..', '..', '..', 'package.json');
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ version: pkg.version, name: pkg.name }));
+            }
+            catch (e) {
+                // rc.19: don't leak fs paths to the public HTTP surface.
+                // rc.20: but DO log the actual error context for the operator (Codex
+                // rc.19 review caught: previous version dropped `e` and logged only a
+                // static string, costing diagnosability).
+                console.error('[/api/version] failed to read package metadata:', e);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Failed to read package metadata' }));
+            }
+            return;
+        }
         // 404
         res.writeHead(404);
         res.end();

package/dist/infrastructure/security/file-collection.js

@@ -62,6 +62,9 @@ export const IGNORE_DIRS = new Set([
     '.cache',
     '.codehere',
     '.codehere-cache',
+    // Cloned reference repos used for dogfooding / comparison — not the user's code.
+    // Codehere convention; mirrors how `.git` is hidden tooling-data, not source.
+    '.oss-repos',
     // Test fixtures / mocks (intentionally-vulnerable code used as scanner inputs)
     'fixtures',
     'test-fixtures',

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

@@ -237,14 +237,61 @@ function generateSimpleReport(report, target) {
     lines.push('Generated by codehere — know what your AI agent did before your tech lead asks.');
     return lines.join('\n');
 }
+/**
+ * Write report to the requested path. If the path is unwritable (EROFS,
+ * EACCES, EPERM, ENOENT on a parent dir we can't create), fall back to
+ * stdout so the user still gets the report instead of a stack trace.
+ *
+ * Returns true if the file was written, false if we fell back to stdout.
+ *
+ * Provoked by rc.25 UAT: `codehere report --simple` from `/` crashed with
+ * `EROFS: read-only file system, open 'codehere-audit.md'`. A user running
+ * the command from any unwritable cwd should still get their report.
+ */
+function writeReportWithFallback(targetPath, content, label) {
+    try {
+        writeFileSync(targetPath, content);
+        console.log(success(`${label} written to ${targetPath}`));
+        return true;
+    }
+    catch (e) {
+        const code = e.code ?? '';
+        if (['EROFS', 'EACCES', 'EPERM', 'ENOENT'].includes(code)) {
+            console.error(error(`Could not write to ${targetPath} (${code}). Printing to stdout instead — pass --out <path> to a writable location.`));
+            process.stdout.write(content + '\n');
+            return false;
+        }
+        throw e;
+    }
+}
 export async function executeReportCommand(target, options = {}) {
     const cwd = process.cwd();
     const resolved = target ? (isAbsolute(target) ? target : join(cwd, target)) : cwd;
-    // Default: write to a file so the user gets a shareable artifact instead of
-    // raw markdown sprayed at the terminal. --stdout opts into the old behavior
-    // for piping; --out overrides the default path.
-    const defaultOutName = options.json ? 'codehere-audit.json' : 'codehere-audit.md';
-    const effectiveOut = options.stdout ? undefined : (options.out ?? defaultOutName);
+    // rc.18: explicit mutex on combinations Codex flagged as silently
+    // ambiguous. Two pairs:
+    //   format    {--json, --simple} — pick at most one output format
+    //   dest      {--stdout, --out}   — pick at most one destination
+    // Previously the second flag silently lost; now we error so users know.
+    if (options.json && options.simple) {
+        console.error(error('--json and --simple cannot be used together. Pick one output format.'));
+        process.exit(2);
+    }
+    if (options.stdout && options.out) {
+        console.error(error('--stdout and --out cannot be used together. Pick one destination.'));
+        process.exit(2);
+    }
+    // Default routing rules (after mutex check):
+    //   --json            → stdout (pipeable to jq, every CLI convention).
+    //   --simple / md     → file (user expects a shareable artifact, not a wall of markdown).
+    //   --out <path>      → wins over the default (explicit beats default).
+    //   --stdout          → forces stdout for non-json formats.
+    // Rationale: rc.15 — `report --json` writing to disk silently broke pipelines
+    // (`codehere report --json | jq` produced empty stdout). Stdout for machine-
+    // readable formats matches `kubectl get -o json`, `docker inspect`, etc.
+    const defaultOut = options.json
+        ? undefined // stdout
+        : 'codehere-audit.md';
+    const effectiveOut = options.stdout ? undefined : (options.out ?? defaultOut);
     if (!existsSync(resolved)) {
         console.error(error(`Not found: ${resolved}`));
         process.exit(1);
@@ -297,8 +344,7 @@ export async function executeReportCommand(target, options = {}) {
     if (options.json) {
         const output = JSON.stringify(report, null, 2);
         if (effectiveOut) {
-            writeFileSync(effectiveOut, output);
-            console.log(success(`Report written to ${effectiveOut}`));
+            writeReportWithFallback(effectiveOut, output, 'Report');
         }
         else {
             console.log(output);
@@ -309,8 +355,7 @@ export async function executeReportCommand(target, options = {}) {
     if (options.simple) {
         const simple = generateSimpleReport(report, resolved);
         if (effectiveOut) {
-            writeFileSync(effectiveOut, simple);
-            console.log(success(`Plain-English report written to ${effectiveOut}`));
+            writeReportWithFallback(effectiveOut, simple, 'Plain-English report');
         }
         else {
             process.stdout.write(simple + '\n');
@@ -320,9 +365,9 @@ export async function executeReportCommand(target, options = {}) {
     // Markdown output
     const markdown = generateMarkdown(report, resolved, cwd);
     if (effectiveOut) {
-        writeFileSync(effectiveOut, markdown);
+        if (!writeReportWithFallback(effectiveOut, markdown, 'Report'))
+            return;
         newline();
-        console.log(success(`Report written to ${effectiveOut}`));
         console.log(colors.dim(`  ${paths.length} files · score ${overallScore}/100 · grade ${grade}`));
         if (criticalCount > 0) {
             console.log(colors.red(`  ${criticalCount} critical issue${criticalCount !== 1 ? 's' : ''} — check the report`));

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

@@ -148,9 +148,14 @@ function renderSessionDrillDown(sessionId, entries) {
         console.log(`  ${icon}  ${time}  ${tool}  ${colors.dim(reason)}`);
     }
     newline();
-    // Verdict
-    if (blocked.length > 2 && sorted.length > 20) {
-        console.log(colors.red('  ⚠ High block rate in a long session — possible prompt injection in multi-agent chain.'));
+    // Verdict — rc.17: tighten "injection" claim to actual high block ratio
+    // (UX_OBSERVATIONS.md P1; long attended sessions shouldn't get accused).
+    if (blocked.length > 2 && sorted.length > 20 && blocked.length / sorted.length > 0.05) {
+        const pct = ((blocked.length / sorted.length) * 100).toFixed(0);
+        console.log(colors.red(`  ⚠ ${pct}% block rate (${blocked.length}/${sorted.length}) — review for injection patterns.`));
+    }
+    else if (blocked.length > 0 && sorted.length > 20) {
+        console.log(colors.yellow(`  ${blocked.length} blocked / ${sorted.length} total — long session, review if unattended.`));
     }
     else if (blocked.length > 0) {
         console.log(colors.yellow(`  ${blocked.length} blocked call${blocked.length !== 1 ? 's' : ''} — review the blocked entries above.`));
@@ -413,6 +418,13 @@ export async function executeStatusCommand(options = {}) {
     const cwd = process.cwd();
     const version = getVersion();
     const entries = readAuditLog();
+    // Validate --since up front — applies to ALL modes, not just --export.
+    // (rc.15 fix: previously the validation ran only inside the --export branch,
+    // so `codehere status --since bogus` silently succeeded with exit 0.)
+    if (options.since && parseDurationToHours(options.since) == null) {
+        console.error(`Invalid --since value: "${options.since}". Use e.g. 24h, 7d, 4w.`);
+        process.exit(1);
+    }
     // Session drill-down mode
     if (options.session) {
         renderSessionDrillDown(options.session, entries);
@@ -421,10 +433,6 @@ export async function executeStatusCommand(options = {}) {
     // Audit export mode — dump raw events for archival/compliance/sharing
     if (options.export) {
         const sinceHours = options.since ? parseDurationToHours(options.since) : null;
-        if (options.since && sinceHours == null) {
-            console.error(`Invalid --since value: "${options.since}". Use e.g. 24h, 7d, 4w.`);
-            process.exit(1);
-        }
         try {
             exportAudit(entries, options.export, sinceHours);
         }
@@ -480,9 +488,17 @@ export async function executeStatusCommand(options = {}) {
                 }));
                 result.taskCount = tasks.length;
             }
-            catch {
+            catch (e) {
+                // rc.25: JSON consumers reading only stdout were still being fed a
+                // lie ([] tasks, 0 count) on real failure (Codex final review:
+                // "degraded behavior being presented as success"). Now we surface a
+                // structured taskLoadError + status:'degraded' so automation can
+                // distinguish "no tasks" from "load failed."
+                console.error('[status --tasks --json] task repository failed to load:', e);
                 result.tasks = [];
                 result.taskCount = 0;
+                result.taskLoadError = e instanceof Error ? e.message : String(e);
+                result.status = 'degraded';
             }
         }
         console.log(JSON.stringify(result, null, 2));
@@ -630,8 +646,14 @@ export async function executeStatusCommand(options = {}) {
                 }
             }
         }
-        catch {
-            console.log(colors.dim('No tasks found. Run "codehere start" to open the task intake, or "codehere task <prompt>" from the CLI.'));
+        catch (e) {
+            // rc.25: don't print "No tasks found" — that's a lie when load failed
+            // (Codex final review: "degraded behavior presented as success"). Show
+            // a clear error line; stderr already has the cause for the operator.
+            console.error('[status] task repository failed to load:', e);
+            const msg = e instanceof Error ? e.message : String(e);
+            console.log(colors.red(`  ✗ Could not load task repository: ${msg}`));
+            console.log(colors.dim('  See logs above for details. Try `codehere start` to (re)init the task intake.'));
         }
     }
     // Quick trust scan (opt-in)

package/dist/presentation/cli/repl.js

@@ -22,9 +22,10 @@ import { join, basename } from 'path';
 import { spawn as childSpawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import { colors, success, error, warning, newline, createCodehereLogo, } from '../../ui.js';
+import { colors, success, error, warning, newline, createCodehereLogo } from '../../ui.js';
 import { getVersion } from '../../utils/version.js';
 import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+import { collectCodeFiles } from '../../infrastructure/security/file-collection.js';
 import chalk from 'chalk';
 const brandBlue = chalk.rgb(74, 144, 226);
 const stdin = process.stdin;
@@ -86,13 +87,55 @@ const SLASH_COMMANDS = [
         promptTemplate: (a) => `refactor: ${a}`,
     },
     // Subcommands · run an existing CLI subcommand inline
-    { name: 'trust', args: '[path]', description: 'Scan for vulnerabilities', kind: 'sub', noKey: true, subcommand: 'trust' },
-    { name: 'report', args: '[path]', description: 'Security audit report', kind: 'sub', noKey: true, subcommand: 'report' },
-    { name: 'hook', args: '[install|status]', description: 'Safety hook management', kind: 'sub', noKey: true, subcommand: 'hook' },
-    { name: 'status', args: '', description: 'Dashboard — hook activity', kind: 'sub', noKey: true, subcommand: 'status' },
+    {
+        name: 'trust',
+        args: '[path]',
+        description: 'Scan for vulnerabilities',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'trust',
+    },
+    {
+        name: 'report',
+        args: '[path]',
+        description: 'Security audit report',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'report',
+    },
+    {
+        name: 'hook',
+        args: '[install|status]',
+        description: 'Safety hook management',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'hook',
+    },
+    {
+        name: 'status',
+        args: '',
+        description: 'Dashboard — hook activity',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'status',
+    },
     { name: 'health', args: '', description: 'System health check', kind: 'sub', noKey: true, subcommand: 'health' },
-    { name: 'setup', args: '', description: 'Configure first-run preferences', kind: 'sub', noKey: true, subcommand: 'setup' },
-    { name: 'config', args: '[key] [value]', description: 'Manage preferences', kind: 'sub', noKey: true, subcommand: 'config' },
+    {
+        name: 'setup',
+        args: '',
+        description: 'Configure first-run preferences',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'setup',
+    },
+    {
+        name: 'config',
+        args: '[key] [value]',
+        description: 'Manage preferences',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'config',
+    },
     { name: 'agents', args: '', description: 'List installed specialists', kind: 'session', noKey: true },
     { name: 'undo', args: '<file>', description: 'Undo file changes (queued for v0.5)', kind: 'session', noKey: true },
     { name: 'history', args: '', description: 'Show command history', kind: 'session', noKey: true },
@@ -126,6 +169,7 @@ function detectState() {
     const hasAnyAgent = availableAgents().some((a) => a.installed && a.id !== 'conductor');
     const isGitRepo = existsSync(join(cwd, '.git'));
     let fileCount = 0;
+    let scannableCount = 0;
     try {
         const count = (dir, d) => {
             if (d > 3)
@@ -142,33 +186,79 @@ function detectState() {
             return n;
         };
         fileCount = count(cwd, 0);
+        // rc.21: surface the scannable count — code files that trust/scan
+        // would actually look at. Honest count beats a single inflated number.
+        // UX_OBSERVATIONS P3. Static ESM import (rc.20 used `require()` which is
+        // undefined in this package's ESM runtime — Codex caught the silent fail).
+        try {
+            scannableCount = collectCodeFiles(cwd).length;
+        }
+        catch {
+            /* ignore — banner stays silent rather than crashes */
+        }
     }
     catch {
         /* ignore */
     }
-    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount };
+    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount, scannableCount };
 }
-function printWelcome() {
-    const state = detectState();
+/**
+ * Format the banner's "X files (Y scannable)" line.
+ *
+ * Pure function (no I/O) so the rc.20 silent-fail regression that Codex
+ * caught — banner falling back to total-only when scannable load fails —
+ * has a tight unit test.
+ *
+ * Contract:
+ *   - scannable > 0 AND scannable < total → "<total> files (<scannable> scannable)"
+ *   - otherwise                            → "<total> files"
+ *
+ * Exported for test/cli/rc15-fixes.test.ts banner integration test.
+ */
+export function formatFileLine(total, scannable) {
+    if (scannable > 0 && scannable < total) {
+        return `${total} files (${scannable} scannable)`;
+    }
+    return `${total} files`;
+}
+export function buildWelcomeLines(state, version) {
     const logo = createCodehereLogo();
-    const ver = colors.dim(`v${getVersion()}`);
-    console.log();
-    console.log(`  ${logo} ${ver}`);
-    console.log();
+    const ver = colors.dim(`v${version}`);
     const badges = [
         state.hasHooks ? colors.green('● hooks') : colors.dim('○ hooks'),
         state.hasAgents ? colors.green('● agents') : colors.dim('○ agents'),
     ];
-    console.log('  ' + badges.join('  '));
-    console.log();
-    console.log(colors.dim(`  ${state.name}`) + colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${state.fileCount} files`));
-    console.log();
-    if (!state.hasHooks)
-        console.log('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
-    else if (!state.hasAgents)
-        console.log('  ' + colors.yellow('→') + ' Install ' + colors.cyan('claude-code') + colors.dim(' / ') + colors.cyan('codex') + colors.dim(' / aider / opencode to delegate tasks'));
-    console.log(colors.dim('  Type / for commands, or ask anything'));
-    console.log();
+    const lines = [
+        '',
+        `  ${logo} ${ver}`,
+        '',
+        '  ' + badges.join('  '),
+        '',
+        colors.dim(`  ${state.name}`) +
+            colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${formatFileLine(state.fileCount, state.scannableCount)}`),
+        '',
+    ];
+    if (!state.hasHooks) {
+        lines.push('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+    }
+    else if (!state.hasAgents) {
+        lines.push('  ' +
+            colors.yellow('→') +
+            ' Install ' +
+            colors.cyan('claude-code') +
+            colors.dim(' / ') +
+            colors.cyan('codex') +
+            colors.dim(' / aider / opencode to delegate tasks'));
+    }
+    lines.push(colors.dim('  Type / for commands, or ask anything'));
+    lines.push('');
+    return lines;
+}
+function printWelcome() {
+    const state = detectState();
+    for (const line of buildWelcomeLines(state, getVersion())) {
+        console.log(line);
+    }
 }
 // ── Main session ─────────────────────────────────────────────────────────
 export async function runInteractiveRepl() {
@@ -188,6 +278,7 @@ export async function runInteractiveRepl() {
     let escTimer = null;
     const cols = () => stdout.columns || 80;
     function truncate(s, maxWidth) {
+        // eslint-disable-next-line no-control-regex -- ANSI escape stripping requires the literal ESC byte
         const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
         if (visible.length <= maxWidth)
             return s;

package/dist/ui.js

@@ -326,9 +326,6 @@ export function createSessionWelcome() {
         const padding = Math.max(0, width - contentVisual - 4);
         return borderColor('│ ') + content + ' '.repeat(padding) + borderColor(' │\n');
     };
-    // Calculate visual lengths (without ANSI codes)
-    const logoVisual = visualLength(logo);
-    const versionVisual = visualLength(version);
     let welcomeBox = '';
     welcomeBox += borderColor('┌' + '─'.repeat(width - 2) + '┐\n');
     // Header line with logo and version

package/dist/utils/typo-guard.js

@@ -0,0 +1,73 @@
+/**
+ * Typo guard for the bare `codehere <word>` action.
+ *
+ * Why this exists: codehere's bare action treats any string as a one-shot task
+ * prompt for the Conductor. Without a guard, a typo like `codehere helpp`
+ * silently spawns a Claude task to interpret "helpp" as a question, burning
+ * API tokens for what was clearly meant to be `codehere help`.
+ *
+ * Earlier rc.15 attempt (greedy edit-check + prefix match) over-matched and
+ * blocked legitimate single-word prompts like "task-runner" or "h". Codex
+ * caught the regression in review. This rc.16 version uses real Levenshtein,
+ * a length floor, and explicit kebab-case exemption.
+ */
+/** Standard Levenshtein distance. Bounded inputs only — no allocation guard. */
+export function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = new Array(n + 1);
+    for (let j = 0; j <= n; j++)
+        dp[j] = j;
+    for (let i = 1; i <= m; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const tmp = dp[j];
+            dp[j] = a[i - 1] === b[j - 1] ? prev : Math.min(prev, dp[j], dp[j - 1]) + 1;
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * Decide whether a bare-action input should be treated as a typo of a known
+ * subcommand. Returns the suggestions if it should block; null if it should
+ * fall through to the task spawner.
+ *
+ * Heuristics (intentionally narrow — false positives are worse than false negatives):
+ *   - Single token (no whitespace), 4–14 chars (excludes "h", "go", etc.)
+ *   - Pure alphabetic, no hyphens (kebab-case is a likely real prompt)
+ *   - True Levenshtein distance ≤ 2 to a known command
+ *   - Distance must be < input length (avoid 2-char words matching anything)
+ *   - Returns up to 3 closest commands ranked by ascending distance
+ */
+export function checkTypo(input, knownCommands) {
+    if (/\s/.test(input))
+        return null;
+    if (input.length < 4 || input.length > 14)
+        return null;
+    if (!/^[a-z]+$/i.test(input))
+        return null;
+    const lower = input.toLowerCase();
+    // Defensively normalize knownCommands to lowercase too — Codex rc.16 review
+    // flagged this for symmetry. Currently every Commander subcommand is lower
+    // already, but a future addition that registers an uppercase name shouldn't
+    // silently slip through the equality check.
+    const knownLower = knownCommands.map((n) => n.toLowerCase());
+    if (knownLower.includes(lower))
+        return null;
+    // Length-prefilter cheap reject before computing DP — same outcome, less work.
+    const scored = knownLower
+        .filter((n) => Math.abs(n.length - lower.length) <= 2)
+        .map((n) => ({ n, d: levenshtein(lower, n) }))
+        .filter((s) => s.d > 0 && s.d <= 2 && s.d < lower.length)
+        // Deterministic tie-breaker (alphabetical) so ranking is stable across runs.
+        .sort((a, b) => (a.d - b.d) || a.n.localeCompare(b.n))
+        .slice(0, 3);
+    return scored.length > 0 ? scored.map((s) => s.n) : null;
+}
+//# sourceMappingURL=typo-guard.js.map

package/dist/utils/version.js

@@ -29,7 +29,7 @@ export function getVersion() {
             return version;
         }
     }
-    catch (error) {
+    catch {
         // Fallback if can't read package.json
         console.warn('Warning: Could not read version from package.json, using fallback');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.12",
+  "version": "0.3.0-rc.27",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",