codehere 0.6.0-alpha.1 → 0.6.1

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

@@ -26,12 +26,13 @@ import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
 import { scanPayload, calculateRiskScore, AUDIT_FILE, verifyAuditChain, } from '../hooks/claude-sdk-hook.js';
 import { getVersion } from '../../utils/version.js';
 import { TASK_HTML, HISTORY_HTML, THREAD_HTML } from './ui-page.js';
+import { TASK_HTML_V2 } from './ui-page-v2.js';
 import { SessionManager, availableAgents, readinessForAllAgents, getAdapter, allAdapters, } from '../orchestration/session-manager.js';
 import { isAbsolute } from 'path';
 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 } from 'crypto';
+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';
@@ -299,15 +300,39 @@ function dispatch(req) {
         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
+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')));
+    });
+}
 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) => {
-        // Auth check
+        // Auth check — timing-safe comparison
         if (token) {
             const authHeader = req.headers.authorization ?? '';
-            if (authHeader !== `Bearer ${token}`) {
+            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;
@@ -319,8 +344,14 @@ export function startMCPServer(options = {}) {
             res.end(JSON.stringify({ status: 'ok', server: 'codehere-mcp', version: getVersion(), tools: TOOLS.length }));
             return;
         }
-        // v0.3 primary UI: task intake + active sessions
+        // 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 dashboard (legacy — at /v1)
+        if (req.method === 'GET' && (req.url === '/v1' || req.url === '/v1/')) {
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end(withDevElu(TASK_HTML));
             return;
@@ -394,6 +425,58 @@ export function startMCPServer(options = {}) {
             });
             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(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' });
@@ -444,41 +527,46 @@ export function startMCPServer(options = {}) {
             return;
         }
         if (req.method === 'POST' && req.url === '/api/permissions') {
-            let body = '';
-            req.on('data', (c) => { body += c; });
-            req.on('end', () => {
-                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;
-                }
+            (async () => {
                 try {
-                    const result = addPermissionEntry({ cwd, pattern, bucket, reason: parsed.reason });
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(result));
+                    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 (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?')) {
@@ -748,49 +836,48 @@ export function startMCPServer(options = {}) {
         // 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];
-            let body = '';
-            req.on('data', (c) => {
-                body += c;
-            });
-            req.on('end', () => {
-                let parsed;
+            (async () => {
                 try {
-                    const raw = JSON.parse(body);
-                    // JSON.parse accepts the literal `null` and primitive bodies as
-                    // valid JSON. Reject anything that isn't a plain object — otherwise
-                    // the .title access below throws and crashes the request callback.
-                    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+                    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' }));
+                        res.end(JSON.stringify({ error: 'invalid_json' }));
                         return;
                     }
-                    parsed = raw;
+                    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 {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'invalid_json' }));
-                    return;
+                    if (process.env.CODEHERE_DEBUG === '1')
+                        console.error('[codehere] readBody rejected (oversized or aborted)');
                 }
-                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) {
-                    // 404 = project missing; 500 = fs append failed; 400 = validation.
-                    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() }));
-            });
+            })();
             return;
         }
         // ── F1 task orchestration routes ─────────────────────────────────────────
@@ -808,218 +895,208 @@ export function startMCPServer(options = {}) {
             // 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') {
-                let body = '';
-                req.on('data', (c) => { body += c; });
-                req.on('end', () => {
-                    let parsed;
+                (async () => {
                     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;
+                        const body = await readBody(req, res);
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(body || '{}');
                         }
-                        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;
+                        catch (e) {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
+                            return;
                         }
-                        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 });
+                        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;
                             }
-                        }
-                        // 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)) {
+                            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({
-                                    error: 'daily_budget_exhausted',
-                                    agent: agentId,
-                                    spentTodayUsd: batchSpendNow,
-                                    dailyBudgetUsd: batchBudget.dailyUsd,
+                                    sessionId: session.sessionId,
+                                    agent: session.agent,
+                                    status: session.status,
+                                    startedAt: session.startedAt,
                                 });
-                                continue;
+                            }
+                            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 });
                             }
                         }
-                        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 }));
                     }
