codehere 0.8.0 → 1.0.2

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

@@ -1,377 +0,0 @@
-/**
- * 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',
-    },
-    {
-        // Narrowed 2026-06-02 (root-cause fix for "randomly uses opencode"): bare
-        // 'generate'/'set up' are far too common ("generate a report", "set up the
-        // config") and were silently routing ordinary tasks to opencode. AND
-        // claude-code now leads — opencode has NO mid-stream visibility (buffered
-        // output), so it must never be the surprise default for a "watch it work"
-        // product; it stays available via the explicit agent picker.
-        triggers: ['scaffold', 'bootstrap', 'create a new project', 'greenfield', 'new project from scratch'],
-        preferred: ['claude-code', 'codex', 'opencode'],
-        reason: 'greenfield scaffolding — claude-code default (visible); opencode opt-in only',
-    },
-    {
-        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);
-        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 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);
-    // 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);
-        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);
-        // Mirror progress + artifacts BEFORE re-emitting so any subscriber that
-        // reads `session.status` / `session.steps` / `session.artifacts` from
-        // inside its event handler sees the up-to-date conductor state.
-        //
-        // BUG 2 (zombie RUNNING sessions, May 1 2026, 138/155 records affected):
-        // pre-fix this block emitted FIRST and updated status SECOND. session-
-        // manager.ts subscribes to the conductor session and persists `session.status`
-        // synchronously inside its on-exit handler. With emit-before-update,
-        // every conductor session was persisted with status='running' even though
-        // the underlying specialist had already finished. The fix reorders so the
-        // emit() at the end sees the freshly-mirrored statusValue.
-        if (specialistSession.steps)
-            stepsSnapshot = specialistSession.steps;
-        if (specialistSession.artifacts)
-            artifactsSnapshot = specialistSession.artifacts;
-        // 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;
-        }
-        emitter.emit('event', evt);
-    });
-    return {
-        sessionId,
-        startedAt,
-        prompt,
-        agent: 'conductor',
-        get status() {
-            return statusValue;
-        },
-        get steps() {
-            return stepsSnapshot;
-        },
-        get artifacts() {
-            return artifactsSnapshot;
-        },
-        // v0.6.0 — Slice 3 of REPL persistence. Conductor inherits appendMessage
-        // capability from whichever specialist it routed to. With all 5 external
-        // adapters wired in Slices 1-2c, this becomes true for every routing
-        // decision. Follow-ups stay with the SAME specialist that handled the
-        // original turn — no re-routing mid-thread (intentional: the user's reply
-        // is part of an ongoing exchange with that specific specialist, not a
-        // fresh classification opportunity).
-        canAppendMessage: specialistSession.canAppendMessage === true,
-        appendMessage: specialistSession.appendMessage
-            ? (text) => specialistSession.appendMessage(text)
-            : undefined,
-        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/context-handoff.js

@@ -1,144 +0,0 @@
-/**
- * context-handoff — structured cross-session context handoff protocol (P2).
- *
- * Bridges P0's auto-failover trigger with P1's graphify-ts context packs.
- * When a session fails over (or a new session spawns), the handoff loader
- * finds the most relevant context pack from recent session logs and injects
- * it as a system hint so the replacement agent inherits continuity.
- *
- * Protocol:
- *   1. loadHandoffContext(cwd, { fromSessionId?, sessionId?, maxAgeMs? })
- *      — scans .codehere/context-packs.jsonl for the most relevant pack
- *   2. enrichPromptWithHandoff(prompt, cwd, handoff)
- *      — merges the handoff context into a prompt string
- *   3. session handoff is automatic during failover (wired in session-manager)
- *
- * Handoff format (injected as system hint):
- *   [handoff: previous agent=<agent>, completed=<status>, pack=<packId>]
- *   Previous work summary: <pack.payloadPreview or compiled summary>
- *   ---
- *   <original prompt>
- */
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-// ── Constants ──────────────────────────────────────────────────────────────────
-const CONTEXT_PACKS_DIR = '.codehere';
-const CONTEXT_PACKS_FILE = 'context-packs.jsonl';
-const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
-const DEFAULT_MIN_NODES = 5;
-// ── Session log scanning ───────────────────────────────────────────────────────
-/**
- * Load all recent context packs from disk, sorted by timestamp (newest first).
- */
-function loadAllPacks(cwd) {
-    const packsFile = join(cwd, CONTEXT_PACKS_DIR, CONTEXT_PACKS_FILE);
-    if (!existsSync(packsFile)) {
-        return [];
-    }
-    try {
-        const content = readFileSync(packsFile, 'utf-8');
-        const lines = content.split('\n').filter(Boolean);
-        return lines.map((line) => JSON.parse(line)).reverse();
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Find the most relevant handoff context from previous sessions.
- *
- * Priority:
- *   1. Same workspace, same prompt keywords (most recent pack)
- *   2. Same workspace, any pack (most recent)
- *   3. Fallback: no handoff
- */
-export function loadHandoffContext(cwd, { maxAgeMs = DEFAULT_MAX_AGE_MS, minNodes = DEFAULT_MIN_NODES } = {}) {
-    const now = Date.now();
-    const packs = loadAllPacks(cwd);
-    // Filter by age
-    const recent = packs.filter((p) => {
-        const ts = p.timestamp;
-        return ts && now - ts < maxAgeMs;
-    });
-    // Prefer packs with enough graph structure to be useful
-    const structured = recent.filter((p) => {
-        const nodes = p.nodeCount ?? 0;
-        return nodes >= minNodes;
-    });
-    if (structured.length === 0)
-        return null;
-    const last = structured[0];
-    return {
-        packId: String(last.packId ?? ''),
-        agent: String(last.agent ?? 'unknown'),
-        prompt: String(last.prompt ?? ''),
-        status: String(last.status ?? 'unknown'),
-        timestamp: last.timestamp,
-        nodeCount: last.nodeCount,
-        edgeCount: last.edgeCount,
-        task: String(last.task ?? 'explain'),
-        payloadPreview: String(last.payloadPreview ?? ''),
-    };
-}
-// ── Prompt enrichment ──────────────────────────────────────────────────────────
-/**
- * Inject handoff context into a prompt.
- *
- * Returns the enriched prompt string with the handoff as a system hint
- * prepended before the original prompt. Returns the original prompt
- * if no handoff is available.
- */
-export function enrichPromptWithHandoff(prompt, handoff) {
-    if (!handoff)
-        return prompt;
-    const handoffLine = `[handoff: agent=${handoff.agent}, pack=${handoff.packId}, ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges]`;
-    const preview = handoff.payloadPreview ? handoff.payloadPreview.slice(0, 800) : '';
-    return [
-        `[Previous session context — ${handoffLine}]`,
-        `This workspace has recent structural context from a prior session.`,
-        ...(preview ? [`Recent context: ${preview}`] : []),
-        `For details, refer to the knowledge graph at the workspace root.`,
-        `---`,
-        prompt,
-    ].join('\n');
-}
-// ── Failover handoff (P2 integration point) ────────────────────────────────────
-/**
- * Build a handoff context for a failover target.
- *
- * When session A fails and session B auto-spawns as replacement,
- * this loads the most recent pack from the same workspace and
- * merges it into the prompt so B has continuity with A's work.
- */
-export function buildFailoverHandoff(cwd, { failedAgent, failedPrompt }) {
-    // Load most recent pack from workspace
-    const pack = loadHandoffContext(cwd, { maxAgeMs: DEFAULT_MAX_AGE_MS, minNodes: 3 });
-    if (!pack)
-        return null;
-    // Enrich the prompt with the handoff
-    const enrichedPrompt = enrichPromptWithHandoff(failedPrompt, {
-        ...pack,
-        agent: failedAgent,
-        status: 'failed',
-    });
-    return {
-        ...pack,
-        agent: failedAgent,
-        prompt: enrichedPrompt,
-        status: 'failed',
-    };
-}
-// ── Handoff summary (for UI / API) ─────────────────────────────────────────────
-/**
- * Generate a human-readable handoff summary for the dashboard.
- */
-export function formatHandoffSummary(handoff) {
-    const ageMs = Date.now() - handoff.timestamp;
-    const ageStr = ageMs < 60_000
-        ? `${Math.round(ageMs / 1000)}s ago`
-        : ageMs < 3600_000
-            ? `${Math.round(ageMs / 60_000)}m ago`
-            : `${Math.round(ageMs / 3600_000)}h ago`;
-    return `Previous session (${handoff.agent}) completed ${ageStr}. ${handoff.nodeCount} nodes, ${handoff.edgeCount} edges in workspace graph.`;
-}
-//# sourceMappingURL=context-handoff.js.map

package/dist/infrastructure/orchestration/control/codex-control-surface.js

@@ -1,99 +0,0 @@
-/**
- * CodexControlSurface · drives a running codex session via the app-server
- * JSON-RPC protocol (newline-delimited over stdio). inject() = `turn/steer`,
- * which pushes a message into the running turn.
- *
- * Under CODEHERE_MOCK=1 it spawns the mock app-server (zero API, no rate-limit);
- * otherwise the real `codex app-server`. The protocol is identical — the real
- * handshake was verified 2026-05-25; the mock lets us build + test the inject
- * path without spending tokens or waiting on the rate-limit.
- */
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { isMockMode } from '../mocks/resolve-agent-spawn.js';
-function serverSpawn() {
-    if (isMockMode()) {
-        // Env override lets tests point at the compiled dist mock (import.meta.url
-        // is the src .ts under vitest, where the .js sibling doesn't exist).
-        const mockPath = process.env.CODEHERE_MOCK_CODEX_SERVER ||
-            join(dirname(fileURLToPath(import.meta.url)), '..', 'mocks', 'mock-codex-app-server.js');
-        return { command: process.execPath, args: [mockPath] };
-    }
-    return { command: 'codex', args: ['app-server'] };
-}
-export class CodexControlSurface {
-    agentId = 'codex';
-    proc = null;
-    buf = '';
-    nextId = 1;
-    pending = new Map();
-    listeners = [];
-    threadId = '';
-    start() {
-        if (this.proc)
-            return;
-        const { command, args } = serverSpawn();
-        this.proc = spawn(command, args, { stdio: ['pipe', 'pipe', 'inherit'] });
-        this.proc.stdout?.on('data', (d) => this.onData(d.toString()));
-    }
-    onData(chunk) {
-        this.buf += chunk;
-        let nl;
-        while ((nl = this.buf.indexOf('\n')) >= 0) {
-            const line = this.buf.slice(0, nl).trim();
-            this.buf = this.buf.slice(nl + 1);
-            if (!line)
-                continue;
-            let m;
-            try {
-                m = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (typeof m.id === 'number' && this.pending.has(m.id)) {
-                this.pending.get(m.id)(m.result ?? m.error);
-                this.pending.delete(m.id);
-            }
-            else if (m.method) {
-                const evt = { method: m.method, params: m.params };
-                for (const cb of this.listeners)
-                    cb(evt);
-            }
-        }
-    }
-    rpc(method, params) {
-        this.start();
-        return new Promise((resolve) => {
-            const id = this.nextId++;
-            this.pending.set(id, resolve);
-            this.proc.stdin?.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
-        });
-    }
-    async open(prompt) {
-        await this.rpc('initialize', { clientInfo: { name: 'codehere', version: '0.6.2' } });
-        const th = (await this.rpc('thread/start', { cwd: process.cwd() }));
-        this.threadId = String(th?.thread_id ?? '');
-        // Fire the initial turn (don't await — it streams; inject() steers it).
-        void this.rpc('turn/start', { thread_id: this.threadId, input: prompt });
-        return { threadId: this.threadId };
-    }
-    async inject(message) {
-        const r = (await this.rpc('turn/steer', { thread_id: this.threadId, input: message }));
-        return { accepted: r?.accepted === true };
-    }
-    onEvent(cb) {
-        this.listeners.push(cb);
-    }
-    close() {
-        try {
-            this.proc?.kill();
-        }
-        catch {
-            /* best-effort */
-        }
-        this.proc = null;
-    }
-}
-//# sourceMappingURL=codex-control-surface.js.map

package/dist/infrastructure/orchestration/control/control-surface.js

@@ -1,15 +0,0 @@
-/**
- * ControlSurface · the vendor-neutral "drive another agent" abstraction.
- *
- * The POC (agent/test/evidence/poc/control-channel/) proved the cross-agent
- * finding: each agent exposes a DIFFERENT control surface (codex app-server
- * turn/steer · claude --channels · etc.), so codehere's control layer is one
- * interface implemented per-adapter — exactly the adapter pattern codehere
- * already uses for spawning.
- *
- * `inject(message)` is the core primitive: push a message INTO a running agent
- * session (the remote-control headline). Today: codex app-server. Next: claude
- * channel.
- */
-export {};
-//# sourceMappingURL=control-surface.js.map