codehere 0.8.0 → 1.0.2

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

@@ -1,2853 +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 } from 'fs';
-import { join, relative, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
-import { scanPayload, calculateRiskScore, AUDIT_FILE, verifyAuditChain } from '../hooks/claude-sdk-hook.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 { HISTORY_HTML, THREAD_HTML } from './ui-page.js';
-import { TASK_HTML_V2 } from './ui-page-v2.js';
-import { VERIFY_HTML } from './verify-page.js';
-import { verifyClaim } from '../../application/use-cases/verify-claim.js';
-import { signBundle, verifyBundle, shortFingerprint, } from '../../application/use-cases/thread-export.js';
-import { loadOrCreateKeypair, trustedKeySet, trustKey } from '../orchestration/thread-key-store.js';
-import { loadSessionById } from '../orchestration/session-persistence.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, 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 } from '../context/oauth-store.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, readProjectThread } from '../storage/project-thread-reader.js';
-import { mirrorReplyToThread, renameProject } 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, isOverBudget, budgetUsedPct } from '../cost/budget-config.js';
-// ── Tool definitions ─────────────────────────────────────────────────────────
-const TOOLS = [
-    {
-        name: 'codehere_trust',
-        description: 'Scan a file or code snippet for security vulnerabilities. Returns a trust score 0-100, grade, and plain-English findings. Zero API calls — runs entirely locally.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filepath: { type: 'string', description: 'Path to file (relative to cwd)' },
-                code: { type: 'string', description: 'Code content to scan (alternative to filepath)' },
-                verbose: { type: 'boolean', description: 'Include all findings with line numbers' },
-            },
-        },
-    },
-    {
-        name: 'codehere_scan',
-        description: 'Scan an instruction, prompt, or command text for injection attacks, credential theft attempts, destructive operations, and other threats. Returns block/allow decision with findings.',
-        inputSchema: {
-            type: 'object',
-            required: ['text'],
-            properties: {
-                text: { type: 'string', description: 'Text to scan (instruction, prompt, command)' },
-            },
-        },
-    },
-    {
-        name: 'codehere_review',
-        description: 'Review all files in a directory and return trust scores. Identifies the riskiest files to focus review effort.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Directory path (default: current directory)' },
-                topN: { type: 'number', description: 'Return top N riskiest files (default: 10)' },
-            },
-        },
-    },
-    {
-        name: 'codehere_audit',
-        description: 'Read recent hook audit log entries — shows which tool calls codehere blocked, allowed, or overrode (fail-open paths) in Claude Code sessions. Pass verify:true to instead validate the SHA-256 hash chain and return any tampering detected.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Number of recent entries to return (default: 20)' },
-                blockedOnly: { type: 'boolean', description: 'Only return blocked events' },
-                overrideOnly: {
-                    type: 'boolean',
-                    description: 'Only return trust-override events — cases where the scanner was bypassed (stdin failure, parse failure, --log-only, scan exception). Per CC frontier Q1 (auditable permission trails) — surface every bypass for review.',
-                },
-                verify: {
-                    type: 'boolean',
-                    description: 'Verify the SHA-256 hash chain instead of returning entries. Returns { valid, totalEntries, chainedEntries, legacyEntries, errors[] } where errors lists every detected tampering point (modification / deletion / insertion / parse failure). Per CC frontier Q1 (cryptographic commitment + tamper evidence).',
-                },
-            },
-        },
-    },
-];
-// ── Tool handlers ────────────────────────────────────────────────────────────
-import { homedir } 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 TASK_HTML/HISTORY_HTML 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>`);
-}
-function handleTrust(params) {
-    const { filepath, code, verbose } = params;
-    let content;
-    let label;
-    if (code) {
-        content = code;
-        label = 'provided code';
-    }
-    else if (filepath) {
-        const resolved = join(process.cwd(), filepath);
-        if (!existsSync(resolved)) {
-            return JSON.stringify({ error: `File not found: ${filepath}` });
-        }
-        content = readFileSync(resolved, 'utf-8');
-        label = filepath;
-    }
-    else {
-        return JSON.stringify({ error: 'Provide either filepath or code' });
-    }
-    const result = scoreFileForMCP(label, content);
-    if (!verbose) {
-        // Compact response
-        return JSON.stringify({
-            score: result.score,
-            grade: result.grade,
-            summary: result.summary,
-            criticalCount: result.findings.filter((f) => f.severity === 'critical').length,
-            highCount: result.findings.filter((f) => f.severity === 'high').length,
-            recommendation: result.score >= 75
-                ? 'Safe — minor issues can be addressed in follow-up'
-                : result.score >= 60
-                    ? 'Review recommended before merge'
-                    : 'Block — resolve critical/high findings first',
-        });
-    }
-    return JSON.stringify(result, null, 2);
-}
-function handleScan(params) {
-    const text = String(params.text ?? '');
-    const findings = scanPayload(text);
-    const riskScore = calculateRiskScore(findings);
-    const criticalFindings = findings.filter((f) => f.severity === 'critical');
-    const blocked = criticalFindings.length > 0 || riskScore >= 60;
-    return JSON.stringify({
-        blocked,
-        riskScore,
-        decision: blocked ? 'block' : 'allow',
-        reason: blocked
-            ? criticalFindings.length > 0
-                ? `${criticalFindings[0].category}: ${criticalFindings[0].description}`
-                : `Risk score ${riskScore}/100 exceeds threshold`
-            : 'No threats detected',
-        findings: findings.slice(0, 10), // cap at 10 to keep response small
-    });
-}
-/**
- * Coerce a client-supplied numeric param to a bounded integer. Daemon
- * endpoints take topN/limit straight from request bodies; a negative or NaN
- * value silently corrupts slice() math (limit=-1 → slice keeps all-but-last,
- * NaN → slice returns everything). Clamp to a sane range instead of trusting
- * the wire.
- */
-export function clampInt(v, def, min, max) {
-    // null/undefined = absent → default. Number(null) is 0 (finite), so without
-    // this guard a literal null would coerce to the min instead of the default.
-    if (v === null || v === undefined)
-        return def;
-    const n = Math.floor(Number(v));
-    if (!Number.isFinite(n))
-        return def;
-    return Math.max(min, Math.min(n, max));
-}
-function handleReview(params) {
-    const targetPath = String(params.path ?? process.cwd());
-    const topN = clampInt(params.topN, 10, 1, 100);
-    try {
-        const files = collectFilesForMCP(targetPath);
-        if (files.length === 0) {
-            return JSON.stringify({ message: 'No code files found', path: targetPath });
-        }
-        const results = files.map((f) => scoreFileForMCP(relative(targetPath, f.filepath), f.code));
-        results.sort((a, b) => a.score - b.score); // worst first
-        const top = results.slice(0, topN);
-        const overallScore = Math.round(results.reduce((s, r) => s + r.score, 0) / results.length);
-        return JSON.stringify({
-            overallScore,
-            grade: overallScore >= 90 ? 'A' : overallScore >= 75 ? 'B' : overallScore >= 60 ? 'C' : overallScore >= 40 ? 'D' : 'F',
-            totalFiles: results.length,
-            riskiestFiles: top.map((r) => ({
-                filepath: r.filepath,
-                score: r.score,
-                grade: r.grade,
-                summary: r.summary,
-                criticalCount: r.findings.filter((f) => f.severity === 'critical').length,
-                highCount: r.findings.filter((f) => f.severity === 'high').length,
-            })),
-        });
-    }
-    catch (e) {
-        return JSON.stringify({ error: String(e) });
-    }
-}
-function handleAudit(params) {
-    const limit = clampInt(params.limit, 20, 1, 500);
-    const blockedOnly = Boolean(params.blockedOnly);
-    const overrideOnly = Boolean(params.overrideOnly);
-    const verify = Boolean(params.verify);
-    if (verify) {
-        // Tamper-evidence verification — walks the file, recomputes every hash,
-        // checks the chain. Returns full report including ALL break points.
-        const result = verifyAuditChain(AUDIT_FILE);
-        return JSON.stringify(result, null, 2);
-    }
-    if (!existsSync(AUDIT_FILE)) {
-        return JSON.stringify({
-            message: 'No audit log yet — install hooks first with: codehere hook install',
-            entries: [],
-        });
-    }
-    const lines = readFileSync(AUDIT_FILE, 'utf-8')
-        .split('\n')
-        .filter(Boolean)
-        .slice(-Math.min(limit * 3, 500)); // read more than needed to account for filter
-    const entries = lines
-        .map((l) => {
-        try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter(Boolean)
-        .filter((e) => {
-        if (overrideOnly)
-            return Boolean(e.overrideReason);
-        if (blockedOnly)
-            return Boolean(e.blocked);
-        return true;
-    })
-        .slice(-limit);
-    return JSON.stringify({ entries, total: entries.length });
-}
-// ── JSON-RPC dispatcher ──────────────────────────────────────────────────────
-function dispatch(req) {
-    const id = req.id;
-    const params = (req.params ?? {});
-    try {
-        switch (req.method) {
-            case 'initialize':
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: {
-                        protocolVersion: '2024-11-05',
-                        capabilities: { tools: {} },
-                        serverInfo: { name: 'codehere', version: getVersion() },
-                    },
-                };
-            case 'tools/list':
-                return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
-            case 'tools/call': {
-                const toolName = String(params.name ?? '');
-                const toolParams = (params.arguments ?? {});
-                let content;
-                switch (toolName) {
-                    case 'codehere_trust':
-                        content = handleTrust(toolParams);
-                        break;
-                    case 'codehere_scan':
-                        content = handleScan(toolParams);
-                        break;
-                    case 'codehere_review':
-                        content = handleReview(toolParams);
-                        break;
-                    case 'codehere_audit':
-                        content = handleAudit(toolParams);
-                        break;
-                    default:
-                        return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${toolName}` } };
-                }
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: { content: [{ type: 'text', text: content }] },
-                };
-            }
-            case 'ping':
-                return { jsonrpc: '2.0', id, result: {} };
-            default:
-                return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${req.method}` } };
-        }
-    }
-    catch (e) {
-        return { jsonrpc: '2.0', id, error: { code: -32603, message: String(e) } };
-    }
-}
-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;
-    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 ?? '';
-        const isReadOnlyPublic = url === '/health' ||
-            url === '/api/version' ||
-            url === '/api/tasks' ||
-            url === '/api/host-sessions' ||
-            url.startsWith('/api/host-sessions/') ||
-            url.startsWith('/api/audit/stats') ||
-            url.startsWith('/api/readiness/agents');
-        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;
-        }
-        // 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;
-        }
-        // History / audit feed (what we built Day 0; now secondary)
-        if (req.method === 'GET' && (req.url === '/history' || req.url === '/history/')) {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(withDevElu(HISTORY_HTML));
-            return;
-        }
-        // v0.6.0 M1 — project thread view; consumes /api/projects + /api/projects/:slug
-        if (req.method === 'GET' &&
-            (req.url === '/threads' || req.url === '/threads/' || req.url?.startsWith('/threads?'))) {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(withDevElu(THREAD_HTML));
-            return;
-        }
-        // Backwards-compat: /ui used to be the Mission Control audit view — now at /history
-        if (req.method === 'GET' && (req.url === '/ui' || req.url === '/ui/')) {
-            res.writeHead(302, { Location: '/history' });
-            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);
-            const ping = setInterval(() => res.write(': ping\n\n'), 15000);
-            req.on('close', () => {
-                clearInterval(ping);
-                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();
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    valid: r.valid,
-                    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: true, totalEntries: 0, chainedEntries: 0, legacyEntries: 0, errors: [] }));
-            }
-            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;
-        }
-        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,
-                chainValid: chain.valid,
-                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).
-        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;
-                    }
-                    appendOverrideAudit('user_override', {
-                        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;
-                            }
-                            if (e.overrideReason === 'user_override' && 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;
-                    }
-                    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;
-        }
-        // ── 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 {
-                const projects = listProjects();
-                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;
-                }
-                const thread = readProjectThread(slug);
-                if (!thread) {
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'project_not_found', slug }));
-                    return;
-                }
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ thread }));
-            }
-            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;
-        }
-        // ── 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 = [];
-                        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;
-                                }
-                            }
-                            // 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 });
-                                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;
-                            }
-                            // 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;
-                                }
-                            }
-                            const budgetForSpawn = loadBudget();
-                            if (budgetForSpawn.dailyUsd !== null) {
-                                const probe = estimateCostUsd(agentId, { inputTokens: 1, outputTokens: 1 });
-                                const isPaidSpawn = probe > 0;
-                                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 session = manager.spawn(promptForSpawn, agentId, { cwd });
-                            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') {
-                const spawned = manager.list().map((s) => {
-                    const completedAt = manager.getCompletedAt(s.sessionId);
-                    const finalReport = manager.getFinalReport(s.sessionId);
-                    const cwd = manager.getCwd(s.sessionId);
-                    const continuedFrom = manager.getContinuedFrom(s.sessionId);
-                    const continuedAs = manager.getContinuedAs(s.sessionId);
-                    const failedReport = manager.hasFailedReport(s.sessionId);
-                    const stalledReason = manager.getStallReason(s.sessionId);
-                    // F-07 · verifier-agent block · run claim vs reality on every task.
-                    // Pure function, no I/O, runs sync · cheap to do per request.
-                    // The UI renders the verdict + findings inline below the Summary.
-                    const verifyResult = verifyClaim({
-                        summary: finalReport?.summary,
-                        artifacts: s.artifacts,
-                        steps: s.steps,
-                    });
-                    return {
-                        sessionId: s.sessionId,
-                        prompt: s.prompt,
-                        startedAt: s.startedAt,
-                        status: s.status,
-                        agent: s.agent,
-                        steps: s.steps ?? [],
-                        artifacts: s.artifacts,
-                        ...(completedAt !== undefined ? { completedAt, durationMs: completedAt - s.startedAt } : {}),
-                        ...(finalReport !== undefined ? { finalReport } : {}),
-                        ...(failedReport ? { failedReport: true } : {}),
-                        ...(stalledReason ? { stalledReason } : {}),
-                        verifyResult,
-                        canAppendMessage: s.canAppendMessage === true,
-                        ...(cwd !== undefined ? { cwd } : {}),
-                        ...(continuedFrom !== undefined ? { continuedFrom } : {}),
-                        ...(continuedAs !== undefined ? { continuedAs } : {}),
-                        provenance: 'spawned',
-                    };
-                });
-                const activeAgents = manager.listActiveAgents();
-                // F-07 · attach verifyResult to persisted records too · same logic.
-                const persisted = manager.listPersisted().map((p) => ({
-                    ...p,
-                    verifyResult: verifyClaim({
-                        summary: p.finalReport?.summary,
-                        artifacts: p.artifacts,
-                        steps: p.steps,
-                    }),
-                }));
-                // 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,
-                    persisted,
-                    activeAgents,
-                    lastEditAt,
-                    sessions: spawned, // 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;
-            }
-            // 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;
-                const session = manager.get(sessionId);
-                if (!session) {
-                    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 {
-                                    const replyCwd = manager.getCwd(sessionId);
-                                    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') {
-            if (req.method !== 'POST') {
-                res.writeHead(405, { 'Content-Type': 'application/json', Allow: 'POST' });
-                res.end(JSON.stringify({ error: 'MCP endpoint accepts POST only', method: req.method }));
-                return;
-            }
-            (async () => {
-                try {
-                    const body = await readBody(req, res);
-                    try {
-                        const mcpReq = JSON.parse(body);
-                        const mcpRes = dispatch(mcpReq);
-                        res.writeHead(200, {
-                            'Content-Type': 'application/json',
-                            'Access-Control-Allow-Origin': 'http://localhost',
-                        });
-                        res.end(JSON.stringify(mcpRes));
-                    }
-                    catch {
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
-                    }
-                }
-                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],
-                    };
-                });
-                // v0.8 S5 · public-by-URL adapters appear with status='available'
-                // (no Connect button needed · they work out of the box).
-                const oauthIds = new Set(oauthItems.map((i) => i.id));
-                const reg = getDefaultRegistry();
-                const noAuthItems = [...reg.bySchemeOnly.values()]
-                    .filter((s) => !oauthIds.has(s.id))
-                    .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, ...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;
-        }
-        if (req.url === '/api/audit/verify' && req.method === 'GET') {
-            try {
-                const r = verifyAuditChain(AUDIT_FILE);
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({
-                    path: AUDIT_FILE,
-                    valid: r.valid,
-                    totalEntries: r.totalEntries,
-                    chainedEntries: r.chainedEntries,
-                    legacyEntries: r.legacyEntries,
-                    errors: r.errors,
-                }));
-            }
-            catch (e) {
-                console.error('[/api/audit/verify] failed:', e);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Failed to verify audit chain' }));
-            }
-            return;
-        }
-        // 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,
-                    exporter: { codehereVersion: '0.7.0' },
-                    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 home = process.env.CODEHERE_HOME || homedir();
-                    const sessionsPath = join(home, '.codehere', 'sessions.jsonl');
-                    const fs = await import('fs');
-                    fs.mkdirSync(dirname(sessionsPath), { recursive: true });
-                    const lines = [];
-                    lines.push(JSON.stringify({
-                        t: 'spawned',
-                        id: ses.sessionId,
-                        agent: ses.agent,
-                        prompt: ses.prompt,
-                        cwd: ses.cwd,
-                        startedAt: ses.startedAt,
-                    }));
-                    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');
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        status: 'imported',
-                        sessionId: ses.sessionId,
-                        fingerprint: shortFingerprint(finalBundle.publicKey),
-                    }));
-                }
-                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.
-                    raw.id = typeof raw.id === 'string' && raw.id ? 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];
-        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"/>
-<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="/threads"><span class="route-name">Project threads</span><span class="route-path">/threads</span></a>
-    <a class="route" href="/history"><span class="route-name">Audit history</span><span class="route-path">/history</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 */
-            }
-            // 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"><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