-                    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') {
-                let body = '';
-                req.on('data', (c) => {
-                    body += c;
-                });
-                req.on('end', () => {
-                    // 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;
-                    }
+                (async () => {
                     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;
-                        }
-                        // 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 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 || '{}');
                         }
-                        const validAgentIds = new Set(allAdapters().map((a) => a.id));
-                        const agentId = typeof agent === 'string' && agent.length > 0 ? agent : 'conductor';
-                        if (!validAgentIds.has(agentId)) {
+                        catch (e) {
                             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],
-                            }));
+                            res.end(JSON.stringify({ error: 'Invalid JSON body', detail: String(e) }));
                             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)) {
+                        try {
+                            const { prompt, cwd, agent } = parsed;
+                            if (!prompt || typeof prompt !== 'string') {
                                 res.writeHead(400, { 'Content-Type': 'application/json' });
-                                res.end(JSON.stringify({ error: 'cwd must be an absolute path with no NUL bytes' }));
+                                res.end(JSON.stringify({ error: 'prompt (string) required' }));
                                 return;
                             }
-                        }
-                        // v0.6 S3 slice 2 — pre-spawn budget gate. Blocks paid spawns
-                        // when today's estimated spend already meets the user's daily
-                        // ceiling. Free-tier specialists (gemini, opencode) always pass:
-                        // "don't let me spend more, but free is fine" matches user intent.
-                        // Conductor is treated as paid because it routes to whatever's
-                        // available (typically claude-code). Per
-                        // claim_market_position v3 cost-bounded-execution edge.
-                        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,
-                                    }));
+                            // 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;
+                                    }
+                                }
+                            }
+                            const session = manager.spawn(prompt, 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,
+                            }));
                         }
-                        const session = manager.spawn(prompt, 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,
-                            // Iter 13 — include canAppendMessage so the freshly-attached
-                            // session card can correctly enable/disable reply input on the
-                            // first render. Without this, ALL just-spawned sessions render
-                            // with reply disabled even when the adapter supports it.
-                            canAppendMessage: session.canAppendMessage === true,
-                        }));
-                    }
-                    catch (e) {
-                        // Spawn-phase failure. Distinguish the cross-vendor pre-prompt
-                        // scan refusal (#110) — actionable safety block — from generic
-                        // adapter / install / SessionManager errors. The pre-prompt
-                        // case gets 422 (Unprocessable Entity, "we understood but
-                        // refused") + a structured 'pre_prompt_blocked' code so the
-                        // web UI can surface a recovery affordance.
-                        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;
+                        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 }));
                         }
-                        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) => {
-                    // Bug 2 sister-fix (May 2): include completedAt for in-memory exited
-                    // sessions so the UI can compute duration. TaskSession interface
-                    // intentionally lacks completedAt; SessionManager tracks it separately
-                    // in completedAtBySession map (populated when exit event fires).
                     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);
                     return {
                         sessionId: s.sessionId,
                         prompt: s.prompt,
@@ -1030,13 +1107,11 @@ export function startMCPServer(options = {}) {
                         artifacts: s.artifacts,
                         ...(completedAt !== undefined ? { completedAt, durationMs: completedAt - s.startedAt } : {}),
                         ...(finalReport !== undefined ? { finalReport } : {}),
-                        // Iter 12 — surface canAppendMessage so the UI knows whether to
-                        // render the reply input or a disabled "follow-up unsupported" state.
+                        ...(failedReport ? { failedReport: true } : {}),
                         canAppendMessage: s.canAppendMessage === true,
-                        // v0.6.x Slack-shape spike — surface cwd so the dashboard's
-                        // "Continue thread" intake button can find the most recent
-                        // in-memory session for the current folder.
                         ...(cwd !== undefined ? { cwd } : {}),
+                        ...(continuedFrom !== undefined ? { continuedFrom } : {}),
+                        ...(continuedAs !== undefined ? { continuedAs } : {}),
                         provenance: 'spawned',
                     };
                 });
@@ -1152,54 +1227,51 @@ export function startMCPServer(options = {}) {
                         res.end(JSON.stringify({ error: `Agent ${session.agent} does not support follow-up messages yet.` }));
                         return;
                     }
-                    let body = '';
-                    req.on('data', (c) => {
-                        body += c.toString('utf-8');
-                    });
-                    req.on('end', async () => {
+                    (async () => {
                         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();
-                            // v0.6.x — forward-mirror the reply turn into the project thread
-                            // so /threads sees follow-ups as visible chronological turns
-                            // (not just the original spawn). Best-effort: mirror failures
-                            // never break the reply path.
+                            const body = await readBody(req, res);
                             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,
-                                    });
+                                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 {
-                                /* mirror is best-effort */
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                res.writeHead(500, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: msg }));
                             }
-                            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;
                 }
             }
@@ -1207,6 +1279,67 @@ export function startMCPServer(options = {}) {
             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') {
@@ -1215,25 +1348,28 @@ export function startMCPServer(options = {}) {
                 res.end(JSON.stringify({ error: 'MCP endpoint accepts POST only', method: req.method }));
                 return;
             }
-            let body = '';
-            req.on('data', (chunk) => {
-                body += chunk;
-            });
-            req.on('end', () => {
+            (async () => {
                 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));
+                    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 {
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                    if (process.env.CODEHERE_DEBUG === '1')
+                        console.error('[codehere] readBody rejected (oversized or aborted)');
                 }
-            });
+            })();
             return;
         }
         // /api/version — small completeness item for ops monitoring (rc.17).