codehere 1.0.1 → 1.0.3

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

@@ -1,3935 +0,0 @@
-/**
- * codehere MCP Server — Working Implementation
- *
- * Starts an HTTP server that speaks the Model Context Protocol.
- * Exposes codehere's trust scanning tools to any MCP-compatible client:
- * Claude Desktop, Cursor, Zed, Continue, Cline, and any agent that supports MCP.
- *
- * Tools exposed:
- *   - codehere_trust    — score a file or code snippet (Layer 0, no API)
- *   - codehere_scan     — scan an instruction/text for injection/threats
- *   - codehere_review   — list findings for a codebase path
- *   - codehere_audit    — read recent hook audit log entries
- *
- * Protocol: MCP over HTTP+SSE (Model Context Protocol Spec 2024-11)
- * Authentication: Bearer token (optional, configurable)
- *
- * Usage:
- *   codehere serve              # start on port 3773
- *   codehere serve --port 8080  # custom port
- */
-import http from 'http';
-import { readFileSync, existsSync, statSync, watchFile, unwatchFile, rmSync, mkdirSync } from 'fs';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { join, dirname, resolve as resolvePath } from 'path';
-import { shipScan } from '../security/ship-scan.js';
-import { fixExposedSecret } from '../security/fix-secret.js';
-import { fixCodeVuln } from '../security/fix-code.js';
-import { fileURLToPath } from 'url';
-import { AUDIT_FILE, MOCK_AUDIT_FILE, verifyAuditChain } from '../hooks/claude-sdk-hook.js';
-import { signAuditTip, pruneSignState } from '../hooks/audit-tip-signature.js';
-import { analyzeSessions, isRealHostSession, previewFromToolInput } from '../hooks/session-analyzer.js';
-import { CodexControlSurface } from '../orchestration/control/codex-control-surface.js';
-import { getVersion } from '../../utils/version.js';
-import { TOOLS, dispatch } from './mcp-tools.js';
-import { TASK_HTML_V2 } from './ui-page-v2.js';
-import { VERIFY_HTML } from './verify-page.js';
-import { composeVerdict } from '../../application/services/verdict-service.js';
-import { signBundle, verifyBundle, shortFingerprint, collectAuditEntriesForSession, verifyEmbeddedAuditChain, } from '../../application/use-cases/thread-export.js';
-import { loadOrCreateKeypair, trustedKeySet, trustKey } from '../orchestration/thread-key-store.js';
-import { loadSessionById, appendResolved, appendCompleted } from '../orchestration/session-persistence.js';
-import { buildCrossVendorVerdictById, buildCrossVendorVerdictForWriter, } from '../../application/use-cases/build-cross-vendor-verdict.js';
-import { validateIntent as validateWritePassIntent, validateDecision as validateWritePassDecision, applyDecision as applyWritePassDecision, applyResponse as applyWritePassResponse, statusToAuditLine as writePassStatusToAuditLine, newPassId, WritePassError, } from '../../application/use-cases/write-pass.js';
-import { putPending as wpPutPending, getById as wpGetById, setStatus as wpSetStatus, listForSession as wpListForSession, listPending as wpListPending, } from '../orchestration/write-pass-store.js';
-import { resolveWriteRequest, WritePassResolveError } from '../context/write-pass-resolver.js';
-import { trustDomain as trustDomainStore } from '../../application/use-cases/domain-trust.js';
-import { appendAuditLog, appendAuditLogDirect, appendOverrideAudit } from '../hooks/claude-sdk-hook.js';
-import { readFileSync as fsReadFileSync, existsSync as fsExistsSync } from 'fs';
-import { resolveContextSourceUrls } from '../context/context-resolver.js';
-import { getDefaultRegistry, createDefaultFetchContextWithPost } from '../context/registry-bootstrap.js';
-import { begin as oauthBegin, complete as oauthComplete, getProvider as getOAuthProvider, listProviders as listOAuthProviders, } from '../context/oauth-flow.js';
-import { saveToken, clearToken, connectionStatus, loadToken } from '../context/oauth-store.js';
-import { requestDeviceCode, pollForToken, githubClientId } from '../context/github-device-flow.js';
-import { fetchIssue, listIssues, parseRepoRef, issueToTaskPrompt, commentOnIssue, issueRefFromText, } from '../context/github-api.js';
-import { SessionManager, availableAgents, readinessForAllAgents, getAdapter, allAdapters, } from '../orchestration/session-manager.js';
-import { isAbsolute } from 'path';
-import { findProjectRoot } from '../orchestration/memory-injector.js';
-import { scaffoldProjectAt } from '../../presentation/cli/commands/init-command.js';
-import { readCrossToolAgents } from '../storage/cross-tool-agents.js';
-import { listProjects, readMergedProjectThread, parseGitHubCloneTarget } from '../storage/project-thread-reader.js';
-import { mirrorReplyToThread, renameProject, setTaskArchived } from '../storage/project-thread-mirror.js';
-import { randomUUID, timingSafeEqual } from 'crypto';
-import { installAgent } from '../orchestration/agent-installer.js';
-import { detectReadiness } from '../orchestration/readiness.js';
-import { getHookMode } from '../hooks/hook-mode.js';
-import { addPermissionEntry, loadPermissions, removePermissionEntry } from '../security/permissions-config.js';
-import { computeSpendToday, estimateCostUsd } from '../cost/spend-aggregator.js';
-import { loadBudget, saveBudget, isOverBudget, budgetUsedPct } from '../cost/budget-config.js';
-import { loadTeamConfig, saveTeamConfig, initTeamDir, codehereHome, writeMyShare, buildTeamView, } from '../cost/team-ledger.js';
-import { recordOpenOncePerDay, discoverySummary, recruitUrl } from '../discovery/discovery-log.js';
-// ── Brand favicon ────────────────────────────────────────────────────────────
-// Byte-for-byte copy of the landing's app/icon.svg (codehere-landing repo —
-// the brand source of truth, per Ega's standing rule). The gradient-C:
-// orange #ff9a76 → blue #4a90e2, 135° (x1 0%/y1 0% → x2 100%/y2 100%).
-// Embedded so the local-first daemon never hotlinks codehere.uk.
-const BRAND_ICON_SVG = `<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <defs>
-    <linearGradient id="gradient" x1="0%" y1="0%" x2="100%" y2="100%">
-      <stop offset="0%" style="stop-color:#ff9a76;stop-opacity:1" />
-      <stop offset="100%" style="stop-color:#4a90e2;stop-opacity:1" />
-    </linearGradient>
-  </defs>
-  <text
-    x="16"
-    y="24"
-    font-family="Inter, system-ui, sans-serif"
-    font-size="24"
-    font-weight="900"
-    text-anchor="middle"
-    fill="url(#gradient)"
-  >
-    C
-  </text>
-</svg>
-
-`;
-// ── MCP message types ────────────────────────────────────────────────────────
-// ── Tool handlers ────────────────────────────────────────────────────────────
-import { homedir, tmpdir } from 'os';
-const controlSessions = new Map();
-let controlSeq = 0;
-/**
- * Dev-only behavior-observer injection (v0.6.0 — elu joined the team roster
- * 2026-05-03 as behavior reviewer). Activated only when CODEHERE_DEV_ELU=1
- * is set in the founder's local env; never in shipped releases. The script's
- * public key is meant for client-side embedding (analytics tracking key, not
- * a secret) so committing the URL is safe.
- *
- * Why runtime injection instead of editing the page templates directly:
- * the templates stay identical between dev and release builds. The only
- * delta is the env var. This keeps the release surface clean (zero-telemetry
- * value per PRD §1.5 #2 stays intact) while letting elu observe founder
- * dogfood sessions.
- *
- * Removal trigger lives in team_roster.md memory: if elu produces zero
- * unique findings within one month, remove this helper + roster entry.
- */
-const ELU_DEV_SCRIPT = '<script async src="https://elu.dev/v1/elu_pk_live_HrKo9yFFLx03tz9xuSKFcE2Jpv.js"></script>';
-function withDevElu(html) {
-    if (process.env.CODEHERE_DEV_ELU !== '1')
-        return html;
-    return html.replace('</head>', `${ELU_DEV_SCRIPT}\n</head>`);
-}
-const MAX_BODY_SIZE = 2_097_152; // 2 MiB — covers 1MB code-scan payloads + framing
-// v0.8 S2.5 · in-memory map of pending OAuth flows keyed by `state` value.
-// Lifecycle: begin() inserts; callback resolves and removes; entries also
-// expire on a 10-min wall clock (the oauth-flow.ts complete() does the
-// check). Daemon restart wipes this · users just click Connect again.
-const PENDING_OAUTH_FLOWS = new Map();
-function readBody(req, res) {
-    return new Promise((resolve, reject) => {
-        let body = '';
-        req.on('data', (c) => {
-            body += c;
-            if (body.length > MAX_BODY_SIZE) {
-                req.pause();
-                res.writeHead(413, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Request body too large' }));
-                reject(new Error('oversized'));
-            }
-        });
-        req.on('end', () => resolve(body));
-        req.on('error', () => reject(new Error('request aborted')));
-    });
-}
-/** v0.9 S6 · Load context-sources.json into the shape resolveWriteRequest
- *  expects. Same on-disk file as the READ adapters · symmetric storage. */
-function loadContextSourcesConfigForWritePass() {
-    const path = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'context-sources.json');
-    if (!fsExistsSync(path))
-        return {};
-    try {
-        const raw = JSON.parse(fsReadFileSync(path, 'utf-8'));
-        return raw;
-    }
-    catch {
-        return {};
-    }
-}
-export function startMCPServer(options = {}) {
-    const port = options.port ?? 3773;
-    const host = options.host ?? '127.0.0.1'; // localhost only by default
-    const token = options.token;
-    // S9 · practice mode starts clean and leaves no residue: when the mock
-    // chain (stable tmp path) is in use, wipe last session's practice chain
-    // and forget its sign-state key — otherwise the stale key reads the fresh
-    // chain as an rm-bypass (a false tamper alarm), and dead keys pile up in
-    // the real keystore. Explicit CODEHERE_AUDIT_FILE (tests) is untouched.
-    if (process.env.CODEHERE_MOCK === '1' && AUDIT_FILE === MOCK_AUDIT_FILE) {
-        try {
-            rmSync(dirname(MOCK_AUDIT_FILE), { recursive: true, force: true });
-            pruneSignState(MOCK_AUDIT_FILE);
-        }
-        catch {
-            /* best-effort — a leftover practice chain never blocks boot */
-        }
-    }
-    const server = http.createServer((req, res) => {
-        // v0.7 Week-2.2 · CORS for read-only public endpoints.
-        // The landing-page daemon-status pill (codehere.uk → 127.0.0.1:3773)
-        // fetches /health · /api/version · /api/tasks across origins to render
-        // "running locally · vX.Y.Z · N tasks." Without these headers the
-        // browser blocks the cross-origin fetch. Safe to allow * on these
-        // because the endpoints expose only version + task COUNTS (no PII ·
-        // no auth-state · no payload). Mutation endpoints (POST /api/task,
-        // /api/writepass/:id/:decision, etc.) are NOT covered by this · they
-        // remain same-origin-only.
-        const url = req.url ?? '';
-        // Query-stripped path for static brand assets — a cache-busted
-        // /icon.svg?v=N must still hit the icon route, not fall to 404.
-        const urlPath = url.split('?')[0];
-        const isReadOnlyPublic = url === '/health' ||
-            url === '/api/version' ||
-            url === '/api/tasks' ||
-            url === '/api/host-sessions' ||
-            url.startsWith('/api/host-sessions/') ||
-            // MED #32 (atomic audit) · this allowlisted '/api/audit/stats', a route
-            // that never existed (CORS headers on a 404). The real read-only route
-            // the footer polls is /api/audit/summary.
-            url.startsWith('/api/audit/summary') ||
-            url.startsWith('/api/readiness/agents') ||
-            // Brand favicon — static public bytes, no state.
-            urlPath === '/icon.svg' ||
-            urlPath === '/favicon.ico';
-        if (isReadOnlyPublic) {
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-            if (req.method === 'OPTIONS') {
-                res.writeHead(204);
-                res.end();
-                return;
-            }
-        }
-        // Auth check — timing-safe comparison
-        if (token) {
-            const authHeader = req.headers.authorization ?? '';
-            const expected = `Bearer ${token}`;
-            const cmpLen = Math.max(expected.length, authHeader.length);
-            const bufExpected = Buffer.alloc(cmpLen);
-            const bufActual = Buffer.alloc(cmpLen);
-            bufExpected.write(expected);
-            bufActual.write(authHeader);
-            const ok = timingSafeEqual(bufExpected, bufActual);
-            if (!ok) {
-                res.writeHead(401, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Unauthorized' }));
-                return;
-            }
-        }
-        // CSRF / DNS-rebind defense for state-changing requests. The daemon binds
-        // localhost, but the user's own browser can reach it — so a page on a
-        // malicious site could fire a cross-origin POST (a text/plain "simple
-        // request" sidesteps the CORS preflight) to spawn an agent or mutate state.
-        // `codehere start` runs without a bearer token, so that gate is off by
-        // default; this enforces the same-origin-only intent noted above. Browsers
-        // attach Origin / Sec-Fetch-Site on these requests; native clients (the
-        // CLI, curl, MCP stdio) do not — so we reject only requests a browser
-        // marks as cross-origin, and leave header-less non-browser clients alone.
-        const method = req.method ?? 'GET';
-        if (method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS') {
-            const sfs = req.headers['sec-fetch-site'];
-            const origin = req.headers.origin;
-            const selfOrigins = new Set([`http://${host}:${port}`, `http://127.0.0.1:${port}`, `http://localhost:${port}`]);
-            const browserCrossOrigin = (typeof sfs === 'string' && sfs !== 'same-origin' && sfs !== 'none') ||
-                (typeof origin === 'string' && origin !== 'null' && !selfOrigins.has(origin));
-            if (browserCrossOrigin) {
-                res.writeHead(403, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'cross-origin request rejected' }));
-                return;
-            }
-        }
-        // Health check
-        if (req.method === 'GET' && req.url === '/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            // `mock` lets a no-spend tool (verify-all) confirm a daemon is mock BEFORE
-            // attaching — so it can refuse to drive a LIVE daemon while claiming "no spend".
-            res.end(JSON.stringify({
-                status: 'ok',
-                server: 'codehere-mcp',
-                version: getVersion(),
-                tools: TOOLS.length,
-                mock: process.env.CODEHERE_MOCK === '1',
-            }));
-            return;
-        }
-        // Brand favicon · S16 one-brand-everywhere. Byte-for-byte copy of the
-        // landing's app/icon.svg (codehere.uk = brand source of truth) — embedded,
-        // never hotlinked, because the product is local-first/offline.
-        // /favicon.ico answers with the same SVG bytes: browsers request it by
-        // default on any tab whose HTML they haven't parsed yet, so the brand
-        // holds even on surfaces a <link rel=icon> hasn't reached.
-        if (req.method === 'GET' && (urlPath === '/icon.svg' || urlPath === '/favicon.ico')) {
-            res.writeHead(200, { 'Content-Type': 'image/svg+xml', 'Cache-Control': 'public, max-age=86400' });
-            res.end(BRAND_ICON_SVG);
-            return;
-        }
-        // v2 Task-Centric PM UI (primary — served at /)
-        if (req.method === 'GET' && (req.url === '/' || req.url === '/index.html')) {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(withDevElu(TASK_HTML_V2));
-            return;
-        }
-        // /v1 deleted 2026-05-23 · failover UI ported to v2 (see ui-page-v2.ts
-        // .failover-banner). The route now redirects to / so old bookmarks land
-        // on the real product instead of 404.
-        if (req.method === 'GET' && (req.url === '/v1' || req.url === '/v1/')) {
-            res.writeHead(301, { Location: '/' });
-            res.end();
-            return;
-        }
-        // verify-at-the-surface dashboard · /verify (+ /verify/replay, query params).
-        // Serves the SAME HTML for both — the page reads ?mode=replay itself. It
-        // embeds `/` in an iframe as the real observation surface. Not dev-elu
-        // wrapped: it IS the verification view, the elu overlay would be noise.
-        if (req.method === 'GET' && req.url && /^\/verify(\/replay)?(\?.*)?$/.test(req.url)) {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(VERIFY_HTML);
-            return;
-        }
-        // Legacy v1-era pages DELETED 2026-06-10 (Ega hit /history and called it
-        // what it was). The v1-MVP surface is exactly: / (the v2 dashboard),
-        // /verify, the JSON API, and /mcp. /history's audit feed lives on in the
-        // v2 AUDIT footer + `codehere audit`; /threads' project view IS the v2
-        // goal-first home. Old bookmarks land on the real product, never a relic.
-        if (req.method === 'GET' &&
-            (req.url === '/history' ||
-                req.url === '/history/' ||
-                req.url === '/threads' ||
-                req.url === '/threads/' ||
-                req.url?.startsWith('/threads?'))) {
-            res.writeHead(301, { Location: '/' });
-            res.end();
-            return;
-        }
-        // Backwards-compat: /ui used to be the Mission Control audit view
-        if (req.method === 'GET' && (req.url === '/ui' || req.url === '/ui/')) {
-            res.writeHead(302, { Location: '/' });
-            res.end();
-            return;
-        }
-        // Live audit event stream (SSE)
-        if (req.method === 'GET' && req.url === '/events') {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            });
-            // Replay last 50 events on connect so the UI isn't empty
-            let lastSize = 0;
-            if (existsSync(AUDIT_FILE)) {
-                try {
-                    const content = readFileSync(AUDIT_FILE, 'utf-8');
-                    lastSize = Buffer.byteLength(content, 'utf-8');
-                    const lines = content.split('\n').filter((l) => l.trim().length > 0);
-                    for (const line of lines.slice(-50)) {
-                        res.write(`data: ${line}\n\n`);
-                    }
-                }
-                catch {
-                    /* no audit yet */
-                }
-            }
-            // Tail the audit file for new events
-            const onChange = () => {
-                try {
-                    if (!existsSync(AUDIT_FILE))
-                        return;
-                    const currentSize = statSync(AUDIT_FILE).size;
-                    if (currentSize <= lastSize)
-                        return;
-                    const fd = readFileSync(AUDIT_FILE, 'utf-8');
-                    const fresh = fd.slice(lastSize);
-                    lastSize = Buffer.byteLength(fd, 'utf-8');
-                    for (const line of fresh.split('\n').filter((l) => l.trim().length > 0)) {
-                        res.write(`data: ${line}\n\n`);
-                    }
-                }
-                catch {
-                    /* transient read errors are fine */
-                }
-            };
-            watchFile(AUDIT_FILE, { interval: 500 }, onChange);
-            // Keep-alive ping every 15s so proxies don't kill the stream
-            const ping = setInterval(() => res.write(': ping\n\n'), 15000);
-            req.on('close', () => {
-                clearInterval(ping);
-                unwatchFile(AUDIT_FILE, onChange);
-            });
-            return;
-        }
-        // ── P4 SSE — session lifecycle events (realtime /v2 updates) ────────────
-        // Tails sessions.jsonl and pushes "change" events so the /v2 UI can
-        // re-fetch task state instantly instead of waiting 8s for the next poll.
-        // Same pattern as /events (audit log tail) but for sessions.
-        const SESSIONS_FILE = join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
-        if (req.method === 'GET' && req.url === '/api/events/sessions') {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            });
-            // Send current session state on connect
-            try {
-                const manager = SessionManager.getInstance();
-                const sessions = manager.list().map((s) => ({
-                    sessionId: s.sessionId,
-                    status: s.status,
-                    agent: s.agent,
-                }));
-                res.write(`data: ${JSON.stringify({ type: 'init', sessions })}\n\n`);
-            }
-            catch {
-                res.write(`data: ${JSON.stringify({ type: 'init', sessions: [] })}\n\n`);
-            }
-            // Tail sessions.jsonl for changes
-            let lastSize = 0;
-            if (existsSync(SESSIONS_FILE)) {
-                try {
-                    lastSize = statSync(SESSIONS_FILE).size;
-                }
-                catch {
-                    /* first time */
-                }
-            }
-            const onChange = () => {
-                try {
-                    if (!existsSync(SESSIONS_FILE))
-                        return;
-                    const currentSize = statSync(SESSIONS_FILE).size;
-                    if (currentSize <= lastSize)
-                        return;
-                    lastSize = currentSize;
-                    res.write(`data: ${JSON.stringify({ type: 'change' })}\n\n`);
-                }
-                catch {
-                    /* transient */
-                }
-            };
-            watchFile(SESSIONS_FILE, { interval: 500 }, onChange);
-            // Live-progress push: sessions.jsonl is only written on spawn + completion,
-            // so disk-watching alone left the room at "0 steps" for the whole run and
-            // then jumped to the outcome (user-#1, 2026-06-07). Steps update in memory;
-            // SessionManager emits a tick when they do. Push it (throttled to ~400ms so
-            // a chatty agent can't flood the stream) so the room watches work live.
-            // Leading-edge throttle: push the FIRST step the instant it lands (no
-            // 400ms wait), then at most every 250ms with a trailing flush for any
-            // steps that arrived during the window. The old trailing-only throttle
-            // delayed the first step and collapsed bursts into one "jump" — the
-            // running view felt batched, not streamed. (Ega dogfood, watch-it-work)
-            let liveTimer = null;
-            let livePending = false;
-            const pushLive = () => {
-                try {
-                    res.write(`data: ${JSON.stringify({ type: 'change' })}\n\n`);
-                }
-                catch {
-                    /* transient */
-                }
-            };
-            const offLive = SessionManager.getInstance().onLiveChange(() => {
-                if (liveTimer) {
-                    livePending = true;
-                    return;
-                }
-                pushLive();
-                liveTimer = setTimeout(() => {
-                    liveTimer = null;
-                    if (livePending) {
-                        livePending = false;
-                        pushLive();
-                    }
-                }, 250);
-            });
-            const ping = setInterval(() => res.write(': ping\n\n'), 15000);
-            req.on('close', () => {
-                clearInterval(ping);
-                if (liveTimer)
-                    clearTimeout(liveTimer);
-                offLive();
-                unwatchFile(SESSIONS_FILE, onChange);
-            });
-            return;
-        }
-        // ── F2 agent registry ─────────────────────────────────────────────────────
-        if (req.method === 'GET' && req.url === '/api/agents') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ agents: availableAgents() }));
-            return;
-        }
-        // P12 slice — tamper-evidence verification of the audit log.
-        // Calls verifyAuditChain() and returns a compact summary. /history
-        // polls this every minute and shows a red banner if valid=false.
-        if (req.method === 'GET' && req.url === '/api/audit/verify') {
-            try {
-                const r = verifyAuditChain();
-                // A walk over zero entries trivially succeeds, so valid:true here would tell the
-                // dashboard "hash chain verified" about a log that does not exist — the same claim
-                // the CLI's --json path was making. Nothing to verify is not the same as verified.
-                const verifiable = r.totalEntries > 0;
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    valid: verifiable && r.valid,
-                    verifiable,
-                    totalEntries: r.totalEntries,
-                    chainedEntries: r.chainedEntries,
-                    legacyEntries: r.legacyEntries,
-                    errors: r.errors.slice(0, 10),
-                }));
-            }
-            catch {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    valid: false,
-                    totalEntries: 0,
-                    chainedEntries: 0,
-                    legacyEntries: 0,
-                    errors: [{ lineNumber: 0, reason: 'unreadable', detail: 'audit verification failed to run' }],
-                }));
-            }
-            return;
-        }
-        // P18 slice 3 — permissions read/write surface. Lets the future
-        // dashboard panel (when a hook block fires) call "Approve in this
-        // folder" without shelling out. The CLI command and this endpoint
-        // both call addPermissionEntry → single source of truth.
-        if (req.method === 'GET' && req.url?.startsWith('/api/permissions?')) {
-            const cwd = decodeURIComponent(req.url.split('cwd=')[1] || '');
-            if (!cwd || !isAbsolute(cwd)) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'cwd query param required (absolute path)' }));
-                return;
-            }
-            try {
-                const cfg = loadPermissions(cwd);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ cwd, permissions: cfg }));
-            }
-            catch {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ cwd, permissions: { allow: [], deny: [] } }));
-            }
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/api/permissions') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(body || '{}');
-                    }
-                    catch (e) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                        return;
-                    }
-                    const cwd = parsed.cwd;
-                    const pattern = parsed.pattern;
-                    const bucket = parsed.bucket === 'deny' ? 'deny' : 'allow';
-                    if (!cwd || typeof cwd !== 'string' || !isAbsolute(cwd) || cwd.includes('\0')) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'cwd must be an absolute path with no NUL bytes' }));
-                        return;
-                    }
-                    if (!pattern || typeof pattern !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'pattern (non-empty string) required' }));
-                        return;
-                    }
-                    try {
-                        const result = addPermissionEntry({ cwd, pattern, bucket, reason: parsed.reason });
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify(result));
-                    }
-                    catch (e) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'write_failed', detail: String(e?.message || e) }));
-                    }
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // Ship-readiness scan — run gitleaks + semgrep on a folder, return the prioritized findings.
-        // Deterministic, no model tokens. Powers the home's "is your app safe to ship?" hook.
-        if (req.method === 'POST' && req.url === '/api/scan') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(body || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON body' }));
-                        return;
-                    }
-                    const dir = resolvePath(String(parsed.dir || '.'));
-                    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: `Not a folder on this machine: ${dir}` }));
-                        return;
-                    }
-                    const result = shipScan(dir);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(result));
-                }
-                catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'scan_failed', detail: String(e?.message || e) }));
-                }
-            })();
-            return;
-        }
-        // Fix + prove closed — for now the deterministic exposed-secret fix (move out of code, re-verify).
-        if (req.method === 'POST' && req.url === '/api/fix') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(body || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, message: 'Invalid JSON body' }));
-                        return;
-                    }
-                    const dir = resolvePath(String(parsed.dir || '.'));
-                    if (!existsSync(dir) || !statSync(dir).isDirectory()) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, message: `Not a folder on this machine: ${dir}` }));
-                        return;
-                    }
-                    // Stream progress: the AI code-fix can take a few minutes, so we send live steps over SSE
-                    // instead of leaving the browser frozen on "Fixing…". The final 'done' event carries the result.
-                    res.writeHead(200, {
-                        'Content-Type': 'text/event-stream',
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                        'X-Accel-Buffering': 'no',
-                    });
-                    res.flushHeaders?.();
-                    res.socket?.setNoDelay?.(true);
-                    const send = (obj) => {
-                        try {
-                            res.write(`data: ${JSON.stringify(obj)}\n\n`);
-                        }
-                        catch {
-                            /* client gone — the fix still runs to completion */
-                        }
-                    };
-                    // Yield a tick after each send so the chunk actually leaves the socket before the next
-                    // synchronous scanner (spawnSync) blocks the event loop — otherwise it all flushes at the end.
-                    const flush = () => new Promise((r) => setImmediate(r));
-                    send({ type: 'step', label: 'Looking at your code' });
-                    await flush();
-                    // Route by the top finding: a leaked secret → deterministic move-out (instant, no spend);
-                    // a code danger → AI fix + re-scan proof (uses the Claude Code subscription).
-                    const scan = shipScan(dir);
-                    const top = scan.top;
-                    let result;
-                    if (!top) {
-                        result = { ok: false, provenClosed: false, message: 'No ship-blockers found — nothing to fix.' };
-                    }
-                    else if (top.tool === 'gitleaks') {
-                        send({ type: 'step', label: 'Moving the secret out of your code' });
-                        result = fixExposedSecret(dir);
-                    }
-                    else {
-                        result = await fixCodeVuln(dir, top, (label) => send({ type: 'step', label }));
-                    }
-                    send({ type: 'done', result });
-                    res.end();
-                }
-                catch (e) {
-                    // If the SSE stream already started, headers are sent — emit a done event instead of a new header.
-                    if (res.headersSent) {
-                        try {
-                            res.write(`data: ${JSON.stringify({ type: 'done', result: { ok: false, provenClosed: false, message: 'fix_failed', detail: String(e?.message || e) } })}\n\n`);
-                        }
-                        catch {
-                            /* best effort */
-                        }
-                        res.end();
-                    }
-                    else {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, message: 'fix_failed', detail: String(e?.message || e) }));
-                    }
-                }
-            })();
-            return;
-        }
-        if (req.method === 'DELETE' && req.url?.startsWith('/api/permissions?')) {
-            const params = new URLSearchParams(req.url.split('?')[1] || '');
-            const cwd = params.get('cwd') || '';
-            const pattern = params.get('pattern') || '';
-            if (!cwd || !isAbsolute(cwd) || !pattern) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'cwd (absolute) + pattern query params required' }));
-                return;
-            }
-            try {
-                const result = removePermissionEntry(cwd, pattern);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(result));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'remove_failed', detail: String(e?.message || e) }));
-            }
-            return;
-        }
-        // Pattern 20 — hook-mode indicator. Read-only by design; mode
-        // switching goes through `codehere hook install/uninstall` so the
-        // safety surface re-validates. Cheap (one settings.json parse);
-        // safe to poll from the dashboard header at 30s cadence.
-        if (req.method === 'GET' && req.url === '/api/hook/mode') {
-            let mode;
-            try {
-                mode = getHookMode();
-            }
-            catch {
-                mode = 'off';
-            }
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ mode }));
-            return;
-        }
-        // ── Gate B3 · Audit summary (moat visible on main page) ───────────────────
-        // Principle #3 status-at-a-glance + #7 agent-provenance. Reads the hook audit
-        // log's last 24h, aggregates: how many actions fired across all agents, how
-        // many codehere blocked, mean trust (= 100 - mean riskScore).
-        if (req.method === 'GET' && req.url === '/api/audit/summary') {
-            const windowMs = 24 * 60 * 60 * 1000;
-            const cutoff = Date.now() - windowMs;
-            let actions = 0, blocked = 0, riskSum = 0, riskN = 0;
-            const sessionIds = new Set();
-            try {
-                if (existsSync(AUDIT_FILE)) {
-                    const content = readFileSync(AUDIT_FILE, 'utf-8');
-                    const lines = content.split('\n');
-                    // Walk backwards; stop at first line older than cutoff (log is append-chronological)
-                    for (let i = lines.length - 1; i >= 0; i--) {
-                        const line = lines[i].trim();
-                        if (!line)
-                            continue;
-                        let entry;
-                        try {
-                            entry = JSON.parse(line);
-                        }
-                        catch {
-                            continue;
-                        }
-                        const ts = typeof entry.timestamp === 'number'
-                            ? entry.timestamp
-                            : entry.timestamp
-                                ? Date.parse(String(entry.timestamp))
-                                : 0;
-                        if (!ts || ts < cutoff)
-                            break;
-                        actions += 1;
-                        if (entry.blocked)
-                            blocked += 1;
-                        if (typeof entry.riskScore === 'number') {
-                            riskSum += entry.riskScore;
-                            riskN += 1;
-                        }
-                        if (entry.sessionId)
-                            sessionIds.add(entry.sessionId);
-                    }
-                }
-            }
-            catch {
-                /* empty audit — zeros are fine */
-            }
-            const avgTrust = riskN > 0 ? Math.max(0, Math.round(100 - riskSum / riskN)) : null;
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                windowHours: 24,
-                actions,
-                blocked,
-                agents: sessionIds.size,
-                avgTrust,
-            }));
-            return;
-        }
-        // ── Host sessions — the coding-agent CLIs codehere observes via the hook ──
-        // These are NOT spawned-by-codehere agents (those live in /api/tasks). These
-        // are the Claude Code / Codex / etc. sessions running in the user's own
-        // terminal, captured by the PreToolUse hook. This is the surface that proves
-        // the INWARD axis: every coding agent — including the one the user is talking
-        // to right now — is a first-class workspace member, not a black box.
-        if (req.method === 'GET' && req.url === '/api/host-sessions') {
-            const entries = [];
-            try {
-                if (existsSync(AUDIT_FILE)) {
-                    const lines = readFileSync(AUDIT_FILE, 'utf-8').split('\n');
-                    for (const line of lines) {
-                        const t = line.trim();
-                        if (!t)
-                            continue;
-                        try {
-                            const e = JSON.parse(t);
-                            if (e && typeof e.sessionId === 'string')
-                                entries.push(e);
-                        }
-                        catch {
-                            /* skip malformed line */
-                        }
-                    }
-                }
-            }
-            catch {
-                /* empty audit — empty list is fine */
-            }
-            // Only surface genuine host coding sessions — not seed fixtures or the
-            // synthetic WritePass/pre_prompt audit rows. isRealHostSession() requires
-            // a real coding tool + 48h recency. Without it the strip would claim
-            // "10 sessions running" when 9 are stale demo artifacts — the screen-lie
-            // the no-screen-lies rule bans.
-            const now = Date.now();
-            const sessions = analyzeSessions(entries)
-                .filter((s) => s.sessionId !== 'unknown')
-                .filter((s) => isRealHostSession(s, now))
-                .sort((a, b) => new Date(b.lastSeen).getTime() - new Date(a.lastSeen).getTime())
-                .slice(0, 10)
-                .map((s) => ({
-                sessionId: s.sessionId,
-                shortId: s.sessionId.substring(0, 8),
-                totalCalls: s.totalCalls,
-                blockedCalls: s.blockedCalls,
-                criticalCalls: s.criticalCalls,
-                durationMs: s.durationMs,
-                lastSeen: s.lastSeen,
-                risk: s.amplificationRisk,
-                toolMix: s.toolMix,
-            }));
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ sessions, total: sessions.length }));
-            return;
-        }
-        // ── Host session as a THREAD — full tool-call timeline for one observed ──
-        // session. This is the meta-dogfood payoff: open the coding-agent session
-        // running in your terminal and see every call codehere scanned, in order,
-        // hash-chained. GET /api/host-sessions/:id
-        const hostDetailMatch = req.url?.match(/^\/api\/host-sessions\/([^/?]+)$/);
-        if (req.method === 'GET' && hostDetailMatch) {
-            const wantId = decodeURIComponent(hostDetailMatch[1]);
-            // Group matching entries by their FULL session id, then resolve to ONE
-            // session. The strip links with an 8-char short id; if two sessions share
-            // that prefix, a naive startsWith() would merge their timelines into a
-            // single bogus session. Grouping + resolving keeps each session distinct.
-            const bySession = new Map();
-            const lastTs = new Map();
-            try {
-                if (existsSync(AUDIT_FILE)) {
-                    const lines = readFileSync(AUDIT_FILE, 'utf-8').split('\n');
-                    for (const line of lines) {
-                        const t = line.trim();
-                        if (!t)
-                            continue;
-                        let e;
-                        try {
-                            e = JSON.parse(t);
-                        }
-                        catch {
-                            continue;
-                        }
-                        const sid = e.sessionId;
-                        if (!sid || (sid !== wantId && !sid.startsWith(wantId)))
-                            continue;
-                        // Plain-English preview: the bash command or the file path, never
-                        // the full JSON blob. Persona-facing surface, not a log dump.
-                        const preview = previewFromToolInput(e.toolInput);
-                        const call = {
-                            timestamp: e.timestamp,
-                            toolName: e.toolName,
-                            riskScore: e.riskScore ?? 0,
-                            blocked: !!e.blocked,
-                            findings: e.findings ?? 0,
-                            criticalFindings: e.criticalFindings ?? 0,
-                            seq: e.seq,
-                            chained: typeof e.entryHash === 'string' && e.entryHash.length > 0,
-                            preview,
-                        };
-                        if (!bySession.has(sid))
-                            bySession.set(sid, []);
-                        bySession.get(sid).push(call);
-                        const ts = e.timestamp ? Date.parse(e.timestamp) : 0;
-                        if (Number.isFinite(ts) && ts > (lastTs.get(sid) ?? 0))
-                            lastTs.set(sid, ts);
-                    }
-                }
-            }
-            catch {
-                /* empty / unreadable audit — empty timeline is honest */
-            }
-            // Resolve to one session: an exact full-id match wins; otherwise the most
-            // recently active session carrying the prefix. We never merge two.
-            let resolvedId;
-            if (bySession.has(wantId)) {
-                resolvedId = wantId;
-            }
-            else if (bySession.size >= 1) {
-                resolvedId = [...bySession.keys()].sort((a, b) => (lastTs.get(b) ?? 0) - (lastTs.get(a) ?? 0))[0];
-            }
-            const calls = resolvedId ? bySession.get(resolvedId) : [];
-            if (calls.length === 0) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'No observed session matching ' + wantId }));
-                return;
-            }
-            calls.sort((a, b) => new Date(String(a.timestamp)).getTime() - new Date(String(b.timestamp)).getTime());
-            const chain = verifyAuditChain(AUDIT_FILE);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                sessionId: resolvedId ?? wantId,
-                calls,
-                totalCalls: calls.length,
-                blockedCalls: calls.filter((c) => c.blocked).length,
-                criticalCalls: calls.filter((c) => c.criticalFindings > 0).length,
-                // Same rule as /api/audit/verify: an empty chain walks clean, so validity is only
-                // meaningful once there is something to walk. The panel needs the third state to
-                // say "nothing recorded yet" instead of picking between verified and broken.
-                chainValid: chain.totalEntries > 0 && chain.valid,
-                chainVerifiable: chain.totalEntries > 0,
-                chainEntries: chain.chainedEntries,
-            }));
-            return;
-        }
-        // ── Remote control · drive a running agent from the web ───────────────
-        // POST /api/control/open  { agent, prompt } → opens a ControlSurface, starts
-        //   a thread + initial turn, returns { controlId, threadId }.
-        // POST /api/control/:id/inject  { message } → turn/steer into the running
-        //   turn (the remote-control primitive).
-        // GET  /api/control/:id/events → what the driven agent emitted.
-        // Same-origin only (mutating). Under CODEHERE_MOCK=1 the surface drives the
-        // mock app-server — zero API, no rate-limit.
-        if (req.method === 'POST' && req.url === '/api/control/open') {
-            (async () => {
-                try {
-                    const raw = JSON.parse((await readBody(req, res)) || '{}');
-                    const agent = String(raw.agent ?? 'codex');
-                    const prompt = String(raw.prompt ?? '').trim();
-                    if (!prompt) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'prompt required' }));
-                        return;
-                    }
-                    if (agent !== 'codex') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'only codex control surface is wired today' }));
-                        return;
-                    }
-                    const surface = new CodexControlSurface();
-                    const controlId = 'ctrl-' + ++controlSeq;
-                    const entry = { surface, agent, threadId: '', events: [], openedAt: Date.now() };
-                    surface.onEvent((e) => entry.events.push(e));
-                    controlSessions.set(controlId, entry);
-                    const { threadId } = await surface.open(prompt);
-                    entry.threadId = threadId;
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ controlId, threadId, agent }));
-                }
-                catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'control open failed: ' + e.message }));
-                }
-            })();
-            return;
-        }
-        const ctlInject = req.url?.match(/^\/api\/control\/([^/]+)\/inject$/);
-        if (req.method === 'POST' && ctlInject) {
-            (async () => {
-                const entry = controlSessions.get(decodeURIComponent(ctlInject[1]));
-                if (!entry) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'no such control session' }));
-                    return;
-                }
-                try {
-                    const raw = JSON.parse((await readBody(req, res)) || '{}');
-                    const message = String(raw.message ?? '').trim();
-                    if (!message) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'message required' }));
-                        return;
-                    }
-                    const r = await entry.surface.inject(message);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ accepted: r.accepted }));
-                }
-                catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'inject failed: ' + e.message }));
-                }
-            })();
-            return;
-        }
-        const ctlEvents = req.url?.match(/^\/api\/control\/([^/]+)\/events$/);
-        if (req.method === 'GET' && ctlEvents) {
-            const entry = controlSessions.get(decodeURIComponent(ctlEvents[1]));
-            if (!entry) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'no such control session' }));
-                return;
-            }
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ threadId: entry.threadId, agent: entry.agent, events: entry.events }));
-            return;
-        }
-        // ── User override · a human reviewed a block and chose to proceed ──────
-        // POST /api/audit/override · body { sessionId, toolName, reason }. Appends
-        // a 'user_override' entry with the free-text reason to the hash chain and
-        // returns the new entry's seq + short hash, so the UI can show "logged ·
-        // chain continues <hash>" with the REAL hash, not a mockup. Same-origin
-        // only (mutating · not in the CORS read-only list).
-        // (helper for the append route) last-10-lines tail scan by identity tuple.
-        function findRecentAuditSeq(sessionId, toolName, timestamp) {
-            try {
-                if (!existsSync(AUDIT_FILE))
-                    return null;
-                const lines = readFileSync(AUDIT_FILE, 'utf-8').trim().split('\n');
-                for (let i = lines.length - 1; i >= 0 && i >= lines.length - 10; i--) {
-                    try {
-                        const e = JSON.parse(lines[i]);
-                        if (e.sessionId === sessionId && e.toolName === toolName && e.timestamp === timestamp) {
-                            return typeof e.seq === 'number' ? e.seq : null;
-                        }
-                    }
-                    catch {
-                        /* skip malformed */
-                    }
-                }
-            }
-            catch {
-                /* unreadable → no match */
-            }
-            return null;
-        }
-        // R1.1 · the daemon as sole audit writer — append endpoint. Loopback-bound
-        // (the server binds 127.0.0.1 by default). Accepts ONLY the pre-chain entry
-        // shape; chain position (seq/prevHash/entryHash) is the DAEMON'S to compute —
-        // a caller supplying any chain field is rejected outright, so an entry
-        // cannot be forge-positioned VIA THIS ENDPOINT (direct file access by the
-        // same uid is R1.2/R1.3's territory). Marks writer:'daemon'. Mirrors
-        // the override route's no-screen-lies rule: success is claimed only after
-        // the entry is CONFIRMED on disk (appendAuditLog is fail-open by design).
-        if (req.method === 'POST' && req.url === '/api/audit/append') {
-            (async () => {
-                try {
-                    const text = await readBody(req, res);
-                    let raw;
-                    try {
-                        raw = JSON.parse(text || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid JSON' }));
-                        return;
-                    }
-                    if (typeof raw.auditFile === 'string' && raw.auditFile !== AUDIT_FILE) {
-                        // The caller records into a different audit file than this daemon —
-                        // we are not its recorder. 409 so the hook falls back to a direct
-                        // write into its own chain (R1.2 honest-routing invariant).
-                        res.writeHead(409, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'this daemon records a different audit file' }));
-                        return;
-                    }
-                    delete raw.auditFile; // accepted — not part of the entry shape
-                    if ('seq' in raw || 'prevHash' in raw || 'entryHash' in raw || 'writer' in raw) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'chain position and writer provenance are computed by the daemon — do not supply seq/prevHash/entryHash/writer',
-                        }));
-                        return;
-                    }
-                    if (typeof raw.sessionId !== 'string' ||
-                        !raw.sessionId ||
-                        typeof raw.toolName !== 'string' ||
-                        !raw.toolName) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'sessionId and toolName are required strings' }));
-                        return;
-                    }
-                    const entry = {
-                        timestamp: typeof raw.timestamp === 'string' && raw.timestamp ? raw.timestamp : new Date().toISOString(),
-                        sessionId: raw.sessionId,
-                        toolName: raw.toolName,
-                        toolInput: typeof raw.toolInput === 'string'
-                            ? raw.toolInput.slice(0, 2000)
-                            : JSON.stringify(raw.toolInput ?? {}).slice(0, 2000),
-                        riskScore: typeof raw.riskScore === 'number' && Number.isFinite(raw.riskScore) ? raw.riskScore : 0,
-                        blocked: raw.blocked === true,
-                        findings: typeof raw.findings === 'number' && Number.isFinite(raw.findings) ? raw.findings : 0,
-                        criticalFindings: typeof raw.criticalFindings === 'number' && Number.isFinite(raw.criticalFindings)
-                            ? raw.criticalFindings
-                            : 0,
-                        // Override provenance is legitimate hook data (R1.2 routes the
-                        // hook's bypass-path entries here) — enum-validated, never free-form.
-                        ...(typeof raw.overrideReason === 'string' &&
-                            [
-                                'stdin_read_failure',
-                                'event_parse_failure',
-                                'scan_exception',
-                                'log_only_mode',
-                                'user_override',
-                                'audit_write_failure',
-                            ].includes(raw.overrideReason)
-                            ? { overrideReason: raw.overrideReason }
-                            : {}),
-                        ...(typeof raw.overrideNote === 'string' && raw.overrideNote.trim()
-                            ? { overrideNote: raw.overrideNote.trim().slice(0, 500) }
-                            : {}),
-                        writer: 'daemon',
-                    };
-                    // Idempotency: a hook may retry after a client-side abort even though
-                    // this daemon already wrote the entry — same (timestamp, sessionId,
-                    // toolName) in the tail means it's already recorded; return its seq
-                    // instead of minting a duplicate row (refuter-demonstrated risk).
-                    const dupSeq = findRecentAuditSeq(entry.sessionId, entry.toolName, entry.timestamp);
-                    if (dupSeq !== null) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, seq: dupSeq, idempotent: true }));
-                        return;
-                    }
-                    appendAuditLogDirect(entry);
-                    // Confirm on disk before claiming success (append is fail-open).
-                    let seq = null;
-                    try {
-                        const lines = readFileSync(AUDIT_FILE, 'utf-8').trim().split('\n');
-                        for (let i = lines.length - 1; i >= 0 && i >= lines.length - 10; i--) {
-                            const e = JSON.parse(lines[i]);
-                            if (e.sessionId === entry.sessionId && e.toolName === entry.toolName && e.timestamp === entry.timestamp) {
-                                seq = typeof e.seq === 'number' ? e.seq : null;
-                                break;
-                            }
-                        }
-                    }
-                    catch {
-                        /* unreadable → unconfirmed */
-                    }
-                    if (seq === null) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'append could not be confirmed on disk' }));
-                        return;
-                    }
-                    // R1.3 · sign-at-write: every daemon append advances the signed tip,
-                    // so the protected prefix grows per WRITE, not per session-completion.
-                    // ed25519 sign is sub-ms; fail-open (signing never breaks the append).
-                    signAuditTip(AUDIT_FILE);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, seq }));
-                }
-                catch (err) {
-                    // readBody may have already 413'd the response before rejecting —
-                    // re-writing headers then would crash embedded callers with
-                    // ERR_HTTP_HEADERS_SENT (refuter caveat c; the /api/permissions
-                    // route's pattern).
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
-                    }
-                }
-            })();
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/api/audit/override') {
-            (async () => {
-                try {
-                    const text = await readBody(req, res);
-                    let raw;
-                    try {
-                        raw = JSON.parse(text || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid JSON' }));
-                        return;
-                    }
-                    const reason = String(raw.reason ?? '').trim();
-                    if (!reason) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'a reason is required to log an override' }));
-                        return;
-                    }
-                    // A failed-task recovery acknowledgement is NOT a security override —
-                    // record it as its own reason so an audit reader can't conflate the
-                    // two (refuter caveat). Default stays user_override.
-                    const reasonType = raw.reasonType === 'recovery_ack' ? 'recovery_ack' : 'user_override';
-                    appendOverrideAudit(reasonType, {
-                        sessionId: typeof raw.sessionId === 'string' ? raw.sessionId : 'unknown',
-                        toolName: typeof raw.toolName === 'string' ? raw.toolName : 'unknown',
-                        note: reason,
-                    });
-                    // appendOverrideAudit → appendAuditLog is fail-open: it swallows
-                    // write errors so a logging failure never blocks a tool call. That's
-                    // right for the hook, but here the UI shows "✓ override logged", so
-                    // we must CONFIRM our entry actually landed before claiming success
-                    // (no screen-lies). Scan the tail backward for our exact entry — a
-                    // concurrent hook process may have appended after ours, so it isn't
-                    // guaranteed to be the very last line.
-                    const wantSid = typeof raw.sessionId === 'string' ? raw.sessionId : 'unknown';
-                    const wantNote = reason.slice(0, 500);
-                    let seq = null;
-                    let entryHash = '';
-                    let confirmed = false;
-                    try {
-                        const lines = readFileSync(AUDIT_FILE, 'utf-8').trim().split('\n');
-                        for (let i = lines.length - 1; i >= 0 && i >= lines.length - 10; i--) {
-                            let e;
-                            try {
-                                e = JSON.parse(lines[i]);
-                            }
-                            catch {
-                                continue;
-                            }
-                            // S6 · match the reasonType we just wrote — a recovery ack is
-                            // recorded as 'recovery_ack', and matching only 'user_override'
-                            // made the readback miss it: the entry landed but the user was
-                            // told "could not be confirmed".
-                            if (e.overrideReason === reasonType && e.sessionId === wantSid && e.overrideNote === wantNote) {
-                                seq = typeof e.seq === 'number' ? e.seq : null;
-                                entryHash = typeof e.entryHash === 'string' ? e.entryHash : '';
-                                confirmed = true;
-                                break;
-                            }
-                        }
-                    }
-                    catch {
-                        /* readback failed — cannot confirm the write landed */
-                    }
-                    if (!confirmed) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'override could not be confirmed in the audit log' }));
-                        return;
-                    }
-                    // S3 · mirror a confirmed recovery ack into task state so the
-                    // resolved badge survives reload (the chain entry alone is not
-                    // what the recovery card re-renders from).
-                    if (reasonType === 'recovery_ack' && typeof raw.sessionId === 'string') {
-                        const resolvedAt = Date.now();
-                        appendResolved({ id: raw.sessionId, resolvedAt });
-                        SessionManager.getInstance().markPersistedResolved(raw.sessionId, resolvedAt);
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        ok: true,
-                        seq,
-                        entryHash,
-                        shortHash: entryHash ? entryHash.slice(0, 4) + '...' + entryHash.slice(-4) : '',
-                    }));
-                }
-                catch {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'override failed' }));
-                }
-            })();
-            return;
-        }
-        // ── F1 · Agent install (zero-terminal setup — principle #10) ──────────────
-        // POST /api/agents/:id/install → SSE stream of install output.
-        // The command comes from the adapter's checkReadiness().installHint — never
-        // from the user over the wire. codehere is the thing that runs the install,
-        // not a page that tells the user how to run it.
-        const installMatch = req.url?.match(/^\/api\/agents\/([a-z0-9-]+)\/install$/i);
-        if (req.method === 'POST' && installMatch) {
-            const adapterId = installMatch[1];
-            const adapter = getAdapter(adapterId);
-            if (!adapter) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: `No such agent: ${adapterId}` }));
-                return;
-            }
-            const session = installAgent(adapter);
-            if (!session) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Agent already installed or has no install hint' }));
-                return;
-            }
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            });
-            const unsubscribe = session.subscribe((evt) => {
-                res.write(`data: ${JSON.stringify(evt)}\n\n`);
-            });
-            const ping = setInterval(() => res.write(': ping\n\n'), 15000);
-            req.on('close', () => {
-                clearInterval(ping);
-                unsubscribe();
-            });
-            return;
-        }
-        // ── E2 · Per-agent readiness (onboarding surface) ─────────────────────────
-        // Full registry snapshot: install state + auth state + hints. Powers the
-        // setup-aware agent dropdown and the one-click swap flow on auth errors.
-        //
-        // Apr 29: Conductor moved to a separate `auto` field. The web UI IS the
-        // Conductor surface — exposing "conductor" as a peer in the agents array
-        // is the "Gmail asks you to pick 'email' before composing" anti-pattern.
-        // But Conductor's readiness state IS the Auto option's readiness, so the
-        // UI needs it preserved (codex Round 1 caught: fresh install with no
-        // specialists installed would otherwise lose the setup prompt — Auto
-        // gets selected by default, submission fails at /api/task because
-        // conductor.isInstalled() returns false). The separate `auto` field
-        // keeps the setup hint plumbing intact while preventing the dropdown
-        // from showing Conductor as a peer choice.
-        if (req.method === 'GET' && req.url === '/api/readiness/agents') {
-            try {
-                const all = readinessForAllAgents();
-                const auto = all.find((a) => a.id === 'conductor');
-                const agents = all.filter((a) => a.id !== 'conductor');
-                // v0.6.0 M8 — surface cross-tool agent definitions (.opencode/agents/,
-                // .claude/agents/, .codehere/agents/) alongside the built-in adapters.
-                // These don't have a `state` (ready/needs_install) — they're definitions
-                // not runtimes. UI can render them as "available specialists" tagged
-                // with their source format. Best-effort: failures fall back to no
-                // cross-tool agents listed.
-                let crossTool = [];
-                try {
-                    const result = readCrossToolAgents(process.cwd());
-                    crossTool = result.agents.map((a) => ({
-                        name: a.name,
-                        description: a.description.length > 240 ? a.description.slice(0, 237) + '…' : a.description,
-                        sourceFormat: a.sourceFormat,
-                        mode: a.mode,
-                        sourcePath: a.sourcePath,
-                    }));
-                }
-                catch {
-                    // best-effort; ignore parse failures
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ agents, auto, crossTool }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'readiness_check_failed', detail: String(e) }));
-            }
-            return;
-        }
-        // ── v0.6 S3 — spend-today aggregator + budget state ──────────────────────
-        // GET /api/spend/today — read-only aggregate of today's estimated USD spend
-        // plus budget config (slice 2: dailyUsd, pctUsed, over). Powers the
-        // dashboard's "spent today" pill + budget warn/block colors. Per
-        // claim_market_position v3 capture-strategy edge "cost-bounded execution":
-        // this is the read surface; the actual block happens at /api/task spawn.
-        if (req.method === 'GET' && req.url === '/api/spend/today') {
-            try {
-                const spend = computeSpendToday();
-                const budget = loadBudget();
-                const pctUsed = budgetUsedPct(spend.totalUsd, budget);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    ...spend,
-                    budget: {
-                        dailyUsd: budget.dailyUsd,
-                        warnAtPct: budget.warnAtPct,
-                        pctUsed,
-                        over: isOverBudget(spend.totalUsd, budget),
-                    },
-                }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'spend_today_failed', detail: String(e) }));
-            }
-            return;
-        }
-        // GET /api/team — merged team cost+audit ledger for the dashboard hero.
-        // Refreshes THIS machine's snapshot in the team dir (no git push; the CLI
-        // `codehere team` is the active pull/push), then merges every machine's
-        // snapshot. Read-only of the network: nothing leaves the box, the merge is
-        // from the team's own dir. { configured:false } when no team dir is set.
-        if (req.method === 'GET' && req.url === '/api/team') {
-            try {
-                const cfg = loadTeamConfig();
-                if (!cfg.dir) {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ configured: false }));
-                    return;
-                }
-                try {
-                    writeMyShare(cfg.dir); // refresh this machine's live numbers; best-effort
-                }
-                catch {
-                    /* dir not writable (e.g. missing) — still try to read what's there */
-                }
-                const view = buildTeamView(cfg.dir, cfg.dailyUsd);
-                recordOpenOncePerDay(); // discovery outcome: the lead opened the shared record (deduped per day, best-effort)
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ configured: true, dir: cfg.dir, recruitUrl: recruitUrl(), ...view }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'team_view_failed', detail: String(e) }));
-            }
-            return;
-        }
-        // GET /api/discovery/summary — the continuous-discovery outcome (record-open
-        // behaviour) read back for the weekly cadence. Read-only, local.
-        if (req.method === 'GET' && req.url === '/api/discovery/summary') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(discoverySummary()));
-            return;
-        }
-        // POST /api/team/init { dir? } — create a team from the dashboard: make +
-        // git-init a shared dir, point at it, write the first snapshot. Same core as
-        // `codehere team init`. Local-first: nothing leaves the box.
-        if (req.method === 'POST' && req.url === '/api/team/init') {
-            (async () => {
-                try {
-                    const raw = await readBody(req, res);
-                    let parsed = {};
-                    try {
-                        parsed = JSON.parse(raw || '{}');
-                    }
-                    catch {
-                        /* empty/invalid body → default dir */
-                    }
-                    const rawDir = parsed.dir && String(parsed.dir).trim();
-                    // "undefined"/"null" are client-bug tripwires, not paths — a Jul-1
-                    // client sent one and six days of shares landed in a cwd-relative
-                    // agent/undefined/. Relative inputs resolve to absolute here.
-                    if (rawDir === 'undefined' || rawDir === 'null') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'dir_invalid',
-                            dir: rawDir,
-                            message: 'That dir looks unset (the literal string "' +
-                                rawDir +
-                                '"). Send a real path or omit dir for the default.',
-                        }));
-                        return;
-                    }
-                    const dir = rawDir ? resolvePath(rawDir) : join(codehereHome(), 'team-shared');
-                    initTeamDir(dir);
-                    const cfg = loadTeamConfig();
-                    cfg.dir = dir;
-                    saveTeamConfig(cfg);
-                    try {
-                        writeMyShare(dir);
-                    }
-                    catch {
-                        /* best-effort first snapshot */
-                    }
-                    const view = buildTeamView(dir, cfg.dailyUsd);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ configured: true, dir, ...view }));
-                }
-                catch (e) {
-                    // readBody may have already sent 413 + ended on an oversized body —
-                    // guard so we don't double-write headers (otherwise process-fatal).
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'team_init_failed', detail: String(e?.message || e) }));
-                    }
-                }
-            })();
-            return;
-        }
-        // POST /api/team/set-dir { dir } — point at an EXISTING shared team dir (a
-        // member who cloned the team repo, or a lead pointing at a shared drive).
-        if (req.method === 'POST' && req.url === '/api/team/set-dir') {
-            (async () => {
-                try {
-                    const raw = await readBody(req, res);
-                    let parsed = {};
-                    try {
-                        parsed = JSON.parse(raw || '{}');
-                    }
-                    catch {
-                        /* fall through to validation */
-                    }
-                    const rawDir = parsed.dir ? String(parsed.dir).trim() : '';
-                    if (!rawDir || rawDir === 'undefined' || rawDir === 'null') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'dir_required',
-                            message: 'Provide { dir } — the shared team folder.' +
-                                (rawDir ? ' (got the literal string "' + rawDir + '" — a client-side unset variable)' : ''),
-                        }));
-                        return;
-                    }
-                    const dir = resolvePath(rawDir); // relative input would pin the record to a cwd
-                    if (!existsSync(dir)) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'dir_not_found',
-                            dir,
-                            message: 'That folder does not exist. Clone the team repo first, or use /api/team/init.',
-                        }));
-                        return;
-                    }
-                    const cfg = loadTeamConfig();
-                    cfg.dir = dir;
-                    saveTeamConfig(cfg);
-                    try {
-                        writeMyShare(dir);
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                    const view = buildTeamView(dir, cfg.dailyUsd);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ configured: true, dir, ...view }));
-                }
-                catch (e) {
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'team_setdir_failed', detail: String(e?.message || e) }));
-                    }
-                }
-            })();
-            return;
-        }
-        // POST /api/github/connect/start — begin the OAuth device flow. Returns the
-        // user code + verification URL to show the user; the deviceCode round-trips
-        // back on /poll (server stays stateless). Needs codehere's GitHub OAuth App
-        // client_id (CODEHERE_GITHUB_CLIENT_ID); no secret, local-first.
-        if (req.method === 'POST' && req.url === '/api/github/connect/start') {
-            (async () => {
-                const clientId = githubClientId();
-                if (!clientId) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        error: 'github_not_configured',
-                        message: "GitHub isn't set up yet: set CODEHERE_GITHUB_CLIENT_ID to codehere's OAuth App client id.",
-                    }));
-                    return;
-                }
-                try {
-                    const dc = await requestDeviceCode(clientId);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        userCode: dc.userCode,
-                        verificationUri: dc.verificationUri,
-                        deviceCode: dc.deviceCode,
-                        intervalSec: dc.intervalSec,
-                        expiresInSec: dc.expiresInSec,
-                    }));
-                }
-                catch (e) {
-                    res.writeHead(502, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_device_code_failed', detail: String(e?.message || e) }));
-                }
-            })();
-            return;
-        }
-        // POST /api/github/connect/poll {deviceCode} — poll once for the token. On
-        // success the token is persisted under 'github' via oauth-store. The client
-        // repeats at intervalSec until status is connected or error.
-        if (req.method === 'POST' && req.url === '/api/github/connect/poll') {
-            (async () => {
-                const clientId = githubClientId();
-                if (!clientId) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_not_configured' }));
-                    return;
-                }
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(body || '{}');
-                    }
-                    catch (e) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                        return;
-                    }
-                    const deviceCode = parsed.deviceCode;
-                    if (!deviceCode || typeof deviceCode !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'deviceCode (string) required' }));
-                        return;
-                    }
-                    const outcome = await pollForToken(clientId, deviceCode);
-                    if (outcome.status === 'connected') {
-                        saveToken(outcome.token);
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(outcome.status === 'connected' ? { status: 'connected', scope: outcome.token.scope } : outcome));
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] github poll readBody rejected');
-                }
-            })();
-            return;
-        }
-        // POST /api/github/issue-to-task {ref} | {repo, issueNumber} — fetch the
-        // issue via the stored token and return a ready task prompt + issue metadata.
-        // The client spawns it through the existing POST /api/task (one proven path).
-        if (req.method === 'POST' && req.url === '/api/github/issue-to-task') {
-            (async () => {
-                const tok = loadToken('github');
-                if (!tok?.accessToken) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_not_connected', message: 'Connect GitHub first.' }));
-                    return;
-                }
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(body || '{}');
-                    }
-                    catch (e) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                        return;
-                    }
-                    const refStr = parsed.ref || (parsed.repo && parsed.issueNumber ? `${parsed.repo}#${parsed.issueNumber}` : '');
-                    const ref = parseRepoRef(refStr);
-                    if (!ref || ref.number === undefined) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: 'bad_ref',
-                            message: 'Provide ref ("owner/repo#123" or an issue URL) or repo + issueNumber.',
-                        }));
-                        return;
-                    }
-                    const issue = await fetchIssue(tok.accessToken, ref.owner, ref.repo, ref.number);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ prompt: issueToTaskPrompt(issue), issue }));
-                }
-                catch (e) {
-                    res.writeHead(502, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_issue_fetch_failed', detail: String(e?.message || e) }));
-                }
-            })();
-            return;
-        }
-        // POST /api/github/post-result {text|ref, body} — comment the agent's result
-        // back on the source GitHub issue. ref ("owner/repo#123") OR text (the task
-        // prompt, from which the issue link is parsed). Non-destructive (no branches).
-        if (req.method === 'POST' && req.url === '/api/github/post-result') {
-            (async () => {
-                const tok = loadToken('github');
-                if (!tok?.accessToken) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_not_connected', message: 'Connect GitHub first.' }));
-                    return;
-                }
-                try {
-                    const raw = await readBody(req, res);
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(raw || '{}');
-                    }
-                    catch (e) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                        return;
-                    }
-                    const ref = parsed.ref ? parseRepoRef(parsed.ref) : issueRefFromText(parsed.text || '');
-                    if (!ref || ref.number === undefined) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'no_issue_ref', message: 'No GitHub issue found in ref/text.' }));
-                        return;
-                    }
-                    const comment = (parsed.body || '').trim();
-                    if (!comment) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'empty_body', message: 'body (the result comment) is required.' }));
-                        return;
-                    }
-                    const r = await commentOnIssue(tok.accessToken, ref.owner, ref.repo, ref.number, comment);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ htmlUrl: r.htmlUrl, issue: `${ref.owner}/${ref.repo}#${ref.number}` }));
-                }
-                catch (e) {
-                    res.writeHead(502, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_comment_failed', detail: String(e?.message || e) }));
-                }
-            })();
-            return;
-        }
-        // GET /api/github/status — does the composer/import panel have a connected
-        // GitHub to work with? Cheap, no network: reads the stored token + whether a
-        // client_id is even configured (so the UI can show "connect" vs "set it up").
-        if (req.method === 'GET' && req.url === '/api/github/status') {
-            const tok = loadToken('github');
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ connected: !!tok?.accessToken, clientIdConfigured: !!githubClientId() }));
-            return;
-        }
-        // GET /api/github/issues?repo=owner/repo — list open issues so the user can
-        // PICK one instead of typing "owner/repo#123" from memory. Uses the stored
-        // device-flow token (loadToken). PRs are filtered out in listIssues.
-        if (req.method === 'GET' && req.url?.startsWith('/api/github/issues')) {
-            (async () => {
-                const tok = loadToken('github');
-                if (!tok?.accessToken) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_not_connected', message: 'Connect GitHub first.' }));
-                    return;
-                }
-                const repoParam = new URL(req.url || '', 'http://localhost').searchParams.get('repo') || '';
-                const ref = parseRepoRef(repoParam);
-                if (!ref) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'bad_repo', message: 'Provide repo as owner/repo.' }));
-                    return;
-                }
-                try {
-                    const issues = await listIssues(tok.accessToken, ref.owner, ref.repo);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ repo: `${ref.owner}/${ref.repo}`, issues }));
-                }
-                catch (e) {
-                    res.writeHead(502, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'github_issues_failed', detail: String(e?.message || e) }));
-                }
-            })();
-            return;
-        }
-        // ── F1a readiness check ───────────────────────────────────────────────────
-        if (req.method === 'GET' && req.url === '/api/readiness') {
-            try {
-                const report = detectReadiness();
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(report));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'readiness_check_failed', detail: String(e) }));
-            }
-            return;
-        }
-        // ── v1 project-memory routes (the room's init nudge) ─────────────────────
-        // Found by the stranger walk: web-only users never run `codehere init`, so
-        // the spec's "agent remembers the project" half of nothing-lost silently
-        // doesn't apply. Status reports the SAME readiness the injector acts on
-        // (shared findProjectRoot); init runs the SAME hardened scaffold the CLI
-        // does (shared scaffoldProjectAt — symlink defenses included).
-        if (req.method === 'GET' && req.url?.startsWith('/api/memory/status')) {
-            try {
-                const u = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`);
-                const cwd = u.searchParams.get('cwd') || '';
-                if (!cwd || !isAbsolute(cwd) || cwd.includes('\0')) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'cwd (absolute path) required' }));
-                    return;
-                }
-                const root = findProjectRoot(cwd);
-                const ready = !!root && existsSync(join(root, '.codehere', 'memory', 'working'));
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ready, projectRoot: root }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'memory_status_failed', detail: String(e) }));
-            }
-            return;
-        }
-        if (req.method === 'POST' && req.url === '/api/memory/init') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let cwd = '';
-                    try {
-                        cwd = String(JSON.parse(body || '{}').cwd || '');
-                    }
-                    catch {
-                        /* falls through to the validation below */
-                    }
-                    if (!cwd || !isAbsolute(cwd) || cwd.includes('\0') || !existsSync(cwd) || !statSync(cwd).isDirectory()) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'cwd (absolute path to an existing directory) required' }));
-                        return;
-                    }
-                    const r = scaffoldProjectAt(cwd);
-                    if (!r.ok) {
-                        res.writeHead(409, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, reason: r.reason }));
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        ok: true,
-                        created: r.created.length,
-                        skipped: r.skipped.length,
-                        refused: r.refused.length + r.refusedDirs.length,
-                    }));
-                }
-                catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'memory_init_failed', detail: String(e) }));
-                }
-            })().catch(() => {
-                /* handled above — keep the route from rejecting unhandled */
-            });
-            return;
-        }
-        // ── v0.6.0 M1 project thread routes ──────────────────────────────────────
-        // GET /api/projects           — list all known projects (slug, cwd, title, taskCount, lastActivityAt)
-        // GET /api/projects/:slug     — single project thread (meta + tasks merged by sessionId)
-        // Reader source of truth: ~/.codehere/projects/<slug>/thread.jsonl (per-project append-only log
-        // populated by migration + forward-mirror). Drives the new thread-view UI.
-        if (req.method === 'GET' && req.url === '/api/projects') {
-            try {
-                // Drop ephemeral/dead projects from the board: a "project" rooted in a throwaway temp dir
-                // (eval/test harnesses), with no local path at all, or whose dirs are all gone, isn't real
-                // work the user can open. Same temp-dir rule as the /api/tasks filter, plus an existence check.
-                const tmpRoot = tmpdir().replace(/^\/private/, '');
-                const isEphemeralPath = (cwd) => {
-                    if (!cwd)
-                        return true;
-                    const norm = cwd.replace(/^\/private/, '');
-                    if (norm === tmpRoot || norm.startsWith(tmpRoot + '/') || norm === '/tmp' || norm.startsWith('/tmp/'))
-                        return true;
-                    return !existsSync(cwd); // a project whose directory is gone isn't workable
-                };
-                const projects = listProjects().filter((p) => (p.localPaths || []).some((c) => !isEphemeralPath(c)));
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ projects }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'list_projects_failed', detail: String(e) }));
-            }
-            return;
-        }
-        if (req.method === 'GET' && req.url?.startsWith('/api/projects/')) {
-            try {
-                // Slug is the segment after /api/projects/. Strip optional query string.
-                const slug = req.url.replace('/api/projects/', '').split('?')[0];
-                // Slug shape is sha1[:12] (12 hex chars) OR the literal 'unknown' bucket.
-                // Reject anything else to keep the surface tight (and stop ../ traversal).
-                if (!/^([a-f0-9]{12}|unknown)$/.test(slug)) {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'invalid_slug' }));
-                    return;
-                }
-                // Merge clones so the room shows the repo's FULL history, and attach per-task
-                // cost (same estimator as /api/tasks) so the conversation rows carry their bill.
-                const thread = readMergedProjectThread(slug);
-                if (!thread) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'project_not_found', slug }));
-                    return;
-                }
-                const tasksWithCost = thread.tasks.map((t) => {
-                    // F-07 / R11 · the same single verdict object /api/tasks serves — the
-                    // room UI reads THIS route, and without it no persisted task could
-                    // ever show its trust verdict (found live: 465 tasks, 0 verdicts).
-                    const verdict = composeVerdict({ finalReport: t.finalReport ?? undefined, artifacts: t.artifacts, steps: t.steps }, t.auditRecon);
-                    const u = t.artifacts?.usage;
-                    if (!u || (!u.inputTokens && !u.outputTokens))
-                        return { ...t, verdict };
-                    const usd = estimateCostUsd(String(t.agent || ''), {
-                        inputTokens: u.inputTokens || 0,
-                        outputTokens: u.outputTokens || 0,
-                        cacheReadTokens: u.cacheReadTokens,
-                        cacheCreationTokens: u.cacheCreationTokens,
-                        model: u.model,
-                    });
-                    return { ...t, verdict, cost: { spent: usd * 100, paid: usd > 0 } };
-                });
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ thread: { ...thread, tasks: tasksWithCost } }));
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'read_project_failed', detail: String(e) }));
-            }
-            return;
-        }
-        // POST /api/projects/:slug/rename  — body { title }
-        // User-initiated rename. Title agent generates a title from the first
-        // prompt; project intent drifts. Without rename, /agent dir gets stuck
-        // titled "Scan Auth File" forever even after 100+ unrelated tasks.
-        if (req.method === 'POST' && req.url?.match(/^\/api\/projects\/[^/]+\/rename$/)) {
-            const slug = req.url.split('/')[3];
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        const raw = JSON.parse(body);
-                        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'invalid_body' }));
-                            return;
-                        }
-                        parsed = raw;
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid_json' }));
-                        return;
-                    }
-                    if (typeof parsed.title !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'title_required' }));
-                        return;
-                    }
-                    const result = renameProject(slug, parsed.title);
-                    if (!result.ok) {
-                        let status = 400;
-                        if (result.error === 'Project not found')
-                            status = 404;
-                        else if (result.error === 'Write failed')
-                            status = 500;
-                        res.writeHead(status, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: result.error }));
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, slug, title: parsed.title.trim() }));
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // POST /api/projects/:slug/archive — body { sessionId, archived } — soft-delete /
-        // restore a task. Append-only + audit-safe (the task record is never deleted).
-        if (req.method === 'POST' && req.url?.match(/^\/api\/projects\/[^/]+\/archive$/)) {
-            const slug = req.url.split('/')[3];
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        const raw = JSON.parse(body);
-                        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'invalid_body' }));
-                            return;
-                        }
-                        parsed = raw;
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid_json' }));
-                        return;
-                    }
-                    if (typeof parsed.sessionId !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'sessionId_required' }));
-                        return;
-                    }
-                    const result = setTaskArchived(slug, parsed.sessionId, parsed.archived === true);
-                    if (!result.ok) {
-                        let status = 400;
-                        if (result.error === 'Project not found')
-                            status = 404;
-                        else if (result.error === 'Write failed')
-                            status = 500;
-                        res.writeHead(status, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: result.error }));
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, sessionId: parsed.sessionId, archived: parsed.archived === true }));
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // POST /api/budget — body { dailyUsd: number | null } — set the daily spend cap
-        // (null/0 disables). Used by first-time setup so the cost-bounded promise is real
-        // from minute one; same store the `codehere budget set` CLI writes.
-        if (req.method === 'POST' && req.url === '/api/budget') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        const raw = JSON.parse(body);
-                        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'invalid_body' }));
-                            return;
-                        }
-                        parsed = raw;
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid_json' }));
-                        return;
-                    }
-                    let dailyUsd;
-                    if (parsed.dailyUsd === null || parsed.dailyUsd === 0) {
-                        dailyUsd = null; // disable enforcement
-                    }
-                    else if (typeof parsed.dailyUsd === 'number' && Number.isFinite(parsed.dailyUsd) && parsed.dailyUsd > 0) {
-                        dailyUsd = parsed.dailyUsd;
-                    }
-                    else {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'dailyUsd must be a positive number, 0, or null' }));
-                        return;
-                    }
-                    const cfg = loadBudget();
-                    cfg.dailyUsd = dailyUsd;
-                    saveBudget(cfg);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, dailyUsd }));
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // POST /api/projects/clone  — { url } → clone a GitHub repo locally, return its cwd.
-        // The room opens from a cwd; the project record auto-creates on the first task
-        // spawned there. Clone target is ~/codehere-projects/<repo> (visible, predictable).
-        // Idempotent: if that dir already holds the same repo, we open it instead of
-        // re-cloning. Async (execFile, not execFileSync) so a slow clone never freezes
-        // the daemon. Uses the user's existing git auth — fails open with a plain reason.
-        if (req.method === 'POST' && req.url === '/api/projects/clone') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        const raw = JSON.parse(body);
-                        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'invalid_body' }));
-                            return;
-                        }
-                        parsed = raw;
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid_json' }));
-                        return;
-                    }
-                    const baseDir = join(process.env.CODEHERE_CLONE_DIR || join(homedir(), 'codehere-projects'));
-                    const target = parseGitHubCloneTarget(typeof parsed.url === 'string' ? parsed.url : '', baseDir);
-                    if (!target.ok) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: target.error }));
-                        return;
-                    }
-                    // Already cloned here? Open it (idempotent), don't re-clone.
-                    if (existsSync(join(target.dir, '.git'))) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, cwd: target.dir, repo: target.repo, alreadyHere: true }));
-                        return;
-                    }
-                    if (existsSync(target.dir)) {
-                        res.writeHead(409, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'dir_exists', detail: target.dir }));
-                        return;
-                    }
-                    mkdirSync(baseDir, { recursive: true });
-                    try {
-                        // `--` ends option parsing: a cloneUrl beginning with '-' is then a
-                        // positional, never read by git as a flag (defense even though execFile
-                        // already avoids a shell). --config protocol.ext.allow=never blocks the
-                        // ext:: transport (git's RCE vector) belt-and-suspenders to the parser.
-                        await promisify(execFile)('git', ['-c', 'protocol.ext.allow=never', 'clone', '--depth', '1', '--', target.cloneUrl, target.dir], {
-                            timeout: 120000,
-                            maxBuffer: 8 * 1024 * 1024,
-                        });
-                    }
-                    catch (cloneErr) {
-                        const msg = String(cloneErr?.stderr || cloneErr?.message || cloneErr).slice(0, 400);
-                        res.writeHead(502, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'clone_failed', detail: msg }));
-                        return;
-                    }
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, cwd: target.dir, repo: target.repo }));
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] clone readBody rejected');
-                }
-            })();
-            return;
-        }
-        // ── F1 task orchestration routes ─────────────────────────────────────────
-        // POST /api/task               — { prompt, cwd? } → { sessionId }
-        // GET  /api/tasks              — list all sessions
-        // GET  /api/task/:id/events    — SSE stream
-        // POST /api/task/:id/kill      — terminate
-        if (req.url && req.url.startsWith('/api/task')) {
-            const manager = SessionManager.getInstance();
-            // v0.6 M5 slice 1 — POST /api/task/batch.
-            // Spawns N tasks at once (independent files only, per W2 — same-file
-            // conflicts ship in v0.7). Each spawn flows through SessionManager
-            // so pre-prompt scan + audit still run per task. Cap of 5 concurrent
-            // to prevent runaway. Returns array of { sessionId, agent } in input
-            // order; per-task failures are surfaced as { error, agent } entries
-            // so a partial-failure batch still returns useful info.
-            if (req.method === 'POST' && req.url === '/api/task/batch') {
-                (async () => {
-                    try {
-                        const body = await readBody(req, res);
-                        let parsed;
-                        try {
-                            parsed = JSON.parse(body || '{}');
-                        }
-                        catch (e) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                            return;
-                        }
-                        const tasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-                        if (tasks.length === 0) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'tasks (non-empty array) required' }));
-                            return;
-                        }
-                        if (tasks.length > 5) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'batch size capped at 5', requested: tasks.length }));
-                            return;
-                        }
-                        const validAgentIds = new Set(allAdapters().map((a) => a.id));
-                        // v0.6 S3 slice 2 — pre-spawn budget gate, applied per-task. Fan-out
-                        // is the most likely way to overshoot a daily budget (5 paid spawns
-                        // at once); checking once at batch entry then re-checking per task
-                        // is overkill, so we snapshot the budget + spend ONCE and let each
-                        // paid spawn that would push us over fail with the same error shape
-                        // /api/task uses. Free-tier spawns always pass.
-                        const batchBudget = loadBudget();
-                        const batchSpendNow = batchBudget.dailyUsd !== null ? computeSpendToday().totalUsd : 0;
-                        const results = [];
-                        const seenCwds = new Set();
-                        // It-4 V1-MULTITASK — one batch call = one parent; children share
-                        // the batchId so the room can render a live-derived rollup row.
-                        const batchId = randomUUID();
-                        for (const t of tasks) {
-                            const prompt = t.prompt;
-                            if (!prompt || typeof prompt !== 'string') {
-                                results.push({ error: 'prompt (string) required', agent: t.agent ?? null });
-                                continue;
-                            }
-                            if (prompt.trim().length === 0) {
-                                results.push({ error: 'prompt is empty — describe what you want done', agent: t.agent ?? null });
-                                continue;
-                            }
-                            const agentId = typeof t.agent === 'string' && t.agent.length > 0 ? t.agent : 'conductor';
-                            if (!validAgentIds.has(agentId)) {
-                                results.push({ error: `Unknown agent: ${agentId}`, agent: agentId });
-                                continue;
-                            }
-                            if (t.cwd !== undefined) {
-                                if (typeof t.cwd !== 'string' || t.cwd.includes('\0') || !isAbsolute(t.cwd)) {
-                                    results.push({ error: 'cwd must be absolute, no NUL bytes', agent: agentId });
-                                    continue;
-                                }
-                                let tCwdIsDir = false;
-                                try {
-                                    tCwdIsDir = statSync(t.cwd).isDirectory();
-                                }
-                                catch {
-                                    /* missing path */
-                                }
-                                if (!tCwdIsDir) {
-                                    results.push({
-                                        error: `That folder doesn't exist on this machine: ${t.cwd.slice(0, 200)}`,
-                                        agent: agentId,
-                                    });
-                                    continue;
-                                }
-                            }
-                            // The batch contract is "independent files only — non-overlapping
-                            // cwds" (W2). It was a comment, not a guard (AUD audit 2026-06-07):
-                            // two tasks on the same cwd both spawned, racing writes on one
-                            // repo path. Enforce it per task; undefined cwds share one key.
-                            // Literal-string guard, not canonicalized — '/tmp' vs '/private/tmp'
-                            // aren't deduped; this catches the paste-same-path-twice footgun.
-                            // readOnly tasks (the @all fanout: same QUESTION to every ready
-                            // adapter) are exempt — read concurrency was never the race this
-                            // guard stops. Caller-asserted, like the rest of the batch
-                            // contract; write fanout stays blocked until worktree isolation.
-                            const readOnly = t.readOnly === true;
-                            const cwdKey = t.cwd ?? '<daemon-cwd>';
-                            if (!readOnly) {
-                                if (seenCwds.has(cwdKey)) {
-                                    results.push({
-                                        error: `cwd already used by another task in this batch (${cwdKey.slice(0, 200)}) — batch tasks must target independent folders`,
-                                        agent: agentId,
-                                    });
-                                    continue;
-                                }
-                                seenCwds.add(cwdKey);
-                            }
-                            // Per-task budget check (paid agents only).
-                            if (batchBudget.dailyUsd !== null) {
-                                const probe = estimateCostUsd(agentId, { inputTokens: 1, outputTokens: 1 });
-                                if (probe > 0 && isOverBudget(batchSpendNow, batchBudget)) {
-                                    results.push({
-                                        error: 'daily_budget_exhausted',
-                                        agent: agentId,
-                                        spentTodayUsd: batchSpendNow,
-                                        dailyBudgetUsd: batchBudget.dailyUsd,
-                                    });
-                                    continue;
-                                }
-                            }
-                            try {
-                                const session = manager.spawn(prompt, agentId, { cwd: t.cwd, batchId });
-                                results.push({
-                                    sessionId: session.sessionId,
-                                    agent: session.agent,
-                                    status: session.status,
-                                    startedAt: session.startedAt,
-                                });
-                            }
-                            catch (e) {
-                                const msg = String(e?.message || e);
-                                const code = msg.includes('pre-prompt scan blocked') ? 'pre_prompt_blocked' : 'spawn_failed';
-                                results.push({ error: code, reason: msg, agent: agentId });
-                            }
-                        }
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ tasks: results, count: results.length }));
-                    }
-                    catch {
-                        if (process.env.CODEHERE_DEBUG === '1')
-                            console.error('[codehere] readBody rejected (oversized or aborted)');
-                    }
-                })();
-                return;
-            }
-            if (req.method === 'POST' && req.url === '/api/task') {
-                (async () => {
-                    try {
-                        const body = await readBody(req, res);
-                        // Two-phase try: JSON parse failures get one error shape, spawn
-                        // failures get a different one. Pre-fix the catch wrapped every
-                        // failure as "Invalid JSON body" — including the pre-prompt scan
-                        // throw — which read as a parse bug to the client.
-                        let parsed;
-                        try {
-                            parsed = JSON.parse(body || '{}');
-                        }
-                        catch (e) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
-                            return;
-                        }
-                        try {
-                            const { prompt, cwd, agent } = parsed;
-                            if (!prompt || typeof prompt !== 'string') {
-                                res.writeHead(400, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: 'prompt (string) required' }));
-                                return;
-                            }
-                            // Whitespace-only prompts are a real spawn with nothing to do —
-                            // they burn an agent run for no work (dogfood 2026-05-27 Phase D).
-                            // Reject before spawn; require something to act on.
-                            if (prompt.trim().length === 0) {
-                                res.writeHead(400, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: 'prompt is empty — describe what you want done' }));
-                                return;
-                            }
-                            // CRIT-5 fix · whitelist agent ID against the registry BEFORE any
-                            // log/spawn. Stops log injection (`agent: "claude-code\n[FAKE]"`),
-                            // future-proofs against partial-match exploits, and fails fast
-                            // with a clear 400 instead of letting SessionManager.spawn throw.
-                            //
-                            // Apr 29: default flipped from 'claude-code' to 'conductor'. The web
-                            // UI is the Conductor surface; tasks submitted without an explicit
-                            // agent route through the supervisor (rule-based routing today,
-                            // LLM classifier in v0.6). Empty string is treated like undefined
-                            // so the form submitting `agent: ""` (Auto option) hits the same
-                            // path. Specialists remain explicit overrides via the dropdown.
-                            // Type-check is preserved: non-string non-undefined values still 400.
-                            if (agent !== undefined && agent !== null && typeof agent !== 'string') {
-                                res.writeHead(400, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: 'agent must be a string or omitted' }));
-                                return;
-                            }
-                            const validAgentIds = new Set(allAdapters().map((a) => a.id));
-                            const agentId = typeof agent === 'string' && agent.length > 0 ? agent : 'conductor';
-                            if (!validAgentIds.has(agentId)) {
-                                res.writeHead(400, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({
-                                    error: `Unknown agent: ${typeof agentId === 'string' ? agentId.slice(0, 64) : '<non-string>'}`,
-                                    valid: [...validAgentIds],
-                                }));
-                                return;
-                            }
-                            // R7 onboarding fix (2026-06-07): an explicitly-picked vendor that
-                            // readiness already KNOWS isn't usable (aider without a billed key,
-                            // gemini without auth) used to accept the spawn and fail generically
-                            // afterwards. Refuse upfront with the same plain-English hint the
-                            // squad bar shows. Mock mode skips (mock spawns run regardless);
-                            // conductor routes around readiness itself; states readiness can't
-                            // detect (claude subscription auth) still rely on post-spawn
-                            // error fingerprints by design.
-                            if (process.env.CODEHERE_MOCK !== '1' && agentId !== 'conductor') {
-                                const ready = readinessForAllAgents().find((a) => a.id === agentId);
-                                if (ready && ready.state !== 'ready') {
-                                    const hint = ready.authHint?.detail;
-                                    res.writeHead(409, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({
-                                        error: 'agent_not_ready',
-                                        state: ready.state,
-                                        message: `${ready.label} isn't ready on this machine (${String(ready.state).replace(/_/g, ' ')}).${hint ? ' ' + hint : ''} Pick another agent, or fix the setup and retry.`,
-                                    }));
-                                    return;
-                                }
-                            }
-                            // Path-traversal + null-byte defense · cwd must be absolute and
-                            // free of NUL bytes (some filesystems treat \0 as terminator).
-                            if (cwd !== undefined) {
-                                if (typeof cwd !== 'string' || cwd.includes('\0') || !isAbsolute(cwd)) {
-                                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({ error: 'cwd must be an absolute path with no NUL bytes' }));
-                                    return;
-                                }
-                                // Lane J S3 (2026-06-07 audit): a nonexistent cwd returned 200
-                                // and the task hung "running" forever — empty steps, no error,
-                                // nothing on the stream. Fail at intake with a human answer.
-                                let cwdIsDir = false;
-                                try {
-                                    cwdIsDir = statSync(cwd).isDirectory();
-                                }
-                                catch {
-                                    /* missing path */
-                                }
-                                if (!cwdIsDir) {
-                                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({
-                                        error: `That folder doesn't exist on this machine: ${cwd.slice(0, 200)} — check the path and try again.`,
-                                    }));
-                                    return;
-                                }
-                            }
-                            const budgetForSpawn = loadBudget();
-                            if (budgetForSpawn.dailyUsd !== null) {
-                                const probe = estimateCostUsd(agentId, { inputTokens: 1, outputTokens: 1 });
-                                // Conductor (the auto router) is NOT refused here — it self-manages
-                                // by failing over to a free agent when over budget (Ega-approved
-                                // 2026-06-08), refusing only if no free agent is ready. Explicit
-                                // paid-agent picks ARE refused (respect the choice + never spend
-                                // over budget). See spawnConductor's budgetBounded routing.
-                                const isPaidSpawn = probe > 0 && agentId !== 'conductor';
-                                if (isPaidSpawn) {
-                                    const todaySpend = computeSpendToday();
-                                    if (isOverBudget(todaySpend.totalUsd, budgetForSpawn)) {
-                                        res.writeHead(429, { 'Content-Type': 'application/json' });
-                                        res.end(JSON.stringify({
-                                            error: 'daily_budget_exhausted',
-                                            message: `Today's estimated spend ($${todaySpend.totalUsd.toFixed(2)}) has reached the daily budget ($${budgetForSpawn.dailyUsd.toFixed(2)}). Switch to a free agent (gemini, opencode) or raise the budget with \`codehere budget set <amount>\`.`,
-                                            spentTodayUsd: todaySpend.totalUsd,
-                                            dailyBudgetUsd: budgetForSpawn.dailyUsd,
-                                        }));
-                                        return;
-                                    }
-                                }
-                            }
-                            // v0.8 S2 · resolve any context-source URLs in the prompt
-                            // (linear://INFRA-247, figma://file/<key>/...) before spawn.
-                            // Best-effort · resolver failures get logged inline in the
-                            // prompt + emit audit lines, never block the spawn.
-                            const reg = getDefaultRegistry();
-                            const fetchCtx = createDefaultFetchContextWithPost({
-                                emitAuditLine: (line) => {
-                                    // Future · feed into the hook audit chain (F-05/F-06).
-                                    // For now console-debug only · the spawn audit line below
-                                    // captures the user-facing outcome.
-                                    if (process.env.CODEHERE_DEBUG === '1') {
-                                        console.error('[context-source]', line.status, line.source, line.url, line.detail ?? '');
-                                    }
-                                },
-                            });
-                            let promptForSpawn = prompt;
-                            try {
-                                const r = await resolveContextSourceUrls(prompt, reg, fetchCtx);
-                                promptForSpawn = r.enrichedPrompt;
-                                if (r.outcomes.length && process.env.CODEHERE_DEBUG === '1') {
-                                    console.error('[context-source] resolved', r.outcomes.length, 'URL(s) ·', r.totalEstimatedTokens, 'tokens');
-                                }
-                            }
-                            catch (e) {
-                                // Resolver-level failure (registry corrupt, etc) · log and
-                                // fall back to the raw prompt. The agent runs without
-                                // enrichment instead of failing outright.
-                                console.error('[context-source] resolver failed:', e instanceof Error ? e.message : String(e));
-                            }
-                            const parentSessionId = typeof parsed.parentSessionId === 'string' && parsed.parentSessionId
-                                ? parsed.parentSessionId
-                                : undefined;
-                            const session = manager.spawn(promptForSpawn, agentId, {
-                                cwd,
-                                ...(parentSessionId ? { parentSessionId } : {}),
-                            });
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                sessionId: session.sessionId,
-                                startedAt: session.startedAt,
-                                status: session.status,
-                                agent: session.agent,
-                                canAppendMessage: session.canAppendMessage === true,
-                            }));
-                        }
-                        catch (e) {
-                            const msg = String(e?.message || e);
-                            if (msg.includes('pre-prompt scan blocked')) {
-                                res.writeHead(422, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: 'pre_prompt_blocked', reason: msg }));
-                                return;
-                            }
-                            res.writeHead(500, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'spawn_failed', detail: msg }));
-                        }
-                    }
-                    catch {
-                        if (process.env.CODEHERE_DEBUG === '1')
-                            console.error('[codehere] readBody rejected (oversized or aborted)');
-                    }
-                })();
-                return;
-            }
-            if (req.method === 'GET' && req.url === '/api/tasks') {
-                // Tier 0.1 · a MOCK run fabricates its own artifacts, so verify-claim
-                // compares the synthetic report to the synthetic artifacts and the green
-                // "verified" is tautological — it proves wiring, not a real result. Flag
-                // real mock RUNS so the surface says "wiring only". Seeded demo-* sessions
-                // are deliberate showcases (and the /verify coverage fixture) — left green.
-                // S18 · classification holds on the RECORD: appendSpawned stamps mockRun
-                // at run time, so a daemon restart / mode flip never reclassifies
-                // history. Legacy persisted records written before the stamp are
-                // recovered on read from the mock adapter's own resume token
-                // (recordedMockRun in session-persistence). The env stamp below applies
-                // only to (a) in-memory sessions of THIS daemon (env == record by
-                // definition) and (b) legacy records with neither stamp nor token —
-                // genuinely no other signal exists for those.
-                const mockDaemon = process.env.CODEHERE_MOCK === '1' || process.env.CODEHERE_MOCK === 'true';
-                const isMockRun = (id) => mockDaemon && !id.startsWith('demo-');
-                // Per-task bill · the card already shows steps/files/verdict but never the
-                // cost (it read t.cost, which nothing populated). Derive it from the task's
-                // own token usage so "what each agent did" includes "what it cost" inline.
-                // cents (sub-cent precision kept; costPill formats). undefined when there's
-                // no usage data — never fabricate a $0.
-                const costFor = (agent, artifacts) => {
-                    const u = artifacts?.usage;
-                    if (!u || (!u.inputTokens && !u.outputTokens))
-                        return undefined;
-                    const usd = estimateCostUsd(String(agent || ''), {
-                        inputTokens: u.inputTokens || 0,
-                        outputTokens: u.outputTokens || 0,
-                        cacheReadTokens: u.cacheReadTokens,
-                        cacheCreationTokens: u.cacheCreationTokens,
-                        model: u.model,
-                    });
-                    return { spent: usd * 100, paid: usd > 0 };
-                };
-                const spawned = manager.list().map((s) => {
-                    const completedAt = manager.getCompletedAt(s.sessionId);
-                    const finalReport = manager.getFinalReport(s.sessionId);
-                    const acceptanceCriteria = manager.getAcceptanceCriteria(s.sessionId);
-                    const cwd = manager.getCwd(s.sessionId);
-                    const continuedFrom = manager.getContinuedFrom(s.sessionId);
-                    const continuedAs = manager.getContinuedAs(s.sessionId);
-                    const recoveredFrom = manager.getRecoveredFrom(s.sessionId);
-                    const auditRecon = manager.getAuditRecon(s.sessionId);
-                    const batchId = manager.getBatchId(s.sessionId);
-                    const delegatedTo = manager.getDelegatedTo(s.sessionId);
-                    const failedReport = manager.hasFailedReport(s.sessionId);
-                    const stalledReason = manager.getStallReason(s.sessionId);
-                    // F-07 / R11 · the session's honesty verdict, ONE object owned by the
-                    // VerdictService: claim-vs-reality + audit-vs-disk reconciliation.
-                    // Pure, no I/O, runs sync · cheap to do per request. The UI renders
-                    // verdict.claim + verdict.audit without re-joining anything.
-                    const verdict = composeVerdict({ finalReport, artifacts: s.artifacts, steps: s.steps }, auditRecon);
-                    const cost = costFor(s.agent, s.artifacts);
-                    return {
-                        sessionId: s.sessionId,
-                        prompt: manager.getDisplayPrompt(s.sessionId) ?? s.prompt,
-                        startedAt: s.startedAt,
-                        status: s.status,
-                        agent: s.agent,
-                        steps: s.steps ?? [],
-                        artifacts: s.artifacts,
-                        ...(cost ? { cost } : {}),
-                        ...(completedAt !== undefined ? { completedAt, durationMs: completedAt - s.startedAt } : {}),
-                        ...(finalReport !== undefined ? { finalReport } : {}),
-                        ...(acceptanceCriteria && acceptanceCriteria.length ? { acceptanceCriteria } : {}),
-                        ...(failedReport ? { failedReport: true } : {}),
-                        ...(stalledReason ? { stalledReason } : {}),
-                        verdict,
-                        canAppendMessage: s.canAppendMessage === true,
-                        // S1 · the server is the single source of truth on whether a
-                        // follow-up can actually be DELIVERED — the UI renders from this,
-                        // never guesses.
-                        canFollowUp: s.canAppendMessage === true,
-                        ...(cwd !== undefined ? { cwd } : {}),
-                        ...(continuedFrom !== undefined ? { continuedFrom } : {}),
-                        ...(continuedAs !== undefined ? { continuedAs } : {}),
-                        // Recovery lineage → activates the dashboard "recovered from <vendor>"
-                        // badge + the failover kicker (gemini → claude · QUOTA · COMPLETED).
-                        ...(recoveredFrom !== undefined
-                            ? { failoverFrom: recoveredFrom.agent, failoverTo: s.agent, failoverReason: recoveredFrom.reason }
-                            : {}),
-                        ...(batchId !== undefined ? { batchId } : {}),
-                        ...(delegatedTo !== undefined ? { delegatedTo } : {}),
-                        ...(isMockRun(s.sessionId) ? { mockRun: true } : {}),
-                        provenance: 'spawned',
-                    };
-                });
-                const activeAgents = manager.listActiveAgents();
-                // F-07 / R11 · persisted records get the same single verdict object.
-                // 2.2 · the audit reconciliation now PERSISTS (appendAuditRecon), so a
-                // reloaded session carries its OBSERVED signal and the composite grade
-                // can still earn green after a restart — not just live in-memory tasks.
-                const persisted = manager.listPersisted().map((p) => ({
-                    ...p,
-                    verdict: composeVerdict(p, p.auditRecon),
-                    ...(costFor(p.agent, p.artifacts) ? { cost: costFor(p.agent, p.artifacts) } : {}),
-                    // S18 · the durable record (carried by ...p) wins; the env stamp is
-                    // only the fallback for legacy records that predate the run-time stamp.
-                    ...(p.mockRun === undefined && isMockRun(p.sessionId) ? { mockRun: true } : {}),
-                    // S1 · a dropped-from-memory session can only continue when
-                    // reconstructAppendable can rebuild it: claude-code + its native
-                    // resume token + cwd. Every other vendor keeps no resume token
-                    // codehere can use once the session is gone — say so.
-                    canFollowUp: p.agent === 'claude-code' && !!p.nativeSessionId && !!p.cwd,
-                }));
-                // A REAL (non-mock) dashboard must never show mock/demo sessions. They
-                // are dev fixtures — seeded `demo-*` showcases (the /verify coverage set)
-                // and `mockRun` wiring tests — that can leak into a persisted store
-                // (e.g. a mock run launched without an isolated CODEHERE_HOME). In mock
-                // mode the board needs them, so they stay; in real mode they are dev
-                // pollution and are filtered out so a genuine user only sees real work.
-                // A task run inside a throwaway temp dir (eval/test harnesses use mkdtemp —
-                // e.g. proven-fix's /…/T/pf-XXXX) is NOT the user's real work; it's harness
-                // pollution leaking into ~/.codehere/sessions.jsonl. Strip it from a real
-                // dashboard alongside mock/demo, so "your day so far" shows genuine work.
-                const tmpRoot = tmpdir().replace(/^\/private/, '');
-                const isEphemeralCwd = (cwd) => {
-                    if (!cwd)
-                        return false;
-                    const norm = cwd.replace(/^\/private/, '');
-                    return norm === tmpRoot || norm.startsWith(tmpRoot + '/') || norm.startsWith('/tmp/');
-                };
-                // Hide STALE throwaway-dir pollution only — NOT recent/live work. The old
-                // filter dropped any /tmp-cwd task outright, which silently hid a task the
-                // user just spawned AND broke verify-real-run (it sandboxes in mkdtemp under
-                // /tmp). A real run there proved the loop works but was invisible. So: an
-                // ephemeral-cwd task is filtered only once it's older than the window — a
-                // running/just-finished one always shows; only yesterday's eval junk fades.
-                const EPHEMERAL_STALE_MS = 2 * 60 * 60 * 1000; // 2h
-                const nowMs = Date.now();
-                const isStaleEphemeral = (cwd, ts) => isEphemeralCwd(cwd) && (!ts || nowMs - ts > EPHEMERAL_STALE_MS);
-                const realSpawned = mockDaemon
-                    ? spawned
-                    : spawned.filter((s) => !s.mockRun && !String(s.sessionId || '').startsWith('demo-') && !isStaleEphemeral(s.cwd, s.startedAt));
-                const realPersisted = mockDaemon
-                    ? persisted
-                    : persisted.filter((p) => p.mockRun !== true &&
-                        !String(p.sessionId || '').startsWith('demo-') &&
-                        !isStaleEphemeral(p.cwd, p.completedAt || p.startedAt));
-                // Layer 7: timestamp of most recent hook-audit line (= "last edit on this machine")
-                let lastEditAt = null;
-                try {
-                    if (existsSync(AUDIT_FILE))
-                        lastEditAt = statSync(AUDIT_FILE).mtimeMs;
-                }
-                catch {
-                    /* no audit yet — null */
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    spawned: realSpawned,
-                    persisted: realPersisted,
-                    activeAgents,
-                    lastEditAt,
-                    sessions: realSpawned, // back-compat for earlier UI code
-                    observed: manager.listObserved(), // legacy, kept for /history or future use
-                }));
-                return;
-            }
-            // P18 slice 4 — GET /api/task/:id/blocks → audit entries with
-            // blocked:true for this session. Lets the session-card UI panel
-            // surface "codehere noticed this pattern" prompts when the per-
-            // tool hook fires mid-session. Reads from the tail of the audit
-            // log; cheap because hook entries are short.
-            const blocksMatch = req.url.match(/^\/api\/task\/([^/]+)\/blocks$/);
-            if (blocksMatch && req.method === 'GET') {
-                const sessId = blocksMatch[1];
-                const blocks = [];
-                try {
-                    if (existsSync(AUDIT_FILE)) {
-                        const content = readFileSync(AUDIT_FILE, 'utf-8');
-                        const lines = content.split('\n');
-                        // Walk backward — most recent first — collect up to 20.
-                        for (let i = lines.length - 1; i >= 0 && blocks.length < 20; i--) {
-                            const ln = lines[i].trim();
-                            if (!ln)
-                                continue;
-                            try {
-                                const e = JSON.parse(ln);
-                                if (e.sessionId === sessId && e.blocked === true) {
-                                    blocks.unshift(e);
-                                }
-                            }
-                            catch {
-                                /* skip malformed */
-                            }
-                        }
-                    }
-                }
-                catch {
-                    /* fail open — empty list */
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ blocks }));
-                return;
-            }
-            // Cross-vendor verdict — GET /api/task/:id/cross-vendor → the receipt when
-            // this session reviewed an earlier DIFFERENT-vendor writer in the same room
-            // (who wrote, who reviewed, audit attribution, chain integrity, cost). null
-            // when the session isn't a cross-vendor review (the common case). Read-only.
-            const cvMatch = req.url.match(/^\/api\/task\/([^/]+)\/cross-vendor$/);
-            if (cvMatch && req.method === 'GET') {
-                const sessId = decodeURIComponent(cvMatch[1]);
-                let verdict = null;
-                try {
-                    // Reviewer-keyed first (the session IS a review); else writer-keyed
-                    // (the session was REVIEWED by a different vendor) so opening the
-                    // writer's run also shows "a different vendor reviewed this."
-                    verdict = buildCrossVendorVerdictById(sessId) ?? buildCrossVendorVerdictForWriter(sessId) ?? null;
-                }
-                catch {
-                    /* fail open — null (no verdict shown) */
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ crossVendor: verdict }));
-                return;
-            }
-            // v0.6 M3 — GET /api/task/:id/narration → latest mid-task summary.
-            // Read-only; SessionManager generates the narration in a background
-            // timer and caches the latest. Frontend polls (~30s) while the
-            // session is running.
-            const narrMatch = req.url.match(/^\/api\/task\/([^/]+)\/narration$/);
-            if (narrMatch && req.method === 'GET') {
-                const sessId = narrMatch[1];
-                const narration = manager.getNarration(sessId);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ narration: narration ?? null }));
-                return;
-            }
-            // /api/task/:id/events  or  /api/task/:id/kill
-            const m = req.url.match(/^\/api\/task\/([^/]+)\/(events|kill|message)$/);
-            if (m) {
-                const [, sessionId, verb] = m;
-                let session = manager.get(sessionId);
-                // BUG-2 (E2E 2.5) · verify accepts git-style 7+-char short ids; kill/
-                // events/message 404'd on the same prefix with a false "no running task
-                // found" while the task WAS running. Resolve a UNIQUE prefix against
-                // live sessions; ambiguous prefixes still fall through to the honest 404.
-                if (!session && sessionId.length >= 7) {
-                    const matches = manager.list().filter((s) => s.sessionId.startsWith(sessionId));
-                    if (matches.length === 1)
-                        session = matches[0];
-                }
-                // resume-after-restart: a completed session dropped from memory (a daemon
-                // restart, or eviction past MAX_COMPLETED) can still be CONTINUED — rebuild
-                // an appendable handle from its persisted native resume token + cwd. Only
-                // for the message verb (events/kill need a live process).
-                if (!session && verb === 'message') {
-                    session = manager.reconstructAppendable(sessionId);
-                }
-                if (!session) {
-                    // S13 refuter · a ZOMBIE running record (daemon restarted, process
-                    // long gone, status still 'running' on disk) was unstoppable: kill
-                    // 404'd forever while the row inflated the RUNNING count. There is
-                    // no live process to signal — record the honest bookkeeping kill so
-                    // the record stops claiming a life it doesn't have.
-                    if (verb === 'kill') {
-                        const zrec = loadSessionById(sessionId);
-                        const zLive = zrec && ['running', 'queued', 'paused', 'blocked'].includes(zrec.status);
-                        if (zrec && zLive) {
-                            appendCompleted({
-                                id: zrec.sessionId,
-                                status: 'killed',
-                                completedAt: Date.now(),
-                                durationMs: zrec.durationMs || 0,
-                                steps: zrec.steps ?? [],
-                                artifacts: zrec.artifacts ?? {},
-                            });
-                            SessionManager.getInstance().markPersistedKilled(zrec.sessionId);
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                sessionId,
-                                status: 'killed',
-                                note: 'no live process · the stale record was marked killed',
-                            }));
-                            return;
-                        }
-                    }
-                    // S1 · honest reason over a generic 404: if the task EXISTS but its
-                    // agent can't continue a finished session, say exactly that — the
-                    // composer should already be disabled, but the server is the gate.
-                    if (verb === 'message') {
-                        const rec = loadSessionById(sessionId);
-                        if (rec) {
-                            res.writeHead(409, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                error: `${rec.agent} can't continue a finished task — its session can't be resumed by codehere. Start a new task; the project thread carries the context.`,
-                                canFollowUp: false,
-                            }));
-                            return;
-                        }
-                    }
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: `No session: ${sessionId}` }));
-                    return;
-                }
-                if (verb === 'events' && req.method === 'GET') {
-                    res.writeHead(200, {
-                        'Content-Type': 'text/event-stream',
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                    });
-                    const unsubscribe = session.subscribe((event) => {
-                        res.write(`data: ${JSON.stringify(event)}\n\n`);
-                    });
-                    const ping = setInterval(() => res.write(': ping\n\n'), 15000);
-                    req.on('close', () => {
-                        clearInterval(ping);
-                        unsubscribe();
-                    });
-                    return;
-                }
-                if (verb === 'kill' && req.method === 'POST') {
-                    session.kill();
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ sessionId, status: session.status }));
-                    return;
-                }
-                // Iter 12 — POST /api/task/:id/message — follow-up message to a
-                // completed session. The reply-to-thread surface in the web UI calls
-                // this. Body: { text }. Response: { result, durationMs }.
-                if (verb === 'message' && req.method === 'POST') {
-                    if (!session.canAppendMessage || !session.appendMessage) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: `Agent ${session.agent} does not support follow-up messages yet.` }));
-                        return;
-                    }
-                    (async () => {
-                        try {
-                            const body = await readBody(req, res);
-                            try {
-                                const parsed = JSON.parse(body || '{}');
-                                const text = (parsed.text ?? '').trim();
-                                if (!text) {
-                                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({ error: 'text is required' }));
-                                    return;
-                                }
-                                const replyStartedAt = Date.now();
-                                const out = await session.appendMessage(text);
-                                const replyCompletedAt = Date.now();
-                                try {
-                                    // Live sessions: cwd from the in-memory map. Reconstructed
-                                    // (resume-after-restart) sessions: the map is empty — fall
-                                    // back to the cwd the handle carried from the persisted
-                                    // record, so the resumed turn still lands in thread.jsonl
-                                    // (no invisible agent activity).
-                                    const replyCwd = manager.getCwd(sessionId) ?? session.cwd;
-                                    if (replyCwd) {
-                                        mirrorReplyToThread({
-                                            parentSessionId: sessionId,
-                                            replySessionId: randomUUID(),
-                                            agent: session.agent,
-                                            prompt: text,
-                                            cwd: replyCwd,
-                                            startedAt: replyStartedAt,
-                                            completedAt: replyCompletedAt,
-                                            durationMs: out.durationMs,
-                                            result: out.result,
-                                        });
-                                    }
-                                }
-                                catch {
-                                    /* mirror is best-effort */
-                                }
-                                res.writeHead(200, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ sessionId, ...out }));
-                            }
-                            catch (err) {
-                                const msg = err instanceof Error ? err.message : String(err);
-                                res.writeHead(500, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: msg }));
-                            }
-                        }
-                        catch {
-                            if (process.env.CODEHERE_DEBUG === '1')
-                                console.error('[codehere] readBody rejected (oversized or aborted)');
-                        }
-                    })();
-                    return;
-                }
-            }
-            res.writeHead(405, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Method not allowed for this path' }));
-            return;
-        }
-        // v0.6.x P0 — GET /api/failover-offers
-        // Returns active failover offers so the dashboard can surface a
-        // "Claude rate-limited — switch to Codex?" banner. Offers expire
-        // after 60 s (handled by SessionManager).
-        if (req.method === 'GET' && req.url === '/api/failover-offers') {
-            const offers = SessionManager.getInstance().getFailoverOffers();
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ offers }));
-            return;
-        }
-        // v0.6.x P0 — POST /api/failover-accept
-        // User clicked "Switch" on the failoffer banner. Spawns a
-        // replacement session on the target agent, preserving the
-        // original prompt + cwd.
-        if (req.method === 'POST' && req.url === '/api/failover-accept') {
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let parsed;
-                    try {
-                        const raw = JSON.parse(body);
-                        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'invalid_body' }));
-                            return;
-                        }
-                        parsed = raw;
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid_body' }));
-                        return;
-                    }
-                    if (typeof parsed.sessionId !== 'string' || typeof parsed.targetAgent !== 'string') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'missing_sessionId_or_targetAgent' }));
-                        return;
-                    }
-                    try {
-                        const result = SessionManager.getInstance().acceptFailover(parsed.sessionId, parsed.targetAgent);
-                        if (result) {
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ ok: true, newSessionId: result.sessionId }));
-                        }
-                        else {
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                ok: false,
-                                error: 'target_unavailable',
-                                detail: `Could not spawn ${parsed.targetAgent}. Check if it's installed and authenticated.`,
-                            }));
-                        }
-                    }
-                    catch (e) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'failover_failed', detail: String(e) }));
-                    }
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // 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') {
-            // MCP Streamable HTTP transport. Plain-JSON POST (Claude Desktop, Claude
-            // Code) AND SSE-framed POST + a GET stream + Mcp-Session-Id, so strict
-            // clients (Codex, Cursor) connect too. One server, every agent.
-            const mcpSessionId = 'codehere-mcp-' + process.pid;
-            // GET opens the server->client SSE channel some clients require.
-            if (req.method === 'GET') {
-                res.writeHead(200, {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    Connection: 'keep-alive',
-                    'Mcp-Session-Id': mcpSessionId,
-                });
-                res.write(': codehere mcp stream open\n\n');
-                const ka = setInterval(() => {
-                    try {
-                        res.write(': keep-alive\n\n');
-                    }
-                    catch {
-                        /* socket closed */
-                    }
-                }, 25000);
-                req.on('close', () => clearInterval(ka));
-                return;
-            }
-            if (req.method !== 'POST') {
-                res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'GET, POST' });
-                res.end(JSON.stringify({ error: 'MCP endpoint accepts GET (stream) or POST', method: req.method }));
-                return;
-            }
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    let mcpReq;
-                    try {
-                        mcpReq = JSON.parse(body);
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                        return;
-                    }
-                    // Notifications (no id, e.g. notifications/initialized) get a 202 with
-                    // no body, per the JSON-RPC / MCP Streamable HTTP spec.
-                    if (mcpReq.id === undefined || mcpReq.id === null) {
-                        res.writeHead(202, { 'Mcp-Session-Id': mcpSessionId });
-                        res.end();
-                        return;
-                    }
-                    const mcpRes = dispatch(mcpReq);
-                    // Strict Streamable-HTTP clients send Accept: text/event-stream and
-                    // want the response as a single SSE message; lenient ones take JSON.
-                    const accept = String(req.headers['accept'] || '');
-                    if (accept.includes('text/event-stream')) {
-                        res.writeHead(200, {
-                            'Content-Type': 'text/event-stream',
-                            'Cache-Control': 'no-cache',
-                            Connection: 'keep-alive',
-                            'Mcp-Session-Id': mcpSessionId,
-                        });
-                        res.write('event: message\ndata: ' + JSON.stringify(mcpRes) + '\n\n');
-                        res.end();
-                    }
-                    else {
-                        res.writeHead(200, { 'Content-Type': 'application/json', 'Mcp-Session-Id': mcpSessionId });
-                        res.end(JSON.stringify(mcpRes));
-                    }
-                }
-                catch {
-                    if (process.env.CODEHERE_DEBUG === '1')
-                        console.error('[codehere] readBody rejected (oversized or aborted)');
-                }
-            })();
-            return;
-        }
-        // F-05 / F-06 · public endpoint for the audit chain verifier · powers
-        // the web UI's "Verify chain" button + can be hit directly by CI.
-        // v0.8 S2.5 · context-source OAuth routes
-        // GET  /api/context-sources                · list all providers + status
-        // POST /api/context-sources/:id/connect    · returns authorize URL + opens browser
-        // POST /api/context-sources/:id/disconnect · clears stored token
-        // GET  /oauth/callback?code=...&state=...  · provider redirect target
-        if (req.url === '/api/context-sources' && req.method === 'GET') {
-            try {
-                const oauthItems = listOAuthProviders().map((p) => {
-                    const status = connectionStatus(p.id);
-                    return {
-                        id: p.id,
-                        label: p.label,
-                        scheme: p.id,
-                        authType: 'oauth',
-                        status: status.status,
-                        userLabel: status.userLabel ?? null,
-                        connectedAt: status.connectedAt ?? null,
-                        expiresAt: status.expiresAt ?? null,
-                        clientIdConfigured: !!process.env[p.clientIdEnv],
-                    };
-                });
-                // GitHub is special: it authenticates via the device flow (/api/github/connect/*),
-                // not the generic auth-code OAuth above. Surface it as ONE connectable entry
-                // with its real device-flow status, so the panel stops showing the
-                // contradictory "public · no auth needed" chip alongside a Connect button
-                // elsewhere. authType 'github-device' tells the UI to drive the device flow.
-                const ghStatus = connectionStatus('github');
-                const githubItem = {
-                    id: 'github',
-                    label: 'GitHub',
-                    scheme: 'github',
-                    authType: 'github-device',
-                    status: ghStatus.status,
-                    userLabel: ghStatus.userLabel ?? null,
-                    connectedAt: ghStatus.connectedAt ?? null,
-                    expiresAt: ghStatus.expiresAt ?? null,
-                    clientIdConfigured: !!githubClientId(),
-                    description: 'Import issues and post results back. Connect once.',
-                };
-                // v0.8 S5 · public-by-URL adapters appear with status='available'
-                // (no Connect button needed · they work out of the box). GitHub is
-                // excluded here — it's rendered as the connectable githubItem above.
-                const oauthIds = new Set(oauthItems.map((i) => i.id));
-                const reg = getDefaultRegistry();
-                const noAuthItems = [...reg.bySchemeOnly.values()]
-                    .filter((s) => !oauthIds.has(s.id) && s.id !== 'github')
-                    .map((s) => ({
-                    id: s.id,
-                    label: s.label,
-                    scheme: s.scheme,
-                    authType: 'public',
-                    status: 'available',
-                    userLabel: null,
-                    connectedAt: null,
-                    expiresAt: null,
-                    clientIdConfigured: true,
-                    description: s.description,
-                }));
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ providers: [...oauthItems, githubItem, ...noAuthItems] }));
-            }
-            catch (e) {
-                console.error('[/api/context-sources] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Failed to list context sources' }));
-            }
-            return;
-        }
-        const connectMatch = req.url?.match(/^\/api\/context-sources\/([^/]+)\/connect$/);
-        if (connectMatch && req.method === 'POST') {
-            const providerId = connectMatch[1];
-            const provider = getOAuthProvider(providerId);
-            if (!provider) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: `unknown provider: ${providerId}` }));
-                return;
-            }
-            const clientId = process.env[provider.clientIdEnv] || null;
-            const r = oauthBegin(provider, { clientId });
-            if ('kind' in r && r.kind === 'not_registered') {
-                res.writeHead(409, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    error: 'provider_not_registered',
-                    provider: providerId,
-                    envVar: provider.clientIdEnv,
-                    message: `Set ${provider.clientIdEnv} to the OAuth client id from ${provider.label}. Until then, paste a manual key into ~/.codehere/context-sources.json under '${providerId}.apiKey'.`,
-                }));
-                return;
-            }
-            const result = r;
-            PENDING_OAUTH_FLOWS.set(result.pending.state, result.pending);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ authorizeUrl: result.authorizeUrl, state: result.pending.state }));
-            return;
-        }
-        // S2.6 · /test endpoint · proves the stored token actually works against
-        // the provider with a minimal read. Returns ok or detail.
-        const testMatch = req.url?.match(/^\/api\/context-sources\/([^/]+)\/test$/);
-        if (testMatch && req.method === 'POST') {
-            const providerId = testMatch[1];
-            const provider = getOAuthProvider(providerId);
-            if (!provider) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: 'unknown_provider' }));
-                return;
-            }
-            (async () => {
-                try {
-                    const status = connectionStatus(providerId);
-                    if (status.status === 'disconnected') {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'not_connected' }));
-                        return;
-                    }
-                    // Minimal probe per provider · the user-info endpoint is the
-                    // cheapest "does this token read at all" call.
-                    const userInfoUrl = provider.userInfoUrl;
-                    if (!userInfoUrl) {
-                        res.writeHead(501, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'no_test_endpoint' }));
-                        return;
-                    }
-                    const cfg = JSON.parse(readFileSync(join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'context-sources.json'), 'utf-8'));
-                    const entry = cfg[providerId] ?? {};
-                    let probeRes;
-                    if (providerId === 'linear') {
-                        const auth = entry.oauth?.accessToken ? `Bearer ${entry.oauth.accessToken}` : (entry.apiKey ?? '');
-                        probeRes = await fetch(userInfoUrl, {
-                            method: 'POST',
-                            headers: { Authorization: auth, 'Content-Type': 'application/json' },
-                            body: JSON.stringify({ query: '{ viewer { name email } }' }),
-                        });
-                    }
-                    else {
-                        // figma · GET with X-Figma-Token OR Bearer
-                        const headers = entry.oauth?.accessToken
-                            ? { Authorization: `Bearer ${entry.oauth.accessToken}` }
-                            : { 'X-Figma-Token': entry.token ?? '' };
-                        probeRes = await fetch(userInfoUrl, { headers });
-                    }
-                    if (!probeRes.ok) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, error: 'provider_returned_' + probeRes.status }));
-                        return;
-                    }
-                    const body = (await probeRes.json());
-                    const who = body.data?.viewer?.email || body.data?.viewer?.name || body.email || body.handle || null;
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: true, who }));
-                }
-                catch (e) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : String(e) }));
-                }
-            })();
-            return;
-        }
-        const disconnectMatch = req.url?.match(/^\/api\/context-sources\/([^/]+)\/disconnect$/);
-        if (disconnectMatch && req.method === 'POST') {
-            const providerId = disconnectMatch[1];
-            const ok = clearToken(providerId);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok, provider: providerId }));
-            return;
-        }
-        if (req.url?.startsWith('/oauth/callback') && req.method === 'GET') {
-            (async () => {
-                try {
-                    const u = new URL(req.url, 'http://127.0.0.1');
-                    const code = u.searchParams.get('code');
-                    const state = u.searchParams.get('state');
-                    const error = u.searchParams.get('error');
-                    if (error || !code || !state) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(callbackHtml('error', error || 'missing code/state', null));
-                        return;
-                    }
-                    const pending = PENDING_OAUTH_FLOWS.get(state);
-                    if (!pending) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(callbackHtml('error', 'unknown state · this flow was not started by this daemon or has expired', null));
-                        return;
-                    }
-                    const provider = getOAuthProvider(pending.provider);
-                    if (!provider) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(callbackHtml('error', `unknown provider: ${pending.provider}`, null));
-                        return;
-                    }
-                    const clientId = process.env[provider.clientIdEnv] || null;
-                    const out = await oauthComplete(code, state, {
-                        clientId,
-                        pending: PENDING_OAUTH_FLOWS,
-                        async httpPost(target, body, headers) {
-                            const r = await fetch(target, { method: 'POST', headers: headers ?? {}, body });
-                            const text = await r.text();
-                            const h = {};
-                            r.headers.forEach((v, k) => {
-                                h[k.toLowerCase()] = v;
-                            });
-                            return { status: r.status, body: text, headers: h };
-                        },
-                        async fetchUserInfo(token, userInfoUrl) {
-                            try {
-                                if (provider.id === 'linear') {
-                                    const r = await fetch(userInfoUrl, {
-                                        method: 'POST',
-                                        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-                                        body: JSON.stringify({ query: '{ viewer { name email } }' }),
-                                    });
-                                    if (!r.ok)
-                                        return null;
-                                    const j = (await r.json());
-                                    return j.data?.viewer ?? null;
-                                }
-                                if (provider.id === 'figma') {
-                                    const r = await fetch(userInfoUrl, {
-                                        headers: { Authorization: `Bearer ${token}` },
-                                    });
-                                    if (!r.ok)
-                                        return null;
-                                    const j = (await r.json());
-                                    return { name: j.handle, email: j.email };
-                                }
-                                return null;
-                            }
-                            catch {
-                                return null;
-                            }
-                        },
-                    });
-                    if ('kind' in out) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(callbackHtml('error', `${out.kind}: ${out.detail}`, provider.label));
-                        return;
-                    }
-                    saveToken(out);
-                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end(callbackHtml('ok', `Connected as ${out.userLabel ?? '(unknown user)'}`, provider.label));
-                }
-                catch (e) {
-                    console.error('[/oauth/callback] failed:', e);
-                    res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end(callbackHtml('error', e instanceof Error ? e.message : String(e), null));
-                }
-            })();
-            return;
-        }
-        // (MED #34, atomic audit) · a second GET /api/audit/verify handler lived
-        // here — unreachable dead code (the earlier handler wins the dispatch)
-        // with a DIFFERENT response shape. Deleted; one route, one truth.
-        // v0.8 S4 · share-thread · POST /api/thread/:id/export returns a signed
-        // bundle of one session that the recipient can replay locally. No relay
-        // through codehere's infrastructure · the response stays on-machine.
-        if (req.method === 'POST' && req.url && /^\/api\/thread\/[^/]+\/export$/.test(req.url)) {
-            try {
-                const m = req.url.match(/^\/api\/thread\/([^/]+)\/export$/);
-                const sessionId = m ? decodeURIComponent(m[1]) : '';
-                const session = sessionId ? loadSessionById(sessionId) : undefined;
-                if (!session) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'session not found', sessionId }));
-                    return;
-                }
-                const keys = loadOrCreateKeypair();
-                const body = {
-                    schema: 1,
-                    kind: 'thread',
-                    sessionId: session.sessionId,
-                    session,
-                    // Embed the tool-call audit so a teammate can inspect what the agent
-                    // did (signer-attested; see ThreadBundleBody.auditChain trust model).
-                    auditChain: collectAuditEntriesForSession(session.sessionId),
-                    // LOW #36 (atomic audit) · was hardcoded '0.7.0' while the build is 0.9.x —
-                    // a stale version stamped into every exported bundle's metadata.
-                    exporter: { codehereVersion: getVersion() },
-                    exportedAt: new Date().toISOString(),
-                };
-                const bundle = signBundle(body, keys);
-                const fp = shortFingerprint(bundle.publicKey);
-                const link = `codehere://thread/${session.sessionId}?signed=ed25519:${bundle.signature.slice(0, 24)}`;
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ bundle, link, fingerprint: fp }));
-            }
-            catch (e) {
-                console.error('[/api/thread/.../export] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'export failed' }));
-            }
-            return;
-        }
-        // v0.8 S4 · share-thread · POST /api/thread/import · accepts a bundle in
-        // the body, verifies it, optionally trusts the signer if the caller sets
-        // { trust: true }, persists the session record on success.
-        if (req.method === 'POST' && req.url === '/api/thread/import') {
-            (async () => {
-                try {
-                    const text = await readBody(req, res);
-                    let payload = {};
-                    try {
-                        payload = JSON.parse(text || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid JSON' }));
-                        return;
-                    }
-                    const verdict = verifyBundle(payload.bundle, trustedKeySet());
-                    if (verdict.status === 'malformed' || verdict.status === 'tampered') {
-                        res.writeHead(verdict.status === 'malformed' ? 400 : 409, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ status: verdict.status, reason: verdict.reason }));
-                        return;
-                    }
-                    if (verdict.status === 'unknown_key') {
-                        if (!payload.trust) {
-                            res.writeHead(202, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                status: 'unknown_key',
-                                publicKey: verdict.publicKey,
-                                fingerprint: shortFingerprint(verdict.publicKey),
-                                hint: 'Re-POST with { "trust": true } to trust this key and import.',
-                            }));
-                            return;
-                        }
-                        trustKey(verdict.publicKey);
-                    }
-                    const finalBundle = verdict.bundle;
-                    const ses = finalBundle.body.session;
-                    const importFp = shortFingerprint(finalBundle.publicKey);
-                    // No-clobber / idempotent import (Phase 2.5 multi-human): a re-import
-                    // must not duplicate the session in a shared room.
-                    if (loadSessionById(ses.sessionId)) {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ status: 'already_imported', sessionId: ses.sessionId, fingerprint: importFp }));
-                        return;
-                    }
-                    const home = process.env.CODEHERE_HOME || homedir();
-                    const sessionsPath = join(home, '.codehere', 'sessions.jsonl');
-                    const fs = await import('fs');
-                    fs.mkdirSync(dirname(sessionsPath), { recursive: true });
-                    // Re-verify the embedded tool-call audit so the importer SEES what the
-                    // agent did. attested gated on verified>0 + no tamper (never bare .valid,
-                    // true for an empty chain). Computed BEFORE persistence so it can be
-                    // stored on the session — the bundle isn't kept, so the room needs this.
-                    const auditCheck = finalBundle.body.auditChain
-                        ? verifyEmbeddedAuditChain(finalBundle.body.auditChain)
-                        : undefined;
-                    const importAudit = auditCheck
-                        ? {
-                            total: auditCheck.total,
-                            verified: auditCheck.verified,
-                            tampered: auditCheck.tampered.length,
-                            attested: auditCheck.verified > 0 && auditCheck.tampered.length === 0,
-                        }
-                        : undefined;
-                    const lines = [];
-                    lines.push(JSON.stringify({
-                        t: 'spawned',
-                        id: ses.sessionId,
-                        agent: ses.agent,
-                        prompt: ses.prompt,
-                        cwd: ses.cwd,
-                        startedAt: ses.startedAt,
-                        // S18 · practice classification is a property of the RUN on the
-                        // exporter's machine, carried by the bundle — never the importing
-                        // daemon's env. Absent in a legacy bundle = the work was real and
-                        // audit-attested; an import performed on a mock daemon must never
-                        // demote a teammate's real work to practice. Stamped explicitly so
-                        // no spawned-record writer leaves the field env-classified.
-                        mockRun: ses.mockRun === true,
-                        // Provenance: attribute the imported session to its signer.
-                        importedFrom: importFp,
-                        ...(importAudit ? { importAudit } : {}),
-                    }));
-                    lines.push(JSON.stringify({
-                        t: 'completed',
-                        id: ses.sessionId,
-                        status: ses.status,
-                        durationMs: ses.durationMs,
-                        completedAt: ses.completedAt,
-                        steps: ses.steps,
-                        artifacts: ses.artifacts,
-                    }));
-                    if (ses.finalReport) {
-                        lines.push(JSON.stringify({
-                            t: 'finalReport',
-                            id: ses.sessionId,
-                            summary: ses.finalReport.summary,
-                            generatedAt: ses.finalReport.generatedAt,
-                            durationMs: ses.finalReport.durationMs,
-                        }));
-                    }
-                    fs.appendFileSync(sessionsPath, lines.join('\n') + '\n', 'utf-8');
-                    // auditCheck was computed above (before persistence); reuse it for the
-                    // response so the importer sees the same attestation that got stored.
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        status: 'imported',
-                        sessionId: ses.sessionId,
-                        fingerprint: shortFingerprint(finalBundle.publicKey),
-                        audit: auditCheck ? { ...importAudit, legacy: auditCheck.legacy } : null,
-                    }));
-                }
-                catch (e) {
-                    console.error('[/api/thread/import] failed:', e);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'import failed' }));
-                }
-            })();
-            return;
-        }
-        /* v0.9 S7 · overlay-renderer · preview a 3rd-party URL via context-source */
-        // GET /api/context-source/preview?url=<urlencoded scheme://...>
-        if (req.method === 'GET' && req.url && req.url.startsWith('/api/context-source/preview')) {
-            (async () => {
-                try {
-                    const u = new URL(req.url, 'http://localhost');
-                    const target = u.searchParams.get('url');
-                    if (!target) {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'url required' }));
-                        return;
-                    }
-                    const reg = getDefaultRegistry();
-                    const fetchCtx = createDefaultFetchContextWithPost({
-                        emitAuditLine: (line) => {
-                            if (process.env.CODEHERE_DEBUG === '1') {
-                                console.error('[overlay-renderer]', line.status, line.source, line.url, line.detail ?? '');
-                            }
-                        },
-                    });
-                    const { fetchViaRegistry } = await import('../context/context-source.js');
-                    try {
-                        const payload = await fetchViaRegistry(reg, target, fetchCtx);
-                        if (!payload) {
-                            // No adapter registered for that scheme · honest 400 instead of
-                            // silent ok:true with payload:null.
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                ok: false,
-                                kind: 'invalid_url',
-                                error: `No adapter registered for "${target}" · supported: linear://, github://, figma://, drawio://`,
-                            }));
-                            return;
-                        }
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: true, payload }));
-                    }
-                    catch (err) {
-                        const code = err.kind ?? 'unknown';
-                        const message = err instanceof Error ? err.message : String(err);
-                        // Map adapter errors to honest HTTP codes so the UI can render
-                        // a useful empty/error state instead of swallowing everything.
-                        const httpStatus = code === 'not_found'
-                            ? 404
-                            : code === 'auth'
-                                ? 401
-                                : code === 'rate_limit'
-                                    ? 429
-                                    : code === 'invalid_url'
-                                        ? 400
-                                        : 502;
-                        res.writeHead(httpStatus, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ ok: false, kind: code, error: message }));
-                    }
-                }
-                catch (e) {
-                    console.error('[/api/context-source/preview] failed:', e);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ ok: false, error: 'preview failed' }));
-                }
-            })();
-            return;
-        }
-        /* v0.9 S6 part B · W-PASS write-pass routes ────────────────────────── */
-        // POST /api/writepass/intent · agent emits an intent.
-        // Body: { sessionId, target, method, payload, reason, emittedBy? }
-        // Response: 201 { status: 'pending', intent: WritePassIntent }
-        if (req.method === 'POST' && req.url === '/api/writepass/intent') {
-            (async () => {
-                try {
-                    const text = await readBody(req, res);
-                    let raw;
-                    try {
-                        raw = JSON.parse(text || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid JSON' }));
-                        return;
-                    }
-                    // Server assigns the id · agents shouldn't pick collisions.
-                    // S11 refuter caveat · the pass id is the DAEMON's to mint, always.
-                    // A caller-supplied id could collide, or match the demo-wp- prefix
-                    // the modal renders as not-sendable (a real pass made permanently
-                    // un-approvable by its own name).
-                    raw.id = newPassId();
-                    raw.emittedAt =
-                        typeof raw.emittedAt === 'number' && Number.isFinite(raw.emittedAt) ? raw.emittedAt : Date.now();
-                    let intent;
-                    try {
-                        intent = validateWritePassIntent(raw);
-                    }
-                    catch (err) {
-                        if (err instanceof WritePassError) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: err.code, detail: err.message }));
-                            return;
-                        }
-                        throw err;
-                    }
-                    const status = wpPutPending(intent);
-                    // Audit the intent immediately · the chain captures the agent's
-                    // request even if the user never decides (i.e. session ends).
-                    try {
-                        const line = writePassStatusToAuditLine(status);
-                        appendAuditLog({
-                            timestamp: line.timestamp,
-                            sessionId: line.sessionId,
-                            toolName: line.toolName,
-                            toolInput: line.toolInput,
-                            riskScore: line.riskScore,
-                            blocked: line.blocked,
-                            findings: line.findings,
-                            criticalFindings: line.criticalFindings,
-                        });
-                    }
-                    catch (e) {
-                        // Audit failure must not block the API (matches claude-sdk-hook discipline).
-                        console.error('[w-pass] audit append failed for intent:', e);
-                    }
-                    res.writeHead(201, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(status));
-                }
-                catch (e) {
-                    console.error('[/api/writepass/intent] failed:', e);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'intent failed' }));
-                }
-            })();
-            return;
-        }
-        // GET /api/writepass/pending · list all pending intents (UI poll target).
-        if (req.method === 'GET' && req.url === '/api/writepass/pending') {
-            try {
-                const pending = wpListPending();
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ passes: pending }));
-            }
-            catch (e) {
-                console.error('[/api/writepass/pending] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'list failed' }));
-            }
-            return;
-        }
-        // GET /api/writepass/session/:id · list all passes for a session.
-        if (req.method === 'GET' && req.url && /^\/api\/writepass\/session\/[^/]+$/.test(req.url)) {
-            try {
-                const m = req.url.match(/^\/api\/writepass\/session\/([^/]+)$/);
-                const sessionId = m ? decodeURIComponent(m[1]) : '';
-                const passes = wpListForSession(sessionId);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ sessionId, passes }));
-            }
-            catch (e) {
-                console.error('[/api/writepass/session] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'list failed' }));
-            }
-            return;
-        }
-        // GET /api/writepass/:id/trust · returns the domain trust grade the
-        // pending pass would resolve to. UI uses this to render the trust chip
-        // BEFORE the user clicks approve.
-        if (req.method === 'GET' && req.url && /^\/api\/writepass\/[^/]+\/trust$/.test(req.url)) {
-            try {
-                const m = req.url.match(/^\/api\/writepass\/([^/]+)\/trust$/);
-                const passId = m ? decodeURIComponent(m[1]) : '';
-                const current = wpGetById(passId);
-                if (!current) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'pass not found' }));
-                    return;
-                }
-                const payload = current.kind === 'edited' ? current.effectivePayload : current.intent.payload;
-                try {
-                    const resolved = resolveWriteRequest(current.intent, payload, loadContextSourcesConfigForWritePass());
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(resolved.trust));
-                }
-                catch (err) {
-                    // Resolver failed (auth missing, unsupported scheme) · return null
-                    // trust so the UI knows there's no domain to grade yet.
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        host: '',
-                        grade: 'F',
-                        reason: err instanceof Error ? err.message : 'resolve failed',
-                        userTrusted: false,
-                        requiresFirstWriteConfirmation: false,
-                    }));
-                }
-            }
-            catch (e) {
-                console.error('[/api/writepass/.../trust] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'trust lookup failed' }));
-            }
-            return;
-        }
-        // POST /api/writepass/:id/decide · user approves / edits / cancels.
-        // Body: { kind: 'approve'|'edit'|'cancel', editedPayload?, note? }
-        // On approve/edit · the daemon resolves + sends, audits the outcome.
-        if (req.method === 'POST' && req.url && /^\/api\/writepass\/[^/]+\/decide$/.test(req.url)) {
-            (async () => {
-                try {
-                    const m = req.url.match(/^\/api\/writepass\/([^/]+)\/decide$/);
-                    const passId = m ? decodeURIComponent(m[1]) : '';
-                    const current = wpGetById(passId);
-                    if (!current) {
-                        res.writeHead(404, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'pass not found', passId }));
-                        return;
-                    }
-                    if (current.kind !== 'pending') {
-                        res.writeHead(409, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'already decided', current }));
-                        return;
-                    }
-                    const bodyText = await readBody(req, res);
-                    let raw;
-                    try {
-                        raw = JSON.parse(bodyText || '{}');
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'invalid JSON' }));
-                        return;
-                    }
-                    // Default decidedAt to now if the client didn't set one.
-                    raw.passId = passId;
-                    raw.decidedAt =
-                        typeof raw.decidedAt === 'number' && Number.isFinite(raw.decidedAt) ? raw.decidedAt : Date.now();
-                    let decision;
-                    try {
-                        decision = validateWritePassDecision(raw, current.intent);
-                    }
-                    catch (err) {
-                        if (err instanceof WritePassError) {
-                            res.writeHead(400, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: err.code, detail: err.message }));
-                            return;
-                        }
-                        throw err;
-                    }
-                    const next = applyWritePassDecision(current.intent, decision);
-                    wpSetStatus(next);
-                    // Audit the decision.
-                    try {
-                        const line = writePassStatusToAuditLine(next);
-                        appendAuditLog({
-                            timestamp: line.timestamp,
-                            sessionId: line.sessionId,
-                            toolName: line.toolName,
-                            toolInput: line.toolInput,
-                            riskScore: line.riskScore,
-                            blocked: line.blocked,
-                            findings: line.findings,
-                            criticalFindings: line.criticalFindings,
-                        });
-                    }
-                    catch (e) {
-                        console.error('[w-pass] audit append failed for decision:', e);
-                    }
-                    // Cancelled · we stop here.
-                    if (next.kind === 'cancelled') {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify(next));
-                        return;
-                    }
-                    // Approved or edited · do the mediated send.
-                    if (next.kind !== 'approved' && next.kind !== 'edited') {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'unexpected status after decision', next }));
-                        return;
-                    }
-                    const effectivePayload = next.kind === 'edited' ? next.effectivePayload : current.intent.payload;
-                    // Load auth config from the same context-sources.json the read
-                    // adapters use · symmetric storage.
-                    const writePassConfig = loadContextSourcesConfigForWritePass();
-                    let resolved;
-                    try {
-                        resolved = resolveWriteRequest(current.intent, effectivePayload, writePassConfig);
-                    }
-                    catch (err) {
-                        if (err instanceof WritePassResolveError) {
-                            const failResponse = {
-                                passId,
-                                status: 0,
-                                bodySnippet: '',
-                                receivedAt: Date.now(),
-                                error: err.message,
-                            };
-                            const failed = applyWritePassResponse(next, failResponse);
-                            wpSetStatus(failed);
-                            try {
-                                const line = writePassStatusToAuditLine(failed);
-                                appendAuditLog({
-                                    timestamp: line.timestamp,
-                                    sessionId: line.sessionId,
-                                    toolName: line.toolName,
-                                    toolInput: line.toolInput,
-                                    riskScore: line.riskScore,
-                                    blocked: line.blocked,
-                                    findings: line.findings,
-                                    criticalFindings: line.criticalFindings,
-                                });
-                            }
-                            catch { }
-                            res.writeHead(424, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: err.code, detail: err.message, status: failed }));
-                            return;
-                        }
-                        throw err;
-                    }
-                    // v0.9 · per-domain mediated-write trust gate. If the resolved
-                    // target's host is graded F (unknown), require the decision to
-                    // explicitly include trustThisDomain:true before sending. Once
-                    // set, persist the host to trusted-domains.json so subsequent
-                    // writes auto-allow at grade B.
-                    if (resolved.trust.requiresFirstWriteConfirmation) {
-                        const decisionRaw = raw;
-                        if (!decisionRaw.trustThisDomain) {
-                            res.writeHead(202, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                status: 'requires_domain_trust',
-                                host: resolved.trust.host,
-                                grade: resolved.trust.grade,
-                                reason: resolved.trust.reason,
-                                hint: 'Re-POST with { "kind": "approve", "trustThisDomain": true } to trust this host once + send.',
-                            }));
-                            return;
-                        }
-                        try {
-                            trustDomainStore(resolved.trust.host, 'trusted during first W-PASS approval');
-                        }
-                        catch (e) {
-                            console.error('[w-pass] trustDomain store failed:', e);
-                        }
-                    }
-                    // Mediated send.
-                    let response;
-                    try {
-                        const f = await fetch(resolved.url, {
-                            method: resolved.method,
-                            headers: resolved.headers,
-                            body: resolved.body,
-                        });
-                        const text = await f.text();
-                        response = {
-                            passId,
-                            status: f.status,
-                            bodySnippet: text.slice(0, 2048),
-                            receivedAt: Date.now(),
-                        };
-                    }
-                    catch (err) {
-                        response = {
-                            passId,
-                            status: 0,
-                            bodySnippet: '',
-                            receivedAt: Date.now(),
-                            error: err instanceof Error ? err.message : String(err),
-                        };
-                    }
-                    const final = applyWritePassResponse(next, response);
-                    wpSetStatus(final);
-                    try {
-                        const line = writePassStatusToAuditLine(final);
-                        appendAuditLog({
-                            timestamp: line.timestamp,
-                            sessionId: line.sessionId,
-                            toolName: line.toolName,
-                            toolInput: line.toolInput,
-                            riskScore: line.riskScore,
-                            blocked: line.blocked,
-                            findings: line.findings,
-                            criticalFindings: line.criticalFindings,
-                        });
-                    }
-                    catch (e) {
-                        console.error('[w-pass] audit append failed for response:', e);
-                    }
-                    res.writeHead(final.kind === 'sent' ? 200 : 502, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(final));
-                }
-                catch (e) {
-                    console.error('[/api/writepass/decide] failed:', e);
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'decide failed' }));
-                }
-            })();
-            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 — friendly HTML page with route list (Bug A6 fix May 6 2026).
-        // Pre-fix: empty body, blank-page failure mode the dogfood walk caught.
-        // Per claim_user_persona HIGH non-technical-first: a non-technical user
-        // who typos a URL gets a useful page back, not a void.
-        const requestedPath = (req.url ?? '/').split('?')[0];
-        // API clients are machines: an unknown /api/* path gets JSON, never an
-        // HTML page a fetch().json() chokes on (2026-06-07 audit, Lane API).
-        if (requestedPath.startsWith('/api/')) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Unknown API route: ${requestedPath.slice(0, 200)}` }));
-            return;
-        }
-        res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(`<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8"/>
-<meta name="viewport" content="width=device-width,initial-scale=1"/>
-<link rel="icon" type="image/svg+xml" href="/icon.svg"/>
-<title>codehere · page not found</title>
-<style>
-  :root {
-    --bg: #0f0f12;
-    --fg: #f5f5f7;
-    --fg-50: #8b8b94;
-    --fg-30: #5a5a62;
-    --border: #2a2a32;
-    --accent: #ff9a76;
-    --mono: ui-monospace, 'SF Mono', Menlo, monospace;
-  }
-  * { box-sizing: border-box; }
-  body {
-    margin: 0; min-height: 100vh;
-    background: var(--bg); color: var(--fg);
-    font-family: Inter, system-ui, -apple-system, 'Segoe UI', sans-serif;
-    display: flex; flex-direction: column; align-items: center; justify-content: center;
-    padding: 48px 24px;
-  }
-  main { max-width: 480px; width: 100%; }
-  .label {
-    font-family: var(--mono); font-size: 11px; letter-spacing: 1.5px;
-    color: var(--fg-30); margin-bottom: 12px;
-  }
-  h1 { font-size: 22px; font-weight: 600; margin: 0 0 12px 0; }
-  .path {
-    font-family: var(--mono); font-size: 13px;
-    color: var(--fg-50); background: rgba(255,255,255,0.04);
-    border: 1px solid var(--border); border-radius: 4px;
-    padding: 6px 10px; display: inline-block; margin-bottom: 28px;
-    word-break: break-all;
-  }
-  .routes {
-    border-top: 1px solid var(--border);
-    padding-top: 24px; margin-top: 8px;
-  }
-  .routes-label {
-    font-family: var(--mono); font-size: 11px; letter-spacing: 1.5px;
-    color: var(--fg-30); margin-bottom: 12px;
-  }
-  .route {
-    display: flex; align-items: baseline; gap: 14px;
-    padding: 8px 0; border-bottom: 1px solid var(--border);
-    text-decoration: none; color: var(--fg);
-  }
-  .route:last-child { border-bottom: none; }
-  .route:hover { background: rgba(255,255,255,0.02); }
-  .route-name { font-weight: 500; }
-  .route-path { font-family: var(--mono); font-size: 12px; color: var(--fg-50); margin-left: auto; }
-</style>
-</head>
-<body>
-<main>
-  <div class="label">404 · NOT FOUND</div>
-  <h1>That page doesn't exist</h1>
-  <div class="path">${escapeHtmlText(requestedPath)}</div>
-  <div class="routes">
-    <div class="routes-label">VALID ROUTES</div>
-    <a class="route" href="/"><span class="route-name">Dashboard</span><span class="route-path">/</span></a>
-    <a class="route" href="/verify"><span class="route-name">Verify at the surface</span><span class="route-path">/verify</span></a>
-  </div>
-</main>
-</body>
-</html>`);
-    });
-    function escapeHtmlText(s) {
-        return s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
-    }
-    server.listen(port, host, () => {
-        // Daemon-start data hygiene — runs once after listen so any failure
-        // doesn't block the server coming up. Both are best-effort.
-        void (async () => {
-            try {
-                const { backfillProjectTitles } = await import('../storage/project-thread-mirror.js');
-                const r = await backfillProjectTitles();
-                if (process.env.CODEHERE_DEBUG === '1' && r.rewritten > 0) {
-                    console.error(`[daemon-start] backfilled ${r.rewritten}/${r.scanned} project titles`);
-                }
-            }
-            catch {
-                /* best-effort */
-            }
-            // Project identity backfill — detect + cache each project's git remote in
-            // _meta once, so the project list can collapse clones of one repo without
-            // shelling git on every poll. Idempotent (skips already-checked projects).
-            try {
-                const { backfillProjectRemotes } = await import('../storage/project-thread-mirror.js');
-                const r = await backfillProjectRemotes();
-                if (process.env.CODEHERE_DEBUG === '1' && r.detected > 0) {
-                    console.error(`[daemon-start] detected ${r.detected}/${r.scanned} project remotes`);
-                }
-            }
-            catch {
-                /* best-effort */
-            }
-            // Stale-session reconciliation. Walks per-project thread.jsonl files
-            // and marks any sessions stuck in 'running' for >60 min as crashed.
-            // Closes the dogfood-found gap where 3-day-old tasks displayed as
-            // RUNNING in the threads view because a daemon crash never wrote
-            // their completion event.
-            try {
-                const { reconcileStaleProjectTasks } = await import('../storage/project-thread-mirror.js');
-                const r = await reconcileStaleProjectTasks();
-                if (process.env.CODEHERE_DEBUG === '1' && r.reconciled > 0) {
-                    console.error(`[daemon-start] reconciled ${r.reconciled} stale running tasks`);
-                }
-            }
-            catch {
-                /* best-effort */
-            }
-        })();
-    });
-    return server;
-}
-/**
- * v0.8 S2.5 · response page rendered to the user's browser after the OAuth
- * provider redirects to /oauth/callback. Tiny styled card with status +
- * "you can close this tab now" affordance. Auto-closes after 3s if window
- * was opened via window.open() from our UI.
- */
-function callbackHtml(status, message, providerLabel) {
-    const safe = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-    const tone = status === 'ok' ? '#28c840' : '#ff5f57';
-    const icon = status === 'ok' ? '✓' : '✕';
-    const title = status === 'ok' ? `${providerLabel ?? 'Provider'} connected` : 'Connection failed';
-    return `<!doctype html><html lang="en"><head>
-<meta charset="utf-8"><link rel="icon" type="image/svg+xml" href="/icon.svg"><title>${safe(title)}</title>
-<style>
-  body { margin:0; background:#0a0a0a; color:#fff; font-family:ui-sans-serif,system-ui,-apple-system,sans-serif; display:flex; align-items:center; justify-content:center; min-height:100vh; }
-  .card { max-width:480px; padding:32px 36px; border:1px solid rgba(255,255,255,0.08); border-radius:12px; background:#111; }
-  .icon { width:48px; height:48px; border-radius:50%; background:${tone}; display:flex; align-items:center; justify-content:center; font-size:28px; font-weight:600; color:#000; margin-bottom:16px; }
-  h1 { font-size:18px; font-weight:600; margin:0 0 8px; }
-  p { color:rgba(255,255,255,0.65); font-size:14px; line-height:1.5; margin:0 0 16px; }
-  .hint { color:rgba(255,255,255,0.4); font-size:12px; font-family:ui-monospace,Menlo,monospace; }
-</style></head><body>
-<div class="card">
-  <div class="icon">${icon}</div>
-  <h1>${safe(title)}</h1>
-  <p>${safe(message)}</p>
-  <p class="hint">You can close this tab. Codehere has stored the connection locally.</p>
-</div>
-<script>setTimeout(function(){ try{ window.close(); }catch(_){} }, 3000);</script>
-</body></html>`;
-}
-//# sourceMappingURL=mcp-server-impl.js.map