codehere 0.3.0-rc.1 → 0.3.0-rc.10

package/dist/index.js

@@ -14,7 +14,6 @@ import { Command } from 'commander';
 import { config } from 'dotenv';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync, readFileSync } from 'fs';
 import { executeSetupCommand } from './presentation/cli/commands/setup-command.js';
 import { executeConfigCommand } from './presentation/cli/commands/config-command.js';
 import { executeHelpCommand } from './presentation/cli/commands/help-command.js';
@@ -44,54 +43,25 @@ program
     .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 });
-// Default action · show welcome + quick start (no REPL; v0.3 is web-UI-first)
+// 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.
 program
-    .argument('[query]', 'Reserved — the PM intake lives at http://127.0.0.1:3773 after you run `codehere start`')
+    .argument('[query]', 'Optional initial task to delegate (otherwise enter interactive REPL)')
     .action(async (query) => {
+    // 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()) {
-        console.error(error('Direct-query routing was removed in v0.3 (D7 trim).'));
-        console.log(colors.dim('Use the PM intake instead:'));
-        console.log('  ' + colors.cyan('codehere start') + '          → web UI at http://127.0.0.1:3773');
-        console.log('  ' + colors.cyan(`codehere task "${query.trim().slice(0, 40)}..."`) + ' → spawn via CLI');
-        process.exit(1);
+        const { runOneShot } = await import('./presentation/cli/repl.js');
+        await runOneShot(query.trim());
+        return;
     }
     if (!process.stdin.isTTY) {
         console.log(createWelcomeMessage());
         return;
     }
-    const codehereDir = join(process.env.HOME || '', '.codehere');
-    const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json');
-    const hasHooks = existsSync(settingsPath) && readFileSync(settingsPath, 'utf-8').includes('codehere');
-    const hasAuditLog = existsSync(join(codehereDir, 'audit', 'hook-events.jsonl'));
-    console.log(createWelcomeMessage());
-    newline();
-    if (!hasHooks && !hasAuditLog) {
-        console.log(colors.bold("Welcome! Let's get you set up."));
-        newline();
-        console.log('  ' + colors.bold('Safety first — no API key, instant'));
-        console.log(colors.dim('  Every AI write gets scanned. Catches injections, hardcoded secrets,'));
-        console.log(colors.dim('  destructive ops, and more.'));
-        newline();
-        console.log('    → Run ' + colors.cyan('codehere hook install') + ' to activate safety');
-        console.log('    → Run ' + colors.cyan('codehere trust .') + ' to scan this project');
-        newline();
-        console.log('  ' + colors.bold('Delegate tasks — the PM for your AI coding agents'));
-        console.log(colors.dim('  Pick Claude Code, Codex, Aider, or OpenCode. codehere coordinates.'));
-        newline();
-        console.log('    → Run ' + colors.cyan('codehere start') + ' to open the task UI');
-        newline();
-    }
-    else {
-        console.log(colors.bold('Quick start:'));
-        newline();
-        console.log('  ' + colors.cyan('codehere start') + '            Task intake UI at http://127.0.0.1:3773');
-        console.log('  ' + colors.cyan('codehere status') + '           Dashboard · sessions · blocked calls');
-        console.log('  ' + colors.cyan('codehere report') + '           Generate a shareable audit report');
-        console.log('  ' + colors.cyan('codehere trust .') + '          Scan this project now');
-        newline();
-        console.log(colors.dim('  Run `codehere --help` for all commands.'));
-        newline();
-    }
+    const { runInteractiveRepl } = await import('./presentation/cli/repl.js');
+    await runInteractiveRepl();
 });
 // ── setup ────────────────────────────────────────────────────────────────────
 program
@@ -354,10 +324,30 @@ program
     const port = parseInt(options?.port ?? '3773', 10);
     const host = options?.host ?? '127.0.0.1';
     const shouldOpen = options?.open !== false;
+    const url = `http://${host}:${port}/`;
+    const openBrowser = async () => {
+        if (!shouldOpen)
+            return;
+        const { spawn } = await import('child_process');
+        const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        try {
+            spawn(opener, [url], { detached: true, stdio: 'ignore' }).unref();
+        }
+        catch {
+            /* browser open is best-effort */
+        }
+    };
     try {
         const { startMCPServer } = await import('./infrastructure/protocols/mcp-server-impl.js');
         const server = startMCPServer({ port, host });
-        const url = `http://${host}:${port}/`;
+        // 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
+        // sees a friendly message instead.
+        await new Promise((resolve, reject) => {
+            server.once('listening', () => resolve());
+            server.once('error', reject);
+        });
         newline();
         console.log(success('codehere is running'));
         newline();
@@ -367,16 +357,7 @@ program
         newline();
         console.log(colors.dim('  Press Ctrl+C to stop'));
         newline();
-        if (shouldOpen) {
-            const { spawn } = await import('child_process');
-            const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-            try {
-                spawn(opener, [url], { detached: true, stdio: 'ignore' }).unref();
-            }
-            catch {
-                /* browser open is best-effort */
-            }
-        }
+        await openBrowser();
         process.on('SIGINT', () => {
             server.close();
             console.log(colors.dim('\ncodehere stopped'));
@@ -387,6 +368,28 @@ program
         });
     }
     catch (err) {
+        const code = err?.code;
+        if (code === 'EADDRINUSE') {
+            // Port is taken. Probe to find out by what — if it's a running codehere,
+            // we should hand the user the existing URL; if it's something else,
+            // tell them to pick a different port.
+            const { isCodehereOnPort } = await import('./infrastructure/protocols/probe-port.js');
+            const existing = await isCodehereOnPort(host, port);
+            newline();
+            if (existing.isCodehere) {
+                console.log(success(`codehere is already running at ${url}`));
+                if (existing.version) {
+                    console.log(colors.dim(`  version: ${existing.version}`));
+                }
+                newline();
+                console.log(colors.dim('  Opening browser...'));
+                await openBrowser();
+                process.exit(0);
+            }
+            console.error(error(`Port ${port} is in use by another process.`));
+            console.error(colors.dim(`  Try: codehere start --port ${port + 1}`));
+            process.exit(1);
+        }
         console.error(error('Failed to start:'), err instanceof Error ? err.message : String(err));
         process.exit(1);
     }

package/dist/infrastructure/hooks/claude-sdk-hook.js

@@ -44,7 +44,7 @@ const PATTERNS = [
         description: 'Role hijacking attempt',
     },
     {
-        regex: /system\s*prompt|<\/?system>|(?<!['"\\])<\/?instruction>/i,
+        regex: /\bsystem\s+prompt\b|<\/?system>|(?<!['"\\])<\/?instruction>/i,
         severity: 'critical',
         category: 'Prompt Injection',
         description: 'System prompt injection',
@@ -56,7 +56,7 @@ const PATTERNS = [
         description: 'Instruction override attempt',
     },
     {
-        regex: /jailbreak|DAN\s+mode|developer\s+mode\s+enabled/i,
+        regex: /\bjailbreak\b|\bDAN\s+mode\b|\bdeveloper\s+mode\s+enabled\b/i,
         severity: 'critical',
         category: 'Prompt Injection',
         description: 'Jailbreak attempt',
@@ -93,7 +93,7 @@ const PATTERNS = [
         description: 'Exfiltrates env secrets',
     },
     {
-        regex: /printenv|env\s*\|\s*(grep|curl|wget|nc)\b/i,
+        regex: /\bprintenv\b|\benv\s*\|\s*(grep|curl|wget|nc)\b/i,
         severity: 'high',
         category: 'Credential Theft',
         description: 'Environment variable exfiltration',
@@ -119,7 +119,7 @@ const PATTERNS = [
         description: 'SSH key tooling access',
     },
     {
-        regex: /keychain|security\s+find-generic-password/i,
+        regex: /\bkeychain\b|\bsecurity\s+find-generic-password\b/i,
         severity: 'high',
         category: 'Credential Theft',
         description: 'macOS keychain access attempt',
@@ -417,10 +417,14 @@ export function appendAuditLog(entry) {
  *   not execution — strip the search term so pattern strings in args don't
  *   trigger the scanner.
  *
- * Write / Edit / MultiEdit: the content is data being written to disk,
- *   not executed. Only scan the file path (destination) and, for Edit,
- *   the old_string (what we're matching). Never scan new_string / content
- *   — that would block writing security documentation, test fixtures, etc.
+ * Write / Edit / MultiEdit: the content is DATA being written to disk, not
+ *   a command being executed. Only scan the file path (destination) — that's
+ *   enough to catch writes to sensitive files (~/.ssh/id_rsa, ~/.aws/credentials).
+ *   Do NOT scan content: it produces false positives on legitimate source code
+ *   that mentions attack-shaped strings (i18n with "system prompt", README docs
+ *   describing what we block, LLM-prompt-engineering code, security tests).
+ *   The Bash surface is the right place to catch prompt-injection / code-injection
+ *   patterns; Edit-time content is data, not execution intent.
  */
 function buildScanPayload(toolName, toolInput) {
     if (toolName === 'Bash') {
@@ -438,11 +442,11 @@ function buildScanPayload(toolName, toolInput) {
         return JSON.stringify({ file_path: toolInput.file_path ?? '' });
     }
     if (toolName === 'Edit') {
-        // Scan destination path + old_string (the selector), not new_string (the replacement)
-        return JSON.stringify({
-            file_path: toolInput.file_path ?? '',
-            old_string: toolInput.old_string ?? '',
-        });
+        // Same model as Write: scan only the destination. The old_string is
+        // EXISTING file content (data), not execution intent — scanning it
+        // produced false positives on legitimate edits to files containing
+        // attack-shaped strings (e.g. i18n.js with a "system prompt" key).
+        return JSON.stringify({ file_path: toolInput.file_path ?? '' });
     }
     if (toolName === 'MultiEdit') {
         // Scan file paths only

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

@@ -0,0 +1,340 @@
+/**
+ * F6 Conductor — codehere's own meta-agent.
+ *
+ * Plain English in, agent actions out. The Conductor is a first-class
+ * AgentAdapter that doesn't fork a subprocess — instead it ROUTES the
+ * incoming prompt to one of the dogfooded specialists (Claude Code, Codex,
+ * Aider, OpenCode) based on intent, then proxies the spawned session's
+ * events back to the caller verbatim, with a single Conductor-attributed
+ * "delegated to X" event prepended so the audit log records the routing
+ * decision.
+ *
+ * This is the v0.4-alpha SCAFFOLD. Routing is rule-based (keyword → adapter)
+ * for now. The v0.4 stable target replaces the rule lookup with an LLM
+ * classifier — Claude Haiku 4.5 prompted to pick the best specialist given
+ * the user's request, the available agents, and any context from past
+ * sessions. The seam (`pickSpecialist`) is the same; only the body changes.
+ *
+ * Why this matters: until Conductor exists, codehere is "a UI over other
+ * people's agents." With Conductor, codehere becomes a participant in the
+ * thread — the user talks to *codehere*, codehere talks to the agents, and
+ * the user gets a single conversational surface instead of having to know
+ * which specialist suits the task. This is the seam the v0.4+ Slack-shape
+ * thread UX (`@conductor` mention) attaches to.
+ *
+ * What v0.4-alpha intentionally does NOT do:
+ *  - LLM-backed classifier (rule-based only)
+ *  - Multi-step plans (one prompt → one specialist)
+ *  - Cross-session memory (Conductor sees only the current prompt)
+ *  - Mid-session redirection (once delegated, the specialist owns the session)
+ *
+ * Adding any of those before v0.4-stable rc.1 violates the "rc.N is feature-
+ * frozen, beta.N+1 may only harden or fix" rule.
+ *
+ * @see docs/CONDUCTOR.md for the full design + roadmap from scaffold → stable
+ * @see memory/project_decisions_log.md Decision 05 (F6 as first-class foundation)
+ */
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+const ROUTING_RULES = [
+    {
+        triggers: ['review', 'audit', 'explain', 'understand', 'analyze', 'analyse', 'why', 'what does'],
+        preferred: ['claude-code', 'codex', 'aider'],
+        reason: 'review/audit/explain tasks favor Claude Code',
+    },
+    {
+        triggers: ['refactor', 'restructure', 'reorganize', 'reorganise', 'rewrite the', 'extract'],
+        preferred: ['codex', 'claude-code', 'aider'],
+        reason: 'structural refactors favor Codex',
+    },
+    {
+        triggers: ['fix', 'patch', 'bugfix', 'hotfix', 'repair', 'resolve'],
+        preferred: ['aider', 'claude-code', 'codex'],
+        reason: 'targeted fixes favor Aider',
+    },
+    {
+        triggers: ['scaffold', 'generate', 'create new', 'bootstrap', 'set up'],
+        preferred: ['opencode', 'claude-code', 'codex'],
+        reason: 'greenfield generation favors OpenCode',
+    },
+    {
+        triggers: ['add tests', 'write tests', 'test coverage', 'unit test', 'integration test'],
+        preferred: ['codex', 'claude-code', 'aider'],
+        reason: 'test authoring favors Codex',
+    },
+];
+/** Default specialist when no routing rule matches. */
+const DEFAULT_SPECIALIST = 'claude-code';
+/**
+ * Tokenize a prompt for trigger matching. Splits on any non-alphanumeric
+ * boundary (whitespace, hyphens, punctuation), lowercases everything. So:
+ *
+ *   "Bug fix"        → ["bug", "fix"]
+ *   "set-up auth"    → ["set", "up", "auth"]    (trigger "set up" still matches via phrase below)
+ *   "unit-test it"   → ["unit", "test", "it"]
+ *   "prefix matter"  → ["prefix", "matter"]      (does NOT match `fix`)
+ *   "hotfixes"       → ["hotfixes"]              (does NOT match `fix`)
+ *
+ * Multi-word triggers ("add tests", "create new") are matched against the
+ * normalized prompt directly using word boundaries — so they catch
+ * "add tests" but not "added testing harness".
+ */
+function tokenize(prompt) {
+    const tokens = new Set(prompt
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+    // Normalized form for multi-word phrase matching: ANY non-alphanumeric char
+    // (hyphens, underscores, slashes, dots, colons, commas, etc.) becomes a space,
+    // then collapse runs of whitespace. This matches the tokenizer's split rule
+    // exactly, so multi-word triggers like "add tests" catch all of:
+    //   "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() + ' ';
+    return { tokens, normalized };
+}
+/**
+ * Test whether a routing trigger matches a prompt. Single-word triggers must
+ * appear as whole tokens (no substring matches). Multi-word triggers must
+ * appear as a phrase in the normalized prompt (with leading/trailing spaces
+ * to enforce word boundaries on the ends).
+ */
+function triggerMatches(trigger, tokens, normalized) {
+    const t = trigger.toLowerCase().trim();
+    if (!t)
+        return false;
+    if (t.includes(' ')) {
+        return normalized.includes(' ' + t + ' ');
+    }
+    return tokens.has(t);
+}
+/**
+ * Pick the right specialist for a given prompt.
+ *
+ * Algorithm:
+ *  1. Tokenize the prompt (whole-word matching, no substring false-positives).
+ *  2. Walk routing rules in order. Stop at the first rule whose triggers match.
+ *  3. Within that rule, return the first preferred adapter that's installed.
+ *  4. If that rule had a match but none of its preferred adapters are
+ *     installed, return DEFAULT_SPECIALIST (or first installed) with a
+ *     HONEST reason that names the matched rule and the fallback.
+ *  5. If no rule matched at all, return DEFAULT_SPECIALIST (or first
+ *     installed) with a "no intent matched" reason.
+ *
+ * Returns null if NO specialist is installed (caller must handle).
+ *
+ * Known limitation: a prompt with multiple intents (e.g. "fix the bug and
+ * add tests") routes by the first matching rule, not the dominant intent.
+ * The v0.4 LLM classifier inherently handles dominance via confidence
+ * scoring; the rule-based path here keeps the deterministic-priority
+ * contract instead.
+ */
+export function pickSpecialist(prompt, installedAgentIds) {
+    if (installedAgentIds.length === 0) {
+        return null;
+    }
+    const installedSet = new Set(installedAgentIds);
+    const { tokens, normalized } = tokenize(prompt);
+    for (const rule of ROUTING_RULES) {
+        const matches = rule.triggers.some((t) => triggerMatches(t, tokens, normalized));
+        if (!matches)
+            continue;
+        // Rule matched. Walk preferred specialists in order.
+        for (const candidate of rule.preferred) {
+            if (installedSet.has(candidate)) {
+                return { agentId: candidate, reason: rule.reason };
+            }
+        }
+        // Rule matched but none of its preferred specialists are installed.
+        // Fall through with an HONEST reason that names the matched rule + fallback,
+        // so the audit log records what actually happened (Codex review caught
+        // the prior version saying "default routing" here, which was a lie).
+        const fallbackId = installedSet.has(DEFAULT_SPECIALIST) ? DEFAULT_SPECIALIST : installedAgentIds[0];
+        return {
+            agentId: fallbackId,
+            reason: `${rule.reason} — but none of [${rule.preferred.join(', ')}] installed; falling back to ${fallbackId}`,
+        };
+    }
+    // No rule matched. Default routing.
+    if (installedSet.has(DEFAULT_SPECIALIST)) {
+        return { agentId: DEFAULT_SPECIALIST, reason: 'default routing (no specific intent matched)' };
+    }
+    return { agentId: installedAgentIds[0], reason: 'fallback to first available specialist' };
+}
+/**
+ * Build the Conductor adapter. The lookup function is injected so we can
+ * register against the same registry without creating an import cycle.
+ *
+ * IMPORTANT: the lookup is called at spawn time, NOT module-load time, so
+ * it sees the fully-populated registry including any user-config adapters.
+ */
+export function buildConductorAdapter(lookup) {
+    const adapter = {
+        id: 'conductor',
+        label: 'Conductor (codehere)',
+        // Conductor doesn't run as its own OS process — there's nothing to detect
+        // via `ps`. The processPattern returned here will never match, by design.
+        processPattern: /__conductor_never_matches__/,
+        isInstalled() {
+            // Conductor is "installed" iff at least one specialist is installed.
+            // Anything else would be a confusing UX (offer Conductor when it has
+            // nothing to delegate to).
+            return lookup().some((a) => a.id !== 'conductor' && a.isInstalled());
+        },
+        checkReadiness() {
+            const specialists = lookup().filter((a) => a.id !== 'conductor');
+            const installedSpecialists = specialists.filter((a) => a.isInstalled());
+            if (installedSpecialists.length === 0) {
+                return {
+                    id: 'conductor',
+                    label: 'Conductor (codehere)',
+                    state: 'needs_install',
+                    installed: false,
+                    installHint: {
+                        command: 'npm install -g @anthropic-ai/claude-code',
+                        url: 'https://github.com/codehere/codehere#install',
+                    },
+                    authHint: {
+                        detail: 'Conductor delegates to specialists. Install at least one (Claude Code, Codex, Aider, or OpenCode) and Conductor becomes available automatically.',
+                    },
+                };
+            }
+            return {
+                id: 'conductor',
+                label: 'Conductor (codehere)',
+                state: 'ready',
+                installed: true,
+            };
+        },
+        spawn(prompt, options) {
+            return spawnConductor(prompt, options ?? {}, lookup);
+        },
+    };
+    return adapter;
+}
+/**
+ * Spawn the Conductor session. Does not fork a process — instead picks a
+ * specialist, spawns it, and proxies its events through with a single
+ * "delegated" event prepended to the buffer.
+ */
+function spawnConductor(prompt, options, lookup) {
+    const sessionId = randomUUID();
+    const startedAt = Date.now();
+    const emitter = new EventEmitter();
+    const buffer = [];
+    let statusValue = 'running';
+    // Look up installed specialists (excluding Conductor itself to avoid recursion)
+    const installedAgentIds = lookup()
+        .filter((a) => a.id !== 'conductor' && a.isInstalled())
+        .map((a) => a.id);
+    const decision = pickSpecialist(prompt, installedAgentIds);
+    // If nothing's installed, emit an error event and return a non-running session.
+    if (!decision) {
+        statusValue = 'error';
+        const errEvent = {
+            type: 'error',
+            timestamp: Date.now(),
+            data: {
+                message: 'Conductor has no specialists to delegate to. Install at least one of: Claude Code, Codex, Aider, OpenCode.',
+            },
+        };
+        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
+    // specialist was chosen. Layer 7 agent-provenance — every action attributable.
+    const routingEvent = {
+        type: 'codehere:conductor-routing',
+        timestamp: Date.now(),
+        data: {
+            conductorSessionId: sessionId,
+            delegatedTo: decision.agentId,
+            reason: decision.reason,
+            promptExcerpt: prompt.slice(0, 200),
+        },
+    };
+    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) {
+        // Defensive: pickSpecialist returned an ID not in the registry. Shouldn't
+        // happen if installedAgentIds was derived from lookup(), but guard anyway.
+        statusValue = 'error';
+        const errEvent = {
+            type: 'error',
+            timestamp: Date.now(),
+            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.
+    const specialistSession = specialist.spawn(prompt, options);
+    let stepsSnapshot = [];
+    let artifactsSnapshot;
+    specialistSession.subscribe((evt) => {
+        buffer.push(evt);
+        emitter.emit('event', evt);
+        // Mirror progress + artifacts so PM-UX layers see them on the Conductor session, too.
+        if (specialistSession.steps)
+            stepsSnapshot = specialistSession.steps;
+        if (specialistSession.artifacts)
+            artifactsSnapshot = specialistSession.artifacts;
+        if (evt.type === 'codehere:complete' || evt.type === 'codehere:error') {
+            statusValue = specialistSession.status;
+        }
+    });
+    return {
+        sessionId,
+        startedAt,
+        prompt,
+        agent: 'conductor',
+        get status() {
+            return statusValue;
+        },
+        get steps() {
+            return stepsSnapshot;
+        },
+        get artifacts() {
+            return artifactsSnapshot;
+        },
+        canAppendMessage: false, // v0.4-alpha doesn't support mid-session redirection
+        subscribe(handler) {
+            for (const e of buffer)
+                handler(e);
+            emitter.on('event', handler);
+            return () => emitter.off('event', handler);
+        },
+        kill() {
+            specialistSession.kill();
+            statusValue = 'killed';
+        },
+    };
+}
+/** Build a TaskSession that just replays an event buffer — used for error states. */
+function synthesizeSession(args) {
+    const { sessionId, startedAt, prompt, statusValue, emitter, buffer } = args;
+    return {
+        sessionId,
+        startedAt,
+        prompt,
+        agent: 'conductor',
+        get status() {
+            return statusValue;
+        },
+        subscribe(handler) {
+            for (const e of buffer)
+                handler(e);
+            emitter.on('event', handler);
+            return () => emitter.off('event', handler);
+        },
+        kill() {
+            /* nothing to kill — never started */
+        },
+    };
+}
+//# sourceMappingURL=conductor-adapter.js.map

package/dist/infrastructure/orchestration/session-manager.js

@@ -18,6 +18,7 @@ import { CodexAdapter } from './codex-adapter.js';
 import { AiderAdapter } from './aider-adapter.js';
 import { OpenCodeAdapter } from './opencode-adapter.js';
 import { buildGenericAdapter, loadAgentsConfig } from './generic-cli-adapter.js';
+import { buildConductorAdapter } from './conductor-adapter.js';
 import { seedAgentsConfig } from './agents-config-seed.js';
 import { AUDIT_FILE } from '../hooks/claude-sdk-hook.js';
 import { appendSpawned, appendCompleted, loadRecent } from './session-persistence.js';
@@ -37,6 +38,11 @@ const REGISTRY = [
     // popular CLI agents above. Users can add/edit/remove entries freely.
     ...loadAgentsConfig().map(buildGenericAdapter),
 ];
+// F6 Conductor — the meta-agent. Registered LAST so it sees the full registry
+// at lookup time. The lookup function is closed over `REGISTRY` so it always
+// returns the current populated array (including any future user adapters).
+// Conductor is appended to the same array so UIs that iterate REGISTRY see it.
+REGISTRY.push(buildConductorAdapter(() => REGISTRY));
 export function availableAgents() {
     return REGISTRY.map((a) => ({ id: a.id, label: a.label, installed: a.isInstalled() }));
 }

package/dist/infrastructure/protocols/probe-port.js

@@ -0,0 +1,36 @@
+/**
+ * Detect whether a given host:port is already serving a codehere instance.
+ *
+ * Used by `codehere start` when the listen() fails with EADDRINUSE: we'd
+ * rather give the user a friendly "codehere already running, opening browser"
+ * than a Node stack trace. If something ELSE holds the port we tell them to
+ * pick a different one.
+ *
+ * Approach: hit the existing server's /health endpoint. The codehere MCP
+ * server returns a JSON body with `server: 'codehere-mcp'` — no other tool
+ * uses that exact identifier. Generous 1.5-second timeout so a slow loopback
+ * doesn't false-negative.
+ */
+export async function isCodehereOnPort(host, port, timeoutMs = 1500) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await fetch(`http://${host}:${port}/health`, { signal: ac.signal });
+        if (!res.ok)
+            return { isCodehere: false };
+        const body = (await res.json());
+        if (body?.server === 'codehere-mcp') {
+            return { isCodehere: true, version: body.version };
+        }
+        return { isCodehere: false };
+    }
+    catch {
+        // Connection refused, timeout, malformed response — anything that's not
+        // a positive codehere identification. Treat as "not codehere."
+        return { isCodehere: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=probe-port.js.map

package/dist/presentation/cli/repl.js

@@ -0,0 +1,474 @@
+/**
+ * Interactive REPL for codehere.
+ *
+ * Bare `codehere` (no args) drops here — the CLI surface, parallel to the
+ * web UI at `codehere start`. Type a task in plain English; the Conductor
+ * routes to the right specialist; events stream to the terminal; you get
+ * the next prompt when the task completes.
+ *
+ * Why this exists:
+ * - The v0.2 REPL was removed in D7 along with the rest of the v0.2 CLI
+ *   surface. That trim went too far — it removed a CLI entry point users
+ *   relied on. rc.6 brings it back, this time backed by the v0.3
+ *   Conductor (rule-based routing) instead of v0.2's smart-route.
+ * - codehere is "PM you talk to" — terminal users should be able to talk
+ *   to it in the terminal, not be forced to a web UI. Both surfaces, both
+ *   first-class.
+ *
+ * What's here:
+ * - Read a line → route via Conductor → spawn specialist → stream events
+ *   to stdout → await completion → next prompt
+ * - `/agents` lists installed specialists and the routing rules
+ * - `/status` shows recent audit activity
+ * - `/quit` (or Ctrl+C / Ctrl+D) exits cleanly
+ */
+import readline from 'readline';
+import { colors, newline } from '../../ui.js';
+import { getVersion } from '../../utils/version.js';
+import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+const SLASH_COMMANDS = [
+    // Task commands · describe the work, the Conductor routes
+    {
+        name: 'fix',
+        aliases: ['edit'],
+        args: '<file> <instruction>',
+        description: 'fix or edit a file (Conductor routes to Aider by default)',
+        action: 'task',
+        promptTemplate: (args) => {
+            const parts = args.split(/\s+/);
+            const file = parts[0];
+            const instr = parts.slice(1).join(' ');
+            return `fix ${file}: ${instr}`;
+        },
+    },
+    {
+        name: 'explain',
+        aliases: ['e'],
+        args: '<file>',
+        description: 'explain a file (Conductor routes to Claude Code by default)',
+        action: 'task',
+        promptTemplate: (args) => `explain this file in plain English: ${args}`,
+    },
+    {
+        name: 'review',
+        aliases: ['r'],
+        args: '<file>',
+        description: 'review a file for bugs and risks (routes to Claude Code)',
+        action: 'task',
+        promptTemplate: (args) => `review ${args} for bugs, security issues, and risks. List concrete findings.`,
+    },
+    {
+        name: 'plan',
+        aliases: ['p'],
+        args: '<instruction>',
+        description: 'plan a complex task into steps (routes to Codex/Claude Code)',
+        action: 'task',
+        promptTemplate: (args) => `plan: ${args}. Break down into concrete steps before any execution.`,
+    },
+    {
+        name: 'test',
+        args: '<file or area>',
+        description: 'add or write tests (routes to Codex)',
+        action: 'task',
+        promptTemplate: (args) => `add tests for ${args}. Cover edge cases and likely failure modes.`,
+    },
+    // Meta · don't spawn agents · run locally
+    { name: 'agents', aliases: ['a'], description: 'list installed specialists + routing rules', action: 'meta' },
+    { name: 'status', aliases: ['s'], description: 'last 24h activity from the audit log', action: 'meta' },
+    { name: 'trust', args: '[path]', description: 'scan a path for security issues (default: current dir)', action: 'meta' },
+    { name: 'history', aliases: ['hist'], description: 'recent prompts in this session', action: 'meta' },
+    { name: 'web', description: 'launch the web UI at :3773 (in another terminal)', action: 'meta' },
+    { name: 'undo', description: 'undo the last edit (queued for v0.5 · F3 memory layer)', action: 'meta' },
+    { name: 'cost', description: 'usage / cost (alias for /status in v0.3)', action: 'meta' },
+    { name: 'clear', description: 'clear the screen', action: 'meta' },
+    { name: 'help', aliases: ['?'], description: 'show this help', action: 'meta' },
+    { name: 'quit', aliases: ['exit', 'q'], description: 'exit (Ctrl+C / Ctrl+D also work)', action: 'meta' },
+];
+function findSlashCommand(input) {
+    const parts = input.trim().split(/\s+/);
+    const head = parts[0].toLowerCase();
+    for (const cmd of SLASH_COMMANDS) {
+        if (cmd.name === head || (cmd.aliases ?? []).includes(head)) {
+            return { command: cmd, args: parts.slice(1).join(' ').trim() };
+        }
+    }
+    return null;
+}
+export async function runInteractiveRepl(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const history = [];
+    newline();
+    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
+    console.log(colors.dim('Talk to your AI coding agents. Type a task to delegate; or use a /command.'));
+    newline();
+    console.log(colors.dim('  /fix /explain /review /plan      delegate a task; Conductor picks the specialist'));
+    console.log(colors.dim('  /agents /status /trust /history  show state, no agent spawn'));
+    console.log(colors.dim('  /help                            full command list'));
+    console.log(colors.dim('  ↑/↓ history  ·  Ctrl+L clear  ·  Ctrl+C / Ctrl+D exit'));
+    newline();
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(colors.yellow('  No specialist agents installed. Install at least one to delegate tasks:'));
+        console.log(colors.dim('    npm install -g @anthropic-ai/claude-code'));
+        console.log(colors.dim('    npm install -g @openai/codex'));
+        console.log(colors.dim('    brew install aider'));
+        console.log(colors.dim('    curl -fsSL https://opencode.ai/install | bash'));
+        newline();
+        console.log(colors.dim('You can still use ') +
+            colors.cyan('/status') +
+            colors.dim(', ') +
+            colors.cyan('codehere trust .') +
+            colors.dim(', and the safety hook here.'));
+        newline();
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: colors.cyan('› '),
+        terminal: true,
+        historySize: 200,
+    });
+    const manager = SessionManager.getInstance();
+    const promptNext = () => {
+        rl.setPrompt(colors.cyan('› '));
+        rl.prompt();
+    };
+    rl.on('close', () => {
+        newline();
+        console.log(colors.dim('Goodbye.'));
+        process.exit(0);
+    });
+    rl.on('SIGINT', () => {
+        rl.close();
+    });
+    promptNext();
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            promptNext();
+            continue;
+        }
+        history.push(trimmed);
+        // Slash commands first
+        if (trimmed.startsWith('/')) {
+            const found = findSlashCommand(trimmed.slice(1));
+            if (!found) {
+                console.log(colors.yellow(`  Unknown command: ${trimmed.split(/\s+/)[0]}`));
+                console.log(colors.dim('  Run /help to see all commands.'));
+                promptNext();
+                continue;
+            }
+            const { command, args } = found;
+            switch (command.name) {
+                case 'quit':
+                    rl.close();
+                    return;
+                case 'help':
+                    printSlashCommandHelp();
+                    break;
+                case 'clear':
+                    console.clear();
+                    newline();
+                    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
+                    newline();
+                    break;
+                case 'agents':
+                    printAgentsAndRoutingRules();
+                    break;
+                case 'status':
+                    await printStatusSummary();
+                    break;
+                case 'history':
+                    printHistory(history);
+                    break;
+                case 'web':
+                    console.log(colors.dim('  Tip: run ') +
+                        colors.cyan('codehere start') +
+                        colors.dim(' in another terminal to launch the web UI at http://127.0.0.1:3773'));
+                    break;
+                case 'trust':
+                    await runTrustScan(args || '.');
+                    break;
+                case 'cost':
+                    // v0.3 doesn't separate cost tracking — show the same dashboard as /status
+                    await printStatusSummary();
+                    break;
+                case 'undo':
+                    console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
+                    console.log(colors.dim('  For now, use git: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
+                    break;
+                default: {
+                    // Task slash command (/fix, /explain, /review, /plan, /test) → Conductor
+                    if (command.action !== 'task' || !command.promptTemplate)
+                        break;
+                    if (!args) {
+                        console.log(colors.yellow(`  Usage: /${command.name}${command.args ? ' ' + command.args : ''}`));
+                        break;
+                    }
+                    if (installed.length === 0) {
+                        console.log(colors.yellow('  No specialist installed — install one and try again.'));
+                        break;
+                    }
+                    const promptText = command.promptTemplate(args);
+                    try {
+                        await runTask(promptText, cwd, manager);
+                    }
+                    catch (err) {
+                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+                    }
+                    newline();
+                }
+            }
+            promptNext();
+            continue;
+        }
+        // Legacy non-slash syntax for backwards-compat with v0.2 muscle memory
+        // (commit 796d4b7's REPL accepted these forms without /).
+        const lower = trimmed.toLowerCase();
+        const legacyMatch = lower.startsWith('explain ') || lower.startsWith('e ')
+            ? { name: 'explain', argsAt: lower.startsWith('explain ') ? 8 : 2 }
+            : lower.startsWith('fix ') || lower.startsWith('edit ')
+                ? { name: 'fix', argsAt: lower.startsWith('fix ') ? 4 : 5 }
+                : lower.startsWith('review ')
+                    ? { name: 'review', argsAt: 7 }
+                    : lower.startsWith('plan ')
+                        ? { name: 'plan', argsAt: 5 }
+                        : null;
+        if (legacyMatch) {
+            const cmd = SLASH_COMMANDS.find((c) => c.name === legacyMatch.name);
+            if (cmd?.promptTemplate) {
+                const args = trimmed.substring(legacyMatch.argsAt).trim();
+                if (!args) {
+                    console.log(colors.yellow(`  Usage: /${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`));
+                }
+                else if (installed.length === 0) {
+                    console.log(colors.yellow('  No specialist installed — install one and try again.'));
+                }
+                else {
+                    try {
+                        await runTask(cmd.promptTemplate(args), cwd, manager);
+                    }
+                    catch (err) {
+                        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+                    }
+                }
+                newline();
+                promptNext();
+                continue;
+            }
+        }
+        // Plain text → delegate via Conductor
+        if (installed.length === 0) {
+            console.log(colors.yellow('  No specialist installed — install one and try again.'));
+            promptNext();
+            continue;
+        }
+        try {
+            await runTask(trimmed, cwd, manager);
+        }
+        catch (err) {
+            console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        }
+        newline();
+        promptNext();
+    }
+}
+/**
+ * Run `codehere trust <path>` inline. Spawns the trust command as a child
+ * process so the existing rendering / scoring logic is reused as-is.
+ */
+async function runTrustScan(target) {
+    const { spawn } = await import('child_process');
+    const { fileURLToPath } = await import('url');
+    const { join, dirname } = await import('path');
+    // dist/presentation/cli/repl.js → walk up to dist/index.js
+    const here = fileURLToPath(import.meta.url);
+    const cliPath = join(dirname(here), '..', '..', 'index.js');
+    await new Promise((resolve) => {
+        const child = spawn('node', [cliPath, 'trust', target], { stdio: 'inherit' });
+        child.on('close', () => resolve());
+        child.on('error', (err) => {
+            console.log(colors.red('  ✗ ') + err.message);
+            resolve();
+        });
+    });
+}
+function printSlashCommandHelp() {
+    const formatRow = (cmd) => {
+        const aliases = cmd.aliases?.length ? colors.dim(' (/' + cmd.aliases.join(', /') + ')') : '';
+        const cmdLabel = '/' + cmd.name + (cmd.args ? ' ' + cmd.args : '');
+        console.log('    ' + colors.cyan(cmdLabel.padEnd(34)) + colors.dim(cmd.description) + aliases);
+    };
+    newline();
+    console.log(colors.bold('Slash commands'));
+    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    newline();
+    console.log(colors.bold('  Tasks') + colors.dim(' — describe the work; Conductor routes to the right specialist'));
+    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'task'))
+        formatRow(cmd);
+    newline();
+    console.log(colors.bold('  Meta') + colors.dim(' — run locally, no agent spawn'));
+    for (const cmd of SLASH_COMMANDS.filter((c) => c.action === 'meta'))
+        formatRow(cmd);
+    newline();
+    console.log(colors.bold('  Or just type'));
+    console.log(colors.dim('    Plain text without / → Conductor routes (e.g. "review src/auth.ts" → claude-code)'));
+    console.log(colors.dim('    Legacy v0.2 syntax: ') + colors.cyan('explain src/auth.ts') + colors.dim(' / ') + colors.cyan('fix file "instr"') + colors.dim(' also work without /'));
+    newline();
+}
+function printHistory(history) {
+    newline();
+    if (history.length === 0) {
+        console.log(colors.dim('  No prompts yet in this session.'));
+        newline();
+        return;
+    }
+    console.log(colors.bold('  Recent prompts:'));
+    history.slice(-10).forEach((h, i) => {
+        const preview = h.length > 70 ? h.slice(0, 67) + '…' : h;
+        console.log(colors.dim(`    ${(i + 1).toString().padStart(2, ' ')}. `) + preview);
+    });
+    newline();
+}
+/**
+ * Run a single task and exit — bypass the REPL prompt loop.
+ * Use case: `codehere "review src/auth.ts"` or scripts piping a task in.
+ */
+export async function runOneShot(prompt, cwd = process.cwd()) {
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(colors.yellow('  No specialist installed. Install one (see `codehere setup`) and try again.'));
+        process.exit(1);
+    }
+    const manager = SessionManager.getInstance();
+    try {
+        await runTask(prompt, cwd, manager);
+    }
+    catch (err) {
+        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+}
+async function runTask(prompt, cwd, manager) {
+    const session = manager.spawn(prompt, 'conductor', { cwd });
+    const startedLabel = colors.dim('  ┌─ ') + colors.bold(session.sessionId.slice(0, 8)) + colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString());
+    console.log(startedLabel);
+    await new Promise((resolve) => {
+        const unsubscribe = session.subscribe((event) => {
+            renderEvent(event);
+            if (event.type === 'codehere:complete' || event.type === 'codehere:error' || event.type === 'exit') {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+    const finalStatus = session.status;
+    const verdict = finalStatus === 'completed' ? colors.green('  └─ done') : finalStatus === 'killed' ? colors.yellow('  └─ killed') : colors.red('  └─ ' + finalStatus);
+    console.log(verdict);
+}
+function renderEvent(event) {
+    switch (event.type) {
+        case 'codehere:conductor-routing': {
+            const data = event.data;
+            console.log(colors.dim('  │ ') +
+                colors.bold('routing → ') +
+                colors.cyan(data.delegatedTo ?? '?') +
+                colors.dim(' · ' + (data.reason ?? '')));
+            break;
+        }
+        case 'codehere:steps': {
+            // Step snapshots replay frequently — skip the noisy ones; the UI handles them
+            break;
+        }
+        case 'stdout':
+        case 'stderr': {
+            const data = event.data;
+            const line = data?.line;
+            if (line) {
+                const text = String(line).trimEnd();
+                if (text)
+                    console.log(colors.dim('  │ ') + text);
+            }
+            break;
+        }
+        case 'error': {
+            const data = event.data;
+            if (data?.message)
+                console.log(colors.red('  │ ✗ ') + data.message);
+            break;
+        }
+        case 'codehere:complete':
+        case 'exit': {
+            // handled by runTask's verdict line
+            break;
+        }
+        default:
+            // Other event types — quiet by default to keep the REPL readable
+            break;
+    }
+}
+function printAgentsAndRoutingRules() {
+    newline();
+    console.log(colors.bold('  Installed specialists:'));
+    const all = availableAgents();
+    for (const a of all) {
+        const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
+        const status = a.installed ? '' : colors.dim('  (not installed)');
+        console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
+    }
+    newline();
+    console.log(colors.bold('  Routing (rule-based; LLM classifier in v0.4):'));
+    console.log(colors.dim('    review · audit · explain → claude-code'));
+    console.log(colors.dim('    refactor · restructure → codex'));
+    console.log(colors.dim('    fix · patch · bugfix → aider'));
+    console.log(colors.dim('    scaffold · generate · bootstrap → opencode'));
+    console.log(colors.dim('    add tests · write tests → codex'));
+    console.log(colors.dim('    (anything else) → claude-code'));
+    newline();
+}
+async function printStatusSummary() {
+    newline();
+    try {
+        const { existsSync, readFileSync } = await import('fs');
+        const { join } = await import('path');
+        const { homedir } = await import('os');
+        const auditPath = process.env.CODEHERE_AUDIT_FILE || join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
+        if (!existsSync(auditPath)) {
+            console.log(colors.dim('  No audit log yet. Run a task or `codehere hook install`.'));
+            newline();
+            return;
+        }
+        const lines = readFileSync(auditPath, 'utf-8').split('\n').filter(Boolean).slice(-10);
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        let actions = 0;
+        let blocked = 0;
+        let trustSum = 0;
+        let trustN = 0;
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                const ts = entry.timestamp ? Date.parse(entry.timestamp) : 0;
+                if (ts < cutoff)
+                    continue;
+                actions++;
+                if (entry.blocked)
+                    blocked++;
+                if (typeof entry.riskScore === 'number') {
+                    trustSum += 100 - entry.riskScore;
+                    trustN++;
+                }
+            }
+            catch {
+                /* skip malformed line */
+            }
+        }
+        const avgTrust = trustN > 0 ? Math.round(trustSum / trustN) : null;
+        console.log(colors.bold('  Last 24h:'));
+        console.log(`    ${actions} actions · ${blocked} blocked${avgTrust !== null ? ` · avg trust ${avgTrust}` : ''}`);
+    }
+    catch (err) {
+        console.log(colors.dim('  Could not read audit log: ' + (err instanceof Error ? err.message : String(err))));
+    }
+    newline();
+}
+//# sourceMappingURL=repl.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.1",
+  "version": "0.3.0-rc.10",
   "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",