@supen-ai/cli 0.1.6

package/daemon/dist/http/routes/system.js

@@ -0,0 +1,2676 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { createRequire } from 'module';
+import { spawn, spawnSync } from 'child_process';
+import { DAEMON_HOSTNAME, DEFAULT_MODEL, MODELS_REGISTRY, SUPEN_HOME, reloadModelsRegistry, } from '../../core/config.js';
+import { readConfigSummary, readConfigYamlFile, writeConfigYamlFile, } from '../../core/env.js';
+import { readSpaceEnvMap, updateSpaceEnvMap, withSupenLlmEnv } from '../../core/space-env.js';
+import { readCodexSubscription } from '../../core/codex-subscription.js';
+import { buildHubSnapshotForSpace } from '../../core/hub-snapshot.js';
+import { readEnrollmentState, createEnrollmentToken, verifyEnrollmentToken, setTrustState } from '../../core/enrollment.js';
+import { getGatewayInstance, getLlmToken } from '../../core/gateway.js';
+import { normalizeGatewayUplinkUrl, readGatewayConfig, writeGatewayConfig, } from '../../core/gateway-config.js';
+import { ensureSession, getAllAgents, getDailyUsage, getGlobalUsage, getSessionsForAgent, getSessionUiEvents, updateSessionBackendDriverId, updateSessionSdkId, } from '../../core/store.js';
+import { listMcpEnvKeys, listMcpServers } from '../../mcp/default-servers.js';
+import { getMcpEnvOverrides, updateMcpEnvOverrides } from '../../mcp/settings.js';
+import { getMcpManager } from '../../mcp/index.js';
+import { buildDaemonOpenApiSpec } from '../../channels/http-routes.js';
+import { writeJson, writeProtocolError, readJsonBody } from '../response.js';
+import { listRecentThreadEventsAfter, readThreadEventLogHead, } from '../../core/thread-event-log.js';
+import { addThreadStreamClient, removeThreadStreamClient, writeThreadStreamEvent } from '../thread-stream.js';
+const DEFAULT_TOKEN_TTL_MINUTES = 20;
+const SPACE_LOG_EVENT_LIMIT = 200;
+const SPACE_LOG_STREAM_POLL_MS = 1000;
+const SPACE_LOG_STREAM_PING_MS = 15000;
+const MIRRORED_THREAD_LIMIT = 80;
+const MIRRORED_THREAD_HISTORY_LIMIT = 100;
+const MIRRORED_THREAD_HISTORY_MAX_BYTES = 64 * 1024 * 1024;
+const MIRRORED_THREAD_TEXT_LIMIT = 48_000;
+const MIRRORED_THREAD_TOOL_STRING_LIMIT = 24_000;
+const MIRRORED_THREAD_OBJECT_DEPTH_LIMIT = 4;
+const MIRRORED_THREAD_OBJECT_KEY_LIMIT = 80;
+const MIRRORED_THREAD_OBJECT_ARRAY_LIMIT = 80;
+const MIRRORED_THREAD_INLINE_DATA_URL_LIMIT = 120_000;
+const MIRRORED_THREAD_STREAM_REPLAY_LIMIT = 500;
+const MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES = 8 * 1024 * 1024;
+const MIRRORED_THREAD_RUNNING_LEASE_MS = 30 * 60 * 1000;
+const MIRRORED_THREAD_HISTORY_CHUNK_BYTES = 1024 * 1024;
+const require = createRequire(import.meta.url);
+function readSqliteRows(dbPath, query) {
+    try {
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        try {
+            return db.prepare(query).all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function gatewayUplinkStatus(config = readGatewayConfig()) {
+    const gatewayUrl = (config.gateway_url || '').trim();
+    return {
+        configured: Boolean(gatewayUrl),
+        gateway_url: gatewayUrl || null,
+        connected: Boolean(getGatewayInstance()?.isConnected()),
+        env_override: Boolean(process.env.SUPEN_GATEWAY_URL),
+        disabled_by_env: process.env.SUPEN_DISABLE_GATEWAY_UPLINK === 'true' ||
+            process.env.SUPEN_DISABLE_GATEWAY_UPLINK === '1',
+    };
+}
+function resolveHostTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+}
+function truncateText(value, max = 160) {
+    const trimmed = value.trim();
+    return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}…`;
+}
+function truncateStreamDelta(value, max = 160) {
+    return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
+function currentSpaceId() {
+    return (process.env.SUPEN_SPACE_ID || '').trim() || 'local';
+}
+function summarizeStreamEvent(raw) {
+    const inner = raw.event && typeof raw.event === 'object'
+        ? raw.event
+        : null;
+    if (!inner)
+        return null;
+    if (inner.type === 'content_block_delta' && inner.delta?.type === 'text_delta') {
+        const text = typeof inner.delta.text === 'string' ? inner.delta.text : '';
+        return text ? { category: 'assistant', summary: truncateStreamDelta(text) } : null;
+    }
+    if (inner.type === 'content_block_delta' && inner.delta?.type === 'thinking_delta') {
+        const text = typeof inner.delta.thinking === 'string' ? inner.delta.thinking : '';
+        return text ? { category: 'reasoning', summary: truncateStreamDelta(text) } : null;
+    }
+    if (inner.type === 'content_block_start' && inner.content_block?.type === 'tool_use') {
+        const toolName = typeof inner.content_block.name === 'string' ? inner.content_block.name : 'tool';
+        return { category: 'tool', summary: `Requested tool: ${toolName}` };
+    }
+    if (inner.type === 'content_block_delta' && inner.delta?.type === 'input_json_delta') {
+        const partialJson = typeof inner.delta.partial_json === 'string' ? inner.delta.partial_json : '';
+        return partialJson ? { category: 'tool input', summary: truncateStreamDelta(partialJson) } : null;
+    }
+    if (inner.type === 'message_delta' && inner.delta?.stop_reason === 'tool_use') {
+        return { category: 'tool', summary: 'Waiting for tool result' };
+    }
+    return null;
+}
+function summarizeToolResultContent(content) {
+    if (typeof content === 'string')
+        return truncateText(content);
+    if (!Array.isArray(content))
+        return null;
+    const text = content
+        .map((item) => {
+        if (typeof item === 'string')
+            return item;
+        if (item && typeof item === 'object' && typeof item.text === 'string') {
+            return item.text;
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+    return text.trim() ? truncateText(text) : null;
+}
+function summarizeAppServerEvent(raw) {
+    const method = typeof raw.method === 'string' ? raw.method : '';
+    if (!method)
+        return null;
+    const params = raw.params && typeof raw.params === 'object'
+        ? raw.params
+        : {};
+    if (method === 'warning') {
+        const message = typeof params.message === 'string' ? params.message : 'Warning';
+        return { category: 'warning', summary: truncateText(message) };
+    }
+    if (method === 'thread/started') {
+        const thread = params.thread && typeof params.thread === 'object'
+            ? params.thread
+            : {};
+        const cwd = typeof thread.cwd === 'string' ? thread.cwd : '';
+        return { category: 'thread.started', summary: cwd ? `started in ${cwd}` : 'started' };
+    }
+    if (method === 'thread/status/changed') {
+        const status = params.status && typeof params.status === 'object'
+            ? params.status
+            : {};
+        const type = typeof status.type === 'string' ? status.type : 'changed';
+        return { category: 'thread.status', summary: type };
+    }
+    if (method === 'turn/started') {
+        return { category: 'turn.started', summary: 'started' };
+    }
+    if (method === 'turn/completed' || method === 'turn/failed' || method === 'turn/cancelled') {
+        const turn = params.turn && typeof params.turn === 'object'
+            ? params.turn
+            : {};
+        const status = typeof turn.status === 'string' ? turn.status : method.slice('turn/'.length);
+        const durationMs = typeof turn.durationMs === 'number' ? turn.durationMs : null;
+        const duration = durationMs !== null ? ` in ${(durationMs / 1000).toFixed(1)}s` : '';
+        return { category: method.replace('/', '.'), summary: `${status}${duration}` };
+    }
+    if (method === 'mcpServer/startupStatus/updated') {
+        const name = typeof params.name === 'string' ? params.name : 'mcp server';
+        const status = typeof params.status === 'string' ? params.status : 'updated';
+        const error = typeof params.error === 'string' && params.error.trim() ? `: ${params.error.trim()}` : '';
+        return { category: 'mcp.status', summary: truncateText(`${name} ${status}${error}`) };
+    }
+    if (method === 'hook/started' || method === 'hook/completed') {
+        const run = params.run && typeof params.run === 'object'
+            ? params.run
+            : {};
+        const eventName = typeof run.eventName === 'string' ? run.eventName : 'hook';
+        const status = typeof run.status === 'string' ? run.status : method.slice('hook/'.length);
+        const durationMs = typeof run.durationMs === 'number' ? run.durationMs : null;
+        const duration = durationMs !== null ? ` in ${durationMs}ms` : '';
+        return { category: method.replace('/', '.'), summary: `${eventName} ${status}${duration}` };
+    }
+    if (method === 'item/started' || method === 'item/completed') {
+        const item = params.item && typeof params.item === 'object'
+            ? params.item
+            : {};
+        const itemType = typeof item.type === 'string' ? item.type : 'item';
+        if (itemType === 'agentMessage') {
+            return { category: method.replace('/', '.'), summary: method === 'item/started' ? 'assistant response started' : 'assistant response completed' };
+        }
+        if (itemType === 'userMessage') {
+            return { category: method.replace('/', '.'), summary: method === 'item/started' ? 'user message received' : 'user message accepted' };
+        }
+        return { category: method.replace('/', '.'), summary: `${itemType} ${method.slice('item/'.length)}` };
+    }
+    if (method === 'item/commandExecution/outputDelta') {
+        const delta = typeof params.delta === 'string' ? params.delta.trim() : '';
+        return {
+            category: 'command.output',
+            summary: delta ? truncateText(delta) : 'output received',
+        };
+    }
+    if (method === 'account/rateLimits/updated') {
+        return { category: 'rate_limits', summary: 'updated' };
+    }
+    return { category: method.replace('/', '.'), summary: 'received' };
+}
+function summarizeUiChunk(chunk) {
+    const type = typeof chunk.type === 'string' ? chunk.type : '';
+    if (type === 'text-delta') {
+        const delta = typeof chunk.delta === 'string' ? chunk.delta : '';
+        return delta ? { category: 'assistant', summary: truncateStreamDelta(delta) } : null;
+    }
+    if (type === 'reasoning-delta') {
+        const delta = typeof chunk.delta === 'string' ? chunk.delta : '';
+        return delta ? { category: 'reasoning', summary: truncateStreamDelta(delta) } : null;
+    }
+    if (type === 'error') {
+        const errorText = typeof chunk.errorText === 'string'
+            ? chunk.errorText
+            : typeof chunk.message === 'string'
+                ? chunk.message
+                : 'Unknown error';
+        return { category: 'error', summary: truncateText(errorText) };
+    }
+    if (type === 'data-supen-event') {
+        const data = chunk.data && typeof chunk.data === 'object'
+            ? chunk.data
+            : {};
+        const eventType = typeof data.eventType === 'string'
+            ? data.eventType
+            : typeof data.type === 'string'
+                ? data.type
+                : 'event';
+        const subtype = typeof data.subtype === 'string' ? data.subtype : '';
+        const raw = data.raw && typeof data.raw === 'object'
+            ? data.raw
+            : {};
+        if (raw.type === 'stream_event') {
+            return summarizeStreamEvent(raw);
+        }
+        if (typeof raw.method === 'string') {
+            return summarizeAppServerEvent(raw);
+        }
+        if (raw.type === 'user' && Array.isArray(raw.message?.content)) {
+            for (const block of raw.message.content) {
+                if (block?.type !== 'tool_result')
+                    continue;
+                const summary = summarizeToolResultContent(block.content);
+                if (summary)
+                    return { category: 'tool result', summary };
+            }
+        }
+        const detail = typeof raw.status === 'string'
+            ? raw.status
+            : typeof raw.message === 'string'
+                ? raw.message
+                : typeof raw.error === 'string'
+                    ? raw.error
+                    : '';
+        return detail
+            ? { category: [eventType, subtype].filter(Boolean).join('.'), summary: truncateText(detail) }
+            : null;
+    }
+    return null;
+}
+function recordValue(record, keys) {
+    for (const key of keys) {
+        if (record[key] !== undefined && record[key] !== null)
+            return record[key];
+    }
+    return null;
+}
+function numberValue(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function labelForQuotaWindow(key, record) {
+    const explicit = recordValue(record, ['label', 'name', 'window', 'period', 'type']);
+    if (typeof explicit === 'string' && explicit.trim())
+        return explicit.trim();
+    return key
+        .replace(/[_-]+/g, ' ')
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function quotaWindowFromRecord(key, record) {
+    const used = numberValue(recordValue(record, ['used', 'current', 'consumed', 'usage', 'used_tokens', 'tokens_used']));
+    const limit = numberValue(recordValue(record, ['limit', 'quota', 'total', 'max', 'cap']));
+    const remaining = numberValue(recordValue(record, ['remaining', 'left', 'available']));
+    const percent = numberValue(recordValue(record, ['percent', 'percentage', 'used_percent', 'usage_percent']));
+    const resetRaw = recordValue(record, ['reset_at', 'resets_at', 'resetAt', 'resetsAt', 'reset']);
+    const reset_at = typeof resetRaw === 'string' && resetRaw.trim() ? resetRaw.trim() : null;
+    if (used === null && limit === null && remaining === null && percent === null && !reset_at)
+        return null;
+    return {
+        label: labelForQuotaWindow(key, record),
+        used,
+        limit,
+        remaining,
+        percent: percent !== null
+            ? percent
+            : (used !== null && limit && limit > 0 ? Math.round((used / limit) * 1000) / 10 : null),
+        reset_at,
+    };
+}
+function normalizeQuotaWindows(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value)) {
+        return value
+            .map((entry, index) => entry && typeof entry === 'object'
+            ? quotaWindowFromRecord(`Quota ${index + 1}`, entry)
+            : null)
+            .filter((entry) => Boolean(entry));
+    }
+    const record = value;
+    const direct = quotaWindowFromRecord('Quota', record);
+    const nested = Object.entries(record)
+        .map(([key, nestedValue]) => nestedValue && typeof nestedValue === 'object'
+        ? quotaWindowFromRecord(key, nestedValue)
+        : null)
+        .filter((entry) => Boolean(entry));
+    return nested.length > 0 ? nested : (direct ? [direct] : []);
+}
+function quotaPayloadFromEvent(raw) {
+    const params = raw.params && typeof raw.params === 'object'
+        ? raw.params
+        : {};
+    return (params.rateLimits ??
+        params.rate_limits ??
+        params.limits ??
+        params.quota ??
+        params.quotas ??
+        params);
+}
+function extractQuotaEvent(event) {
+    const chunk = event.chunk && typeof event.chunk === 'object' ? event.chunk : {};
+    const data = chunk.data && typeof chunk.data === 'object'
+        ? chunk.data
+        : {};
+    const raw = data.raw && typeof data.raw === 'object'
+        ? data.raw
+        : {};
+    if (raw.method !== 'account/rateLimits/updated')
+        return null;
+    const windows = normalizeQuotaWindows(quotaPayloadFromEvent(raw));
+    return {
+        updated_at: event.timestamp || new Date().toISOString(),
+        windows,
+    };
+}
+function readLatestSpaceQuotaStatus() {
+    const sessions = getAllAgents()
+        .flatMap((agent) => getSessionsForAgent(agent.agent_id).map((session) => ({
+        agent_id: agent.agent_id,
+        session_id: session.session_id,
+    })));
+    const latest = sessions
+        .flatMap((session) => getSessionUiEvents(session.agent_id, session.session_id, 200)
+        .map((event) => extractQuotaEvent(event)))
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => a.updated_at.localeCompare(b.updated_at))
+        .at(-1);
+    return {
+        source: latest ? 'codex' : null,
+        updated_at: latest?.updated_at ?? null,
+        windows: latest?.windows ?? [],
+    };
+}
+function localAgentHome() {
+    const configured = (process.env.CODEX_HOME || '').trim();
+    return configured || path.join(os.homedir(), '.codex');
+}
+function parseJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readRecentJsonlLines(filePath, maxBytes = MIRRORED_THREAD_HISTORY_MAX_BYTES) {
+    const safeMaxBytes = Math.max(1, Math.min(Math.floor(maxBytes), MIRRORED_THREAD_HISTORY_MAX_BYTES));
+    const size = fs.statSync(filePath).size;
+    if (size <= safeMaxBytes) {
+        return fs.readFileSync(filePath, 'utf-8').split(/\r?\n/).filter(Boolean);
+    }
+    const readLength = Math.min(size, safeMaxBytes);
+    const start = size - readLength;
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(readLength);
+        const bytesRead = fs.readSync(fd, buffer, 0, readLength, start);
+        let text = buffer.subarray(0, bytesRead).toString('utf-8');
+        if (start > 0) {
+            const firstLineEnd = text.indexOf('\n');
+            if (firstLineEnd < 0)
+                return [];
+            text = text.slice(firstLineEnd + 1);
+        }
+        return text.split(/\r?\n/).filter(Boolean);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function isCodexHistoryMessageLine(line) {
+    const parsed = parseJsonLine(line);
+    const payload = parsed?.payload && typeof parsed.payload === 'object'
+        ? parsed.payload
+        : {};
+    return ((parsed?.type === 'event_msg' && payload.type === 'user_message') ||
+        (parsed?.type === 'response_item' && payload.type === 'message'));
+}
+function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRRORED_THREAD_HISTORY_MAX_BYTES) {
+    const safeTargetMessages = Math.max(1, Math.min(Math.floor(targetMessages), 501));
+    const safeMaxBytes = Math.max(1, Math.min(Math.floor(maxBytes), MIRRORED_THREAD_HISTORY_MAX_BYTES));
+    const size = fs.statSync(filePath).size;
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        let position = size;
+        let scannedBytes = 0;
+        let leadingPartial = '';
+        let messageCount = 0;
+        let collected = [];
+        while (position > 0 && scannedBytes < safeMaxBytes && messageCount < safeTargetMessages) {
+            const readLength = Math.min(MIRRORED_THREAD_HISTORY_CHUNK_BYTES, position, safeMaxBytes - scannedBytes);
+            position -= readLength;
+            scannedBytes += readLength;
+            const buffer = Buffer.alloc(readLength);
+            const bytesRead = fs.readSync(fd, buffer, 0, readLength, position);
+            const text = `${buffer.subarray(0, bytesRead).toString('utf-8')}${leadingPartial}`;
+            const lines = text.split(/\r?\n/);
+            leadingPartial = lines.shift() || '';
+            if (position === 0 && leadingPartial) {
+                lines.unshift(leadingPartial);
+                leadingPartial = '';
+            }
+            const completeLines = lines.filter(Boolean);
+            for (const line of completeLines) {
+                if (isCodexHistoryMessageLine(line))
+                    messageCount += 1;
+            }
+            collected = [...completeLines, ...collected];
+        }
+        return collected.filter(Boolean);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readThreadIndex(limit) {
+    const indexPath = path.join(localAgentHome(), 'session_index.jsonl');
+    if (!fs.existsSync(indexPath))
+        return [];
+    const lines = fs.readFileSync(indexPath, 'utf-8').split(/\r?\n/).filter(Boolean);
+    const byId = new Map();
+    for (const line of lines) {
+        const parsed = parseJsonLine(line);
+        const id = typeof parsed?.id === 'string' ? parsed.id.trim() : '';
+        const title = typeof parsed?.thread_name === 'string' ? parsed.thread_name.trim() : '';
+        const updatedAt = typeof parsed?.updated_at === 'string' ? parsed.updated_at.trim() : '';
+        if (!id || !updatedAt)
+            continue;
+        byId.set(id, {
+            id,
+            thread_name: title || 'New Task',
+            updated_at: updatedAt,
+        });
+    }
+    return Array.from(byId.values())
+        .sort((a, b) => b.updated_at.localeCompare(a.updated_at))
+        .slice(0, limit);
+}
+function readThreadIndexEntry(threadId) {
+    return readThreadIndex(1000).find((entry) => entry.id === threadId) || null;
+}
+function readThreadStateEntry(threadId) {
+    return readThreadStateEntries(1000).find((entry) => entry.id === threadId) || null;
+}
+function isoFromMillis(value) {
+    const ms = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(ms) || ms <= 0)
+        return null;
+    return new Date(ms).toISOString();
+}
+function readThreadStateEntries(limit) {
+    const dbPath = path.join(localAgentHome(), 'state_5.sqlite');
+    if (!fs.existsSync(dbPath))
+        return [];
+    const query = `
+    select id, title, cwd, updated_at, updated_at_ms
+    from threads
+    where archived = 0
+      and coalesce(thread_source, 'user') = 'user'
+    order by coalesce(updated_at_ms, updated_at * 1000) desc, id desc
+    limit ${Math.max(1, Math.min(limit, 500))}
+  `;
+    let rows = readSqliteRows(dbPath, query);
+    if (!rows) {
+        const result = spawnSync('sqlite3', ['-json', dbPath, query], {
+            encoding: 'utf-8',
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        if (result.status !== 0 || !result.stdout.trim())
+            return [];
+        try {
+            rows = JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+    }
+    try {
+        return rows
+            .map((row) => {
+            const id = typeof row.id === 'string' ? row.id.trim() : '';
+            if (!id)
+                return null;
+            const updatedAtMs = typeof row.updated_at_ms === 'number'
+                ? row.updated_at_ms
+                : Number(row.updated_at) * 1000;
+            const updatedAt = isoFromMillis(updatedAtMs);
+            if (!updatedAt)
+                return null;
+            return {
+                id,
+                title: typeof row.title === 'string' && row.title.trim() ? row.title.trim() : 'New Task',
+                cwd: typeof row.cwd === 'string' && row.cwd.trim() ? row.cwd.trim() : null,
+                updated_at: updatedAt,
+                updated_at_ms: updatedAtMs,
+            };
+        })
+            .filter((entry) => Boolean(entry));
+    }
+    catch {
+        return [];
+    }
+}
+function walkSessionFiles(dir, out = new Map()) {
+    if (!fs.existsSync(dir))
+        return out;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkSessionFiles(fullPath, out);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+            continue;
+        const match = entry.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+        if (match?.[1])
+            out.set(match[1], fullPath);
+    }
+    return out;
+}
+function readFileHead(filePath, maxBytes = 64 * 1024) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(maxBytes);
+        const bytesRead = fs.readSync(fd, buffer, 0, maxBytes, 0);
+        return buffer.subarray(0, bytesRead).toString('utf-8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readFileTail(filePath, maxBytes = 256 * 1024) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const stat = fs.fstatSync(fd);
+        const length = Math.min(maxBytes, stat.size);
+        const buffer = Buffer.alloc(length);
+        fs.readSync(fd, buffer, 0, length, Math.max(0, stat.size - length));
+        return buffer.toString('utf-8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readThreadWorkspacePath(filePath) {
+    if (!filePath)
+        return null;
+    try {
+        const head = readFileHead(filePath);
+        for (const line of head.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const parsed = parseJsonLine(line);
+            if (parsed?.type !== 'session_meta')
+                continue;
+            const payload = parsed.payload && typeof parsed.payload === 'object'
+                ? parsed.payload
+                : {};
+            const cwd = typeof payload.cwd === 'string' ? payload.cwd.trim() : '';
+            return cwd || null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function normalizeThreadStatusToken(value) {
+    return typeof value === 'string'
+        ? value.trim().toLowerCase().replace(/[-_\s]/g, '')
+        : '';
+}
+const RUNNING_THREAD_STATUS_TOKENS = new Set([
+    'running',
+    'inprogress',
+    'processing',
+    'active',
+    'started',
+    'streaming',
+    'busy',
+    'claimed',
+]);
+const TERMINAL_THREAD_STATUS_TOKENS = new Set([
+    'completed',
+    'complete',
+    'succeeded',
+    'success',
+    'failed',
+    'error',
+    'cancelled',
+    'canceled',
+    'aborted',
+    'idle',
+]);
+function isRunningThreadStatusToken(value) {
+    return RUNNING_THREAD_STATUS_TOKENS.has(normalizeThreadStatusToken(value));
+}
+function isTerminalThreadStatusToken(value) {
+    return TERMINAL_THREAD_STATUS_TOKENS.has(normalizeThreadStatusToken(value));
+}
+function isFreshRunningActivity(timestampMs) {
+    if (!timestampMs)
+        return false;
+    return Date.now() - timestampMs <= MIRRORED_THREAD_RUNNING_LEASE_MS;
+}
+function timestampMsFromParsedLine(parsed) {
+    const timestamp = typeof parsed?.timestamp === 'string' ? parsed.timestamp : '';
+    if (!timestamp)
+        return null;
+    const timestampMs = Date.parse(timestamp);
+    return Number.isFinite(timestampMs) ? timestampMs : null;
+}
+function readThreadStatus(filePath) {
+    if (!filePath)
+        return 'idle';
+    try {
+        let sawUserTurn = false;
+        let completedAfterLastUser = false;
+        let lastRunningActivityMs = null;
+        const tail = readFileTail(filePath, MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES);
+        for (const line of tail.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const parsed = parseJsonLine(line);
+            const timestampMs = timestampMsFromParsedLine(parsed);
+            const payload = parsed?.payload && typeof parsed.payload === 'object'
+                ? parsed.payload
+                : {};
+            if (parsed?.type === 'event_msg') {
+                if (payload.type === 'task_started' || payload.type === 'user_message') {
+                    sawUserTurn = true;
+                    completedAfterLastUser = false;
+                    lastRunningActivityMs = timestampMs;
+                    continue;
+                }
+                if (payload.type === 'task_complete' ||
+                    payload.type === 'task_failed' ||
+                    payload.type === 'task_cancelled' ||
+                    payload.type === 'task_canceled' ||
+                    payload.type === 'turn_aborted') {
+                    completedAfterLastUser = true;
+                    continue;
+                }
+            }
+            if (parsed?.type === 'response_item' &&
+                payload.type === 'message' &&
+                payload.role === 'user') {
+                sawUserTurn = true;
+                completedAfterLastUser = false;
+                lastRunningActivityMs = timestampMs;
+                continue;
+            }
+            const raw = payload.raw && typeof payload.raw === 'object'
+                ? payload.raw
+                : null;
+            const method = typeof raw?.method === 'string' ? raw.method : '';
+            const params = raw?.params && typeof raw.params === 'object'
+                ? raw.params
+                : {};
+            if (method === 'turn/started') {
+                sawUserTurn = true;
+                completedAfterLastUser = false;
+                lastRunningActivityMs = timestampMs;
+                continue;
+            }
+            if (method === 'turn/completed' ||
+                method === 'turn/failed' ||
+                method === 'turn/cancelled' ||
+                method === 'turn/canceled' ||
+                method === 'turn/aborted') {
+                completedAfterLastUser = true;
+                continue;
+            }
+            if (method === 'thread/status/changed') {
+                const status = params.status && typeof params.status === 'object'
+                    ? params.status.type
+                    : params.status;
+                if (isRunningThreadStatusToken(status)) {
+                    sawUserTurn = true;
+                    completedAfterLastUser = false;
+                    lastRunningActivityMs = timestampMs;
+                    continue;
+                }
+                if (isTerminalThreadStatusToken(status)) {
+                    completedAfterLastUser = true;
+                }
+            }
+        }
+        return sawUserTurn && !completedAfterLastUser && isFreshRunningActivity(lastRunningActivityMs)
+            ? 'running'
+            : 'idle';
+    }
+    catch {
+        return 'idle';
+    }
+}
+function projectNameFromPath(projectPath) {
+    if (!projectPath)
+        return 'No workspace';
+    const normalized = projectPath.replace(/\\/g, '/').replace(/\/+$/, '');
+    return normalized.split('/').filter(Boolean).at(-1) || normalized || 'No workspace';
+}
+function isPathWithin(parent, candidate) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function isMirrorableCodexWorkspace(projectPath) {
+    if (!projectPath || !path.isAbsolute(projectPath))
+        return false;
+    try {
+        if (!fs.existsSync(projectPath) || !fs.statSync(projectPath).isDirectory())
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return !isPathWithin(path.join(SUPEN_HOME, 'tasks'), projectPath);
+}
+function isAutomationRunThreadTitle(title) {
+    if (!title)
+        return false;
+    return (/^Automation context file:\s*.+\/automations\/[^/\s]+\/runs\/[^/\s]+\.context\.json\s*$/m.test(title) &&
+        /^Automation id:\s*\S+\s*$/m.test(title) &&
+        /^Run id:\s*\S+\s*$/m.test(title));
+}
+function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
+    const safeLimit = Math.max(1, Math.min(limit, 200));
+    const stateEntries = readThreadStateEntries(safeLimit);
+    const indexEntries = readThreadIndex(safeLimit);
+    const sessionFiles = walkSessionFiles(path.join(localAgentHome(), 'sessions'));
+    const projects = new Map();
+    if (stateEntries.length > 0) {
+        for (const entry of stateEntries) {
+            const sessionPath = sessionFiles.get(entry.id) || null;
+            if (!sessionPath)
+                continue;
+            const workspacePath = entry.cwd || readThreadWorkspacePath(sessionPath);
+            if (!isMirrorableCodexWorkspace(workspacePath))
+                continue;
+            const projectId = workspacePath || 'no-workspace';
+            const indexEntry = readThreadIndexEntry(entry.id);
+            const title = indexEntry?.thread_name || entry.title;
+            if (isAutomationRunThreadTitle(title))
+                continue;
+            const project = projects.get(projectId) || {
+                id: projectId,
+                name: projectNameFromPath(workspacePath),
+                path: workspacePath,
+                threads: [],
+            };
+            project.threads.push({
+                id: entry.id,
+                title,
+                updated_at: entry.updated_at,
+                status: readThreadStatus(sessionPath),
+                session_path: sessionPath,
+            });
+            projects.set(projectId, project);
+        }
+        return {
+            generated_at: new Date().toISOString(),
+            projects: Array.from(projects.values()).map((project) => ({
+                ...project,
+                threads: project.threads.sort((a, b) => b.updated_at.localeCompare(a.updated_at)),
+            })),
+        };
+    }
+    for (const entry of indexEntries) {
+        const sessionPath = sessionFiles.get(entry.id) || null;
+        const workspacePath = readThreadWorkspacePath(sessionPath);
+        if (!isMirrorableCodexWorkspace(workspacePath))
+            continue;
+        if (isAutomationRunThreadTitle(entry.thread_name))
+            continue;
+        const projectId = workspacePath || 'no-workspace';
+        const project = projects.get(projectId) || {
+            id: projectId,
+            name: projectNameFromPath(workspacePath),
+            path: workspacePath,
+            threads: [],
+        };
+        project.threads.push({
+            id: entry.id,
+            title: entry.thread_name,
+            updated_at: entry.updated_at,
+            status: readThreadStatus(sessionPath),
+            session_path: sessionPath,
+        });
+        projects.set(projectId, project);
+    }
+    return {
+        generated_at: new Date().toISOString(),
+        projects: Array.from(projects.values()).map((project) => ({
+            ...project,
+            threads: project.threads.sort((a, b) => b.updated_at.localeCompare(a.updated_at)),
+        })),
+    };
+}
+function sanitizeMirroredUserText(text) {
+    return text
+        .replace(/\[Image blocked: No description\]/g, '')
+        .replace(/(?:^|\n)\s*<\/?image>\s*(?=\n|$)/gi, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function truncateMirroredHistoryString(value, limit, label) {
+    if (value.length <= limit)
+        return value;
+    const omitted = value.length - limit;
+    return `${value.slice(0, limit)}\n\n[${label} truncated: ${omitted.toLocaleString()} more characters omitted]`;
+}
+function sanitizeMirroredHistoryPayload(value, depth = 0) {
+    if (typeof value === 'string') {
+        return truncateMirroredHistoryString(value, MIRRORED_THREAD_TOOL_STRING_LIMIT, 'Tool output');
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (depth >= MIRRORED_THREAD_OBJECT_DEPTH_LIMIT) {
+        return Array.isArray(value) ? '[Nested array omitted]' : '[Nested object omitted]';
+    }
+    if (Array.isArray(value)) {
+        const visibleItems = value
+            .slice(0, MIRRORED_THREAD_OBJECT_ARRAY_LIMIT)
+            .map((item) => sanitizeMirroredHistoryPayload(item, depth + 1));
+        if (value.length > MIRRORED_THREAD_OBJECT_ARRAY_LIMIT) {
+            visibleItems.push(`[${value.length - MIRRORED_THREAD_OBJECT_ARRAY_LIMIT} more items omitted]`);
+        }
+        return visibleItems;
+    }
+    const result = {};
+    const entries = Object.entries(value);
+    for (const [key, entryValue] of entries.slice(0, MIRRORED_THREAD_OBJECT_KEY_LIMIT)) {
+        result[key] = sanitizeMirroredHistoryPayload(entryValue, depth + 1);
+    }
+    if (entries.length > MIRRORED_THREAD_OBJECT_KEY_LIMIT) {
+        result.__truncated_keys = `${entries.length - MIRRORED_THREAD_OBJECT_KEY_LIMIT} more keys omitted`;
+    }
+    return result;
+}
+function safeMirroredHistoryAttachmentUrl(url) {
+    const trimmed = url.trim();
+    if (trimmed.startsWith('data:') && trimmed.length > MIRRORED_THREAD_INLINE_DATA_URL_LIMIT) {
+        return '';
+    }
+    return trimmed;
+}
+function mimeTypeFromImageUrl(url) {
+    const match = url.match(/^data:([^;,]+)?/i);
+    return match?.[1] || 'image/png';
+}
+function imageExtensionFromMimeType(mimeType) {
+    if (mimeType === 'image/jpeg')
+        return 'jpg';
+    if (mimeType === 'image/webp')
+        return 'webp';
+    if (mimeType === 'image/gif')
+        return 'gif';
+    return 'png';
+}
+function imageAttachmentFromUrl(url, index) {
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    const mimeType = mimeTypeFromImageUrl(trimmed);
+    const filename = `pasted-image-${index + 1}.${imageExtensionFromMimeType(mimeType)}`;
+    return {
+        name: filename,
+        filename,
+        url: safeMirroredHistoryAttachmentUrl(trimmed),
+        mimeType,
+        mime_type: mimeType,
+    };
+}
+function imageAttachmentsFromUnknown(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((image, index) => (typeof image === 'string' ? imageAttachmentFromUrl(image, index) : null))
+        .filter((attachment) => Boolean(attachment));
+}
+function mergeMirroredAttachments(left = [], right = []) {
+    const seen = new Set();
+    const merged = [];
+    for (const attachment of [...left, ...right]) {
+        const key = attachment.url || attachment.filename;
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(attachment);
+    }
+    return merged;
+}
+function mirroredMessageContentParts(content) {
+    if (typeof content === 'string') {
+        return { text: sanitizeMirroredUserText(content), attachments: [] };
+    }
+    if (!Array.isArray(content))
+        return { text: '', attachments: [] };
+    const textParts = [];
+    const attachments = [];
+    for (const part of content) {
+        if (typeof part === 'string') {
+            textParts.push(part);
+            continue;
+        }
+        if (!part || typeof part !== 'object')
+            continue;
+        const record = part;
+        if (record.type === 'input_text' ||
+            record.type === 'output_text' ||
+            record.type === 'text') {
+            const text = typeof record.text === 'string' ? record.text : '';
+            if (text.trim().toLowerCase() !== '<image>' && text.trim().toLowerCase() !== '</image>') {
+                textParts.push(text);
+            }
+            continue;
+        }
+        if (record.type === 'input_image' && typeof record.image_url === 'string') {
+            const attachment = imageAttachmentFromUrl(record.image_url, attachments.length);
+            if (attachment)
+                attachments.push(attachment);
+        }
+    }
+    return {
+        text: sanitizeMirroredUserText(textParts.filter(Boolean).join('\n')),
+        attachments,
+    };
+}
+function textFromMirroredMessageContent(content) {
+    return mirroredMessageContentParts(content).text;
+}
+function isInternalMirroredUserMessage(text) {
+    const trimmed = text.trimStart();
+    return (trimmed.startsWith('<environment_context>') ||
+        trimmed.startsWith('<developer_context>') ||
+        trimmed.startsWith('[plugin:vite:'));
+}
+function isMirroredGoalContextMessage(text) {
+    const trimmed = text.trim();
+    return trimmed.startsWith('<goal_context>') && trimmed.endsWith('</goal_context>');
+}
+function parseJsonObject(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function readableOutputFromMcpResult(result) {
+    if (!result || typeof result !== 'object')
+        return result;
+    const ok = result.Ok;
+    const error = result.Err;
+    const payload = ok && typeof ok === 'object' ? ok : error;
+    if (!payload || typeof payload !== 'object')
+        return result;
+    const content = payload.content;
+    if (!Array.isArray(content))
+        return payload;
+    const text = content
+        .map((entry) => {
+        if (typeof entry === 'string')
+            return entry;
+        if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+            return entry.text;
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+    return text || payload;
+}
+function fileNameFromPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    return path.basename(trimmed);
+}
+function displayPatchPath(filePath, workspacePath) {
+    const trimmed = filePath.trim();
+    if (!trimmed || !workspacePath || !path.isAbsolute(trimmed))
+        return trimmed;
+    const relativePath = path.relative(workspacePath, trimmed);
+    if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath))
+        return trimmed;
+    return relativePath;
+}
+function diffStatsFromText(value) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of value.split(/\r?\n/)) {
+        if (line.startsWith('+++') || line.startsWith('---'))
+            continue;
+        if (line.startsWith('+'))
+            additions += 1;
+        if (line.startsWith('-'))
+            deletions += 1;
+    }
+    return { additions, deletions };
+}
+function extractPatchFiles(input) {
+    if (typeof input !== 'string')
+        return [];
+    const files = [];
+    const seen = new Set();
+    for (const line of input.split(/\r?\n/)) {
+        const match = line.match(/^\*\*\* (?:Update|Add|Delete) File:\s+(.+?)\s*$/);
+        if (!match)
+            continue;
+        const filePath = match[1]?.trim();
+        if (!filePath || seen.has(filePath))
+            continue;
+        seen.add(filePath);
+        files.push({ path: filePath, name: fileNameFromPath(filePath) || filePath });
+    }
+    return files;
+}
+function extractPatchEndFiles(changes, workspacePath) {
+    if (!changes || typeof changes !== 'object')
+        return [];
+    return Object.entries(changes).map(([filePath, change]) => {
+        const diff = typeof change?.unified_diff === 'string' ? change.unified_diff : '';
+        const displayPath = displayPatchPath(filePath, workspacePath);
+        return {
+            path: displayPath,
+            name: fileNameFromPath(displayPath) || displayPath,
+            ...(diff ? { diff } : {}),
+            ...diffStatsFromText(diff),
+        };
+    });
+}
+function codexReplayEvent(eventId, timestamp, taskId, raw) {
+    return {
+        id: eventId,
+        timestamp,
+        task_id: taskId,
+        chunk: {
+            type: 'data-supen-event',
+            id: eventId,
+            data: { raw },
+        },
+    };
+}
+function mirroredThreadWorkspacePath(sessionPath, stateEntry) {
+    const stateCwd = typeof stateEntry?.cwd === 'string' ? stateEntry.cwd : null;
+    const sessionWorkspace = readThreadWorkspacePath(sessionPath);
+    for (const candidate of [stateCwd, sessionWorkspace]) {
+        if (candidate && isMirrorableCodexWorkspace(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY_LIMIT, options = {}) {
+    const safeLimit = Math.max(1, Math.min(limit, 500));
+    const sessionPath = walkSessionFiles(path.join(localAgentHome(), 'sessions')).get(threadId);
+    if (!sessionPath)
+        return null;
+    const eventLogThreadId = options.eventLogThreadId || threadId;
+    const stateEntry = readThreadStateEntry(threadId);
+    const workspacePath = mirroredThreadWorkspacePath(sessionPath, stateEntry);
+    const indexEntry = readThreadIndexEntry(threadId);
+    const eventLogHead = readThreadEventLogHead(eventLogThreadId);
+    const lines = readRecentCodexHistoryLines(sessionPath, safeLimit + 1);
+    const messages = [];
+    const events = [];
+    let messageIndex = 0;
+    let eventIndex = 0;
+    let latestTimestamp = indexEntry?.updated_at || '';
+    let recentGoalContext = null;
+    const toolCalls = new Map();
+    const mirroredUserMessageKey = (text) => sanitizeMirroredUserText(text)
+        .replace(/\s+/g, ' ')
+        .trim();
+    const pushUserMessage = (text, timestamp, messageId, attachments = []) => {
+        text = sanitizeMirroredUserText(text);
+        if (isMirroredGoalContextMessage(text)) {
+            recentGoalContext = { text, timestamp };
+        }
+        text = truncateMirroredHistoryString(text, MIRRORED_THREAD_TEXT_LIMIT, 'Message');
+        if ((!text && attachments.length === 0) || isInternalMirroredUserMessage(text))
+            return;
+        const key = mirroredUserMessageKey(text);
+        const timestampMs = Date.parse(timestamp);
+        const duplicateIndex = messages.findIndex((message) => {
+            if (message.role !== 'user')
+                return false;
+            if (mirroredUserMessageKey(message.content) !== key)
+                return false;
+            const existingTimestampMs = Date.parse(message.timestamp);
+            if (!Number.isFinite(timestampMs) || !Number.isFinite(existingTimestampMs)) {
+                return message.timestamp === timestamp;
+            }
+            return Math.abs(existingTimestampMs - timestampMs) <= 15_000;
+        });
+        if (duplicateIndex >= 0) {
+            if (text.length > messages[duplicateIndex].content.length) {
+                messages[duplicateIndex].content = text;
+            }
+            const mergedAttachments = mergeMirroredAttachments(messages[duplicateIndex].attachments, attachments);
+            if (mergedAttachments.length > 0) {
+                messages[duplicateIndex].attachments = mergedAttachments;
+            }
+            return;
+        }
+        const id = messageId || `${threadId}-message-${messageIndex + 1}`;
+        if (!messageId)
+            messageIndex += 1;
+        messages.push({
+            id,
+            role: 'user',
+            content: text,
+            timestamp,
+            task_id: threadId,
+            ...(attachments.length > 0 ? { attachments } : {}),
+        });
+    };
+    const pushEvent = (timestamp, chunk) => {
+        eventIndex += 1;
+        events.push({
+            id: `${threadId}-event-${eventIndex}`,
+            timestamp,
+            task_id: threadId,
+            chunk,
+        });
+    };
+    const pushToolInput = (timestamp, toolCallId, toolName, input) => {
+        const sanitizedInput = sanitizeMirroredHistoryPayload(input);
+        toolCalls.set(toolCallId, { toolName, input: sanitizedInput });
+        pushEvent(timestamp, {
+            type: 'tool-input-available',
+            toolCallId,
+            toolName,
+            input: sanitizedInput,
+        });
+    };
+    const pushToolOutput = (timestamp, toolCallId, output, fallbackToolName, fallbackInput, failed = false) => {
+        const toolCall = toolCalls.get(toolCallId);
+        const toolName = toolCall?.toolName || fallbackToolName;
+        const input = toolCall?.input ?? (fallbackInput === undefined ? undefined : sanitizeMirroredHistoryPayload(fallbackInput));
+        pushEvent(timestamp, {
+            type: failed ? 'tool-output-error' : 'tool-output-available',
+            toolCallId,
+            ...(toolName ? { toolName } : {}),
+            ...(input !== undefined ? { input } : {}),
+            ...(failed
+                ? { errorText: typeof output === 'string' ? output : 'Tool failed' }
+                : { output: sanitizeMirroredHistoryPayload(parseJsonObject(output)) }),
+        });
+    };
+    for (const line of lines) {
+        const parsed = parseJsonLine(line);
+        if (typeof parsed?.timestamp === 'string')
+            latestTimestamp = parsed.timestamp;
+        const timestamp = typeof parsed?.timestamp === 'string'
+            ? parsed.timestamp
+            : latestTimestamp || new Date().toISOString();
+        const payload = parsed?.payload && typeof parsed.payload === 'object'
+            ? parsed.payload
+            : {};
+        if (parsed?.type === 'event_msg') {
+            if (payload.type === 'user_message') {
+                const text = typeof payload.message === 'string' ? payload.message.trim() : '';
+                pushUserMessage(text, timestamp, undefined, imageAttachmentsFromUnknown(payload.images));
+                continue;
+            }
+            if (payload.type === 'turn_aborted') {
+                if (eventLogThreadId !== threadId) {
+                    events.push(codexReplayEvent(`${threadId}-turn-aborted-${eventIndex + 1}`, timestamp, threadId, {
+                        method: 'turn/completed',
+                        params: {
+                            turn: {
+                                id: payload.turn_id || payload.turnId || 'turn',
+                                status: 'interrupted',
+                            },
+                        },
+                    }));
+                    eventIndex += 1;
+                }
+                continue;
+            }
+            if (payload.type === 'context_compacted') {
+                events.push(codexReplayEvent(`${threadId}-context-compacted-${eventIndex + 1}`, timestamp, threadId, {
+                    method: 'contextCompaction/completed',
+                    params: {
+                        threadId,
+                        messageCount: payload.message_count || payload.messageCount,
+                        tokensSaved: payload.tokens_saved || payload.tokensSaved,
+                    },
+                }));
+                eventIndex += 1;
+                continue;
+            }
+            if (payload.type === 'web_search_end') {
+                const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-web-search-${eventIndex + 1}`;
+                const input = {
+                    query: payload.query,
+                    action: payload.action,
+                };
+                pushToolInput(timestamp, toolCallId, 'web_search', input);
+                pushToolOutput(timestamp, toolCallId, payload.action || payload.query || 'completed');
+                continue;
+            }
+            if (payload.type === 'mcp_tool_call_end') {
+                const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-mcp-tool-${eventIndex + 1}`;
+                const invocation = payload.invocation && typeof payload.invocation === 'object'
+                    ? payload.invocation
+                    : {};
+                const server = typeof invocation.server === 'string' ? invocation.server : '';
+                const tool = typeof invocation.tool === 'string' ? invocation.tool : '';
+                const toolName = [server, tool].filter(Boolean).join('.') || 'mcpToolCall';
+                const input = invocation.arguments;
+                const result = payload.result && typeof payload.result === 'object'
+                    ? payload.result
+                    : payload.result;
+                const failed = Boolean(result && typeof result === 'object' && 'Err' in result);
+                pushToolInput(timestamp, toolCallId, toolName, input);
+                pushToolOutput(timestamp, toolCallId, readableOutputFromMcpResult(result), toolName, input, failed);
+                continue;
+            }
+            if (payload.type === 'patch_apply_end') {
+                const files = extractPatchEndFiles(payload.changes, workspacePath);
+                const additions = files.reduce((sum, file) => sum + file.additions, 0);
+                const deletions = files.reduce((sum, file) => sum + file.deletions, 0);
+                events.push(codexReplayEvent(`${threadId}-patch-end-${eventIndex + 1}`, timestamp, threadId, {
+                    method: 'codex/patchApply/completed',
+                    params: {
+                        callId: payload.call_id,
+                        success: payload.success !== false,
+                        files,
+                        fileCount: files.length,
+                        additions,
+                        deletions,
+                        status: payload.status,
+                    },
+                }));
+                eventIndex += 1;
+                continue;
+            }
+        }
+        if (parsed?.type === 'compacted') {
+            events.push(codexReplayEvent(`${threadId}-context-compacted-${eventIndex + 1}`, timestamp, threadId, {
+                method: 'contextCompaction/completed',
+                params: { threadId },
+            }));
+            eventIndex += 1;
+            continue;
+        }
+        if (parsed?.type !== 'response_item')
+            continue;
+        if (payload.type === 'function_call') {
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-${eventIndex + 1}`;
+            const toolName = typeof payload.name === 'string' ? payload.name : 'tool';
+            const input = sanitizeMirroredHistoryPayload(parseJsonObject(payload.arguments));
+            pushToolInput(timestamp, toolCallId, toolName, input);
+            continue;
+        }
+        if (payload.type === 'function_call_output') {
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-${eventIndex + 1}`;
+            pushToolOutput(timestamp, toolCallId, payload.output);
+            continue;
+        }
+        if (payload.type === 'tool_search_call') {
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-search-${eventIndex + 1}`;
+            pushToolInput(timestamp, toolCallId, 'tool_search', payload.arguments);
+            continue;
+        }
+        if (payload.type === 'tool_search_output') {
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-search-${eventIndex + 1}`;
+            pushToolOutput(timestamp, toolCallId, {
+                status: payload.status,
+                tools: payload.tools,
+            }, 'tool_search');
+            continue;
+        }
+        if (payload.type === 'custom_tool_call') {
+            const toolName = typeof payload.name === 'string' ? payload.name : 'custom_tool';
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-${eventIndex + 1}`;
+            if (toolName === 'apply_patch') {
+                const input = typeof payload.input === 'string' ? payload.input : '';
+                const files = extractPatchFiles(input);
+                events.push(codexReplayEvent(`${threadId}-patch-start-${eventIndex + 1}`, timestamp, threadId, {
+                    method: 'codex/patchApply/started',
+                    params: {
+                        callId: payload.call_id,
+                        files,
+                        fileCount: files.length,
+                        ...diffStatsFromText(input),
+                    },
+                }));
+                eventIndex += 1;
+            }
+            else {
+                pushToolInput(timestamp, toolCallId, toolName, parseJsonObject(payload.input));
+            }
+            continue;
+        }
+        if (payload.type === 'custom_tool_call_output') {
+            const toolCallId = typeof payload.call_id === 'string' ? payload.call_id : `${threadId}-tool-${eventIndex + 1}`;
+            if (toolCalls.has(toolCallId)) {
+                pushToolOutput(timestamp, toolCallId, payload.output);
+            }
+            continue;
+        }
+        if (payload.type !== 'message')
+            continue;
+        messageIndex += 1;
+        const messageId = `${threadId}-message-${messageIndex}`;
+        const role = payload.role;
+        if (role !== 'user' && role !== 'assistant' && role !== 'system')
+            continue;
+        const contentParts = mirroredMessageContentParts(payload.content);
+        const text = contentParts.text;
+        if (!text && contentParts.attachments.length === 0)
+            continue;
+        if (role === 'user') {
+            pushUserMessage(text, timestamp, messageId, contentParts.attachments);
+            continue;
+        }
+        messages.push({
+            id: messageId,
+            role,
+            content: truncateMirroredHistoryString(text, MIRRORED_THREAD_TEXT_LIMIT, 'Message'),
+            timestamp,
+            task_id: threadId,
+        });
+    }
+    for (const event of listRecentThreadEventsAfter(eventLogThreadId, 0, {
+        limit: MIRRORED_THREAD_STREAM_REPLAY_LIMIT,
+        maxBytes: MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES,
+    })) {
+        const chunk = threadStreamChunkForEvent(event);
+        if (!chunk)
+            continue;
+        events.push({
+            id: `${threadId}-event-log-${event.sequence}`,
+            timestamp: event.received_at,
+            task_id: threadId,
+            chunk,
+        });
+    }
+    const slicedMessages = messages.slice(-safeLimit);
+    const slicedEvents = events.slice(-safeLimit * 8);
+    const status = readThreadStatus(sessionPath);
+    const latestGoalContext = recentGoalContext;
+    return {
+        session: {
+            task_id: threadId,
+            agent_id: 'local-agent-mirror',
+            channel: 'local-agent',
+            source_ref: `local-agent:${threadId}`,
+            title: indexEntry?.thread_name || stateEntry?.title || slicedMessages.find((message) => message.role === 'user')?.content || 'New Task',
+            status,
+            created_at: slicedMessages[0]?.timestamp || latestTimestamp || '',
+            updated_at: latestTimestamp || slicedMessages.at(-1)?.timestamp || '',
+            task_workspace_folder: workspacePath,
+        },
+        messages: slicedMessages,
+        events: slicedEvents,
+        interaction_events: [],
+        control_log: [],
+        items: [],
+        runtimeState: {
+            event_log_head: eventLogHead,
+            projection_version: 1,
+            event_log: { status: 'current' },
+            runtime: {
+                status: status === 'running' ? 'running' : 'idle',
+                updated_at: latestTimestamp || undefined,
+            },
+        },
+        has_more: messages.length > safeLimit,
+        ...(latestGoalContext ? { goal_context: latestGoalContext } : {}),
+    };
+}
+function serializeAdoptedMirroredThread(session) {
+    return {
+        id: session.session_id,
+        taskId: session.session_id,
+        agentId: session.agent_id,
+        status: session.status || 'idle',
+        title: session.title,
+        createdAt: session.created_at,
+        updatedAt: session.updated_at,
+        supen: {
+            channel: session.channel,
+            sourceRef: session.source_ref,
+            taskWorkspaceFolder: session.task_workspace_folder,
+        },
+    };
+}
+function adoptMirroredThread(threadId, agentId) {
+    const history = readCodexThreadHistory(threadId, 1);
+    if (!history)
+        return null;
+    const historySession = history.session;
+    const session = ensureSession({
+        agent_id: agentId,
+        session_id: threadId,
+        channel: 'http',
+        agent_name: agentId,
+        source_ref: `local-agent:${threadId}`,
+        title: typeof historySession.title === 'string' ? historySession.title : undefined,
+        status: historySession.status === 'running' ? 'running' : 'idle',
+        backend_driver_id: 'codex-app-server',
+        task_workspace_folder: typeof historySession.task_workspace_folder === 'string'
+            ? historySession.task_workspace_folder
+            : null,
+    });
+    updateSessionSdkId(agentId, threadId, threadId);
+    updateSessionBackendDriverId(agentId, threadId, 'codex-app-server');
+    return session;
+}
+function coerceSingleQueryParam(value) {
+    if (Array.isArray(value))
+        return value[0] || null;
+    return value || null;
+}
+function collectSpaceLogEntries(filters = {}) {
+    const spaceId = currentSpaceId();
+    const limit = Math.max(1, Math.min(filters.limit || SPACE_LOG_EVENT_LIMIT, 500));
+    const agents = getAllAgents()
+        // Single-Computer runtime: include all agents in this mounted volume.
+        .sort((a, b) => (a.name || a.agent_id).localeCompare(b.name || b.agent_id));
+    const sessions = agents.flatMap((agent) => getSessionsForAgent(agent.agent_id)
+        .map((session) => ({
+        agent_id: agent.agent_id,
+        agent_name: agent.name || null,
+        session_id: session.session_id,
+        status: session.status,
+        updated_at: session.updated_at,
+        title: session.title || null,
+    })));
+    const filteredSessions = sessions.filter((session) => {
+        if (filters.agentId && session.agent_id !== filters.agentId)
+            return false;
+        if (filters.sessionId && session.session_id !== filters.sessionId)
+            return false;
+        return true;
+    });
+    const entries = filteredSessions
+        .flatMap((session) => getSessionUiEvents(session.agent_id, session.session_id, limit).map((event) => {
+        const logSummary = event.chunk && typeof event.chunk === 'object'
+            ? summarizeUiChunk(event.chunk)
+            : null;
+        return logSummary
+            ? {
+                id: event.id,
+                timestamp: event.timestamp,
+                agent_id: session.agent_id,
+                agent_name: session.agent_name,
+                session_id: session.session_id,
+                session_title: session.title,
+                task_id: event.task_id || null,
+                category: logSummary.category,
+                summary: logSummary.summary,
+            }
+            : null;
+    }))
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+        .slice(-limit);
+    return {
+        space_id: spaceId,
+        generated_at: new Date().toISOString(),
+        timezone: resolveHostTimeZone(),
+        agents,
+        sessions,
+        entries,
+        filters: {
+            agent_id: filters.agentId || null,
+            session_id: filters.sessionId || null,
+        },
+    };
+}
+function writeSse(res, payload) {
+    if (!payload) {
+        res.write(': ping\n\n');
+        return;
+    }
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+function numericQueryParam(value) {
+    if (!value)
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+function lastEventIdFromRequest(req) {
+    const raw = req.headers?.['last-event-id'];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    return typeof value === 'string' ? numericQueryParam(value) : null;
+}
+function threadStreamChunkForEvent(event) {
+    if (event.source !== 'codex-app-server')
+        return null;
+    if (event.raw_payload &&
+        typeof event.raw_payload === 'object' &&
+        !Array.isArray(event.raw_payload)) {
+        return event.raw_payload;
+    }
+    return {
+        type: 'data-supen-event',
+        data: {
+            eventType: event.event_type,
+            raw: event.raw_payload,
+        },
+    };
+}
+function buildMcpSettingsResponse() {
+    const overrides = getMcpEnvOverrides();
+    const runtimeEnv = { ...process.env };
+    const spaceEnv = readSpaceEnvMap();
+    for (const [key, entry] of Object.entries(spaceEnv)) {
+        if (entry.scope !== 'runtime')
+            continue;
+        runtimeEnv[key] = entry.value;
+    }
+    const servers = listMcpServers(runtimeEnv, overrides);
+    const envStatus = listMcpEnvKeys().map((key) => {
+        const overrideValue = overrides[key];
+        const processValue = runtimeEnv[key];
+        const effective = (overrideValue && overrideValue.trim().length > 0)
+            ? overrideValue
+            : processValue;
+        return {
+            key,
+            hasValue: !!effective && effective.trim().length > 0,
+            source: overrideValue && overrideValue.trim().length > 0
+                ? 'settings'
+                : (processValue && processValue.trim().length > 0 ? 'process' : null),
+        };
+    });
+    return { servers, env: envStatus };
+}
+const CODING_CLI_INSTALL_COMMANDS = {
+    codex: { command: 'npm', args: ['install', '-g', '@openai/codex'] },
+    gemini: { command: 'npm', args: ['install', '-g', '@google/gemini-cli'] },
+};
+const MANAGED_CODING_CLI_INSTALL_COMMANDS = {
+    codex: CODING_CLI_INSTALL_COMMANDS.codex,
+    gemini: CODING_CLI_INSTALL_COMMANDS.gemini,
+};
+const CODING_CLI_NAMES = ['codex', 'gemini', 'claude'];
+const DETECTABLE_SPACE_APPS = [
+    { id: 'codex', command: 'codex', managed: true },
+    { id: 'gemini', command: 'gemini', managed: true },
+    { id: 'claude', command: 'claude', managed: false },
+    { id: 'acpx', command: 'acpx', managed: false },
+    { id: 'libreoffice', command: 'libreoffice', managed: false },
+    { id: 'dotnet', command: 'dotnet', managed: false },
+    { id: 'tiwater-docx', command: 'tiwater-docx', managed: false },
+    { id: 'node', command: 'node', managed: false },
+    { id: 'pnpm', command: 'pnpm', managed: false },
+    { id: 'cursor', command: 'cursor-agent', managed: false },
+    { id: 'gh', command: 'gh', managed: false },
+    { id: 'git', command: 'git', managed: false },
+];
+const codexConnectRuntime = {
+    state: 'idle',
+    updatedAt: null,
+    logs: [],
+    error: null,
+    child: null,
+};
+function nowIso() {
+    return new Date().toISOString();
+}
+function normalizeCliName(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'codex' || value === 'gemini' || value === 'claude')
+        return value;
+    return null;
+}
+function normalizeCodexTransport(raw) {
+    const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (value === 'app-server' || value === 'exec' || value === 'acpx')
+        return value;
+    return null;
+}
+function isManagedCliName(name) {
+    return name === 'codex' || name === 'gemini';
+}
+function trimLogNoise(value) {
+    const line = value.trim();
+    if (!line)
+        return '';
+    if (line.startsWith('WARNING: proceeding, even though we could not update PATH'))
+        return '';
+    return line;
+}
+function pushCodexConnectLog(chunk) {
+    const lines = chunk
+        .split(/\r?\n/g)
+        .map((line) => trimLogNoise(line))
+        .filter(Boolean);
+    if (lines.length === 0)
+        return;
+    codexConnectRuntime.logs.push(...lines);
+    if (codexConnectRuntime.logs.length > 120) {
+        codexConnectRuntime.logs = codexConnectRuntime.logs.slice(-120);
+    }
+    codexConnectRuntime.updatedAt = nowIso();
+}
+function codexConnectSnapshot() {
+    return {
+        state: codexConnectRuntime.state,
+        updated_at: codexConnectRuntime.updatedAt,
+        logs: [...codexConnectRuntime.logs],
+        error: codexConnectRuntime.error,
+    };
+}
+function detectCliInstalled(name) {
+    const cmd = spawnSync('sh', ['-lc', `command -v ${name}`], {
+        encoding: 'utf8',
+        timeout: 3000,
+    });
+    if (cmd.status !== 0)
+        return { installed: false, version: null };
+    const versionCmd = spawnSync(name, ['--version'], {
+        encoding: 'utf8',
+        timeout: 5000,
+    });
+    const output = trimLogNoise(`${versionCmd.stdout || ''}\n${versionCmd.stderr || ''}`) || '';
+    return { installed: true, version: output || null };
+}
+function detectCodexAuthStatus(installed) {
+    if (!installed)
+        return { authenticated: false, summary: 'codex not installed' };
+    const result = spawnSync('codex', ['login', 'status'], {
+        encoding: 'utf8',
+        timeout: 8000,
+    });
+    const text = `${result.stdout || ''}\n${result.stderr || ''}`
+        .split(/\r?\n/g)
+        .map((line) => trimLogNoise(line))
+        .filter(Boolean)
+        .join('\n');
+    const authenticated = /logged in/i.test(text) && !/not logged in/i.test(text);
+    const summary = text.split(/\r?\n/g).find((line) => line.trim().length > 0) || null;
+    return { authenticated, summary };
+}
+function readCodexDefaultModel() {
+    const codexHome = resolveCodexHome();
+    const configPath = path.join(codexHome, 'config.toml');
+    try {
+        const text = fs.readFileSync(configPath, 'utf8');
+        const match = text.match(/^\s*model\s*=\s*["']([^"']+)["']/m);
+        const model = match?.[1]?.trim();
+        return model || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveCodexHome() {
+    return process.env.CODEX_HOME && process.env.CODEX_HOME.trim().length > 0
+        ? process.env.CODEX_HOME
+        : path.join(os.homedir(), '.codex');
+}
+function quoteTomlString(value) {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+function writeCodexDefaultModel(model) {
+    const nextModel = model.trim();
+    if (!nextModel || /[\r\n]/.test(nextModel)) {
+        throw new Error('Model must be a non-empty single-line value');
+    }
+    const codexHome = resolveCodexHome();
+    const configPath = path.join(codexHome, 'config.toml');
+    const nextLine = `model = ${quoteTomlString(nextModel)}`;
+    fs.mkdirSync(codexHome, { recursive: true });
+    let text = '';
+    try {
+        text = fs.readFileSync(configPath, 'utf8');
+    }
+    catch {
+        fs.writeFileSync(configPath, `${nextLine}\n`, 'utf8');
+        return nextModel;
+    }
+    const normalized = text.replace(/\s+$/u, '');
+    const updated = /^\s*model\s*=.*$/m.test(normalized)
+        ? normalized.replace(/^\s*model\s*=.*$/m, nextLine)
+        : `${nextLine}\n${normalized}`;
+    fs.writeFileSync(configPath, `${updated}\n`, 'utf8');
+    return nextModel;
+}
+function readCodexModelOptions(defaultModel) {
+    const codexHome = resolveCodexHome();
+    const cachePath = path.join(codexHome, 'models_cache.json');
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+        if (!Array.isArray(parsed.models))
+            return defaultModel ? fallbackCodexModelOptions(defaultModel) : [];
+        const options = parsed.models
+            .flatMap((entry) => {
+            if (!entry || typeof entry !== 'object')
+                return [];
+            const model = entry;
+            const id = typeof model.slug === 'string' ? model.slug.trim() : '';
+            if (!id || model.visibility !== 'list')
+                return [];
+            const supportedLevels = Array.isArray(model.supported_reasoning_levels)
+                ? model.supported_reasoning_levels.flatMap((level) => {
+                    if (!level || typeof level !== 'object')
+                        return [];
+                    const effort = level.effort;
+                    return typeof effort === 'string' && effort.trim() ? [effort.trim()] : [];
+                })
+                : [];
+            return [{
+                    id,
+                    display_name: typeof model.display_name === 'string' && model.display_name.trim()
+                        ? model.display_name.trim()
+                        : id,
+                    description: typeof model.description === 'string' && model.description.trim()
+                        ? model.description.trim()
+                        : null,
+                    default_reasoning_level: typeof model.default_reasoning_level === 'string' && model.default_reasoning_level.trim()
+                        ? model.default_reasoning_level.trim()
+                        : null,
+                    supported_reasoning_levels: supportedLevels,
+                    context_window: typeof model.context_window === 'number' && Number.isFinite(model.context_window)
+                        ? model.context_window
+                        : null,
+                    priority: typeof model.priority === 'number' && Number.isFinite(model.priority)
+                        ? model.priority
+                        : 999,
+                }];
+        })
+            .sort((a, b) => a.priority - b.priority || a.display_name.localeCompare(b.display_name));
+        if (defaultModel && !options.some((option) => option.id === defaultModel)) {
+            return [...fallbackCodexModelOptions(defaultModel), ...options];
+        }
+        return options;
+    }
+    catch {
+        return defaultModel ? fallbackCodexModelOptions(defaultModel) : [];
+    }
+}
+function fallbackCodexModelOptions(model) {
+    return [{
+            id: model,
+            display_name: model,
+            description: null,
+            default_reasoning_level: null,
+            supported_reasoning_levels: [],
+            context_window: null,
+            priority: 0,
+        }];
+}
+function readCodingCliStatusPayload() {
+    const clis = CODING_CLI_NAMES.map((name) => {
+        const detected = detectCliInstalled(name);
+        return {
+            name,
+            installed: detected.installed,
+            version: detected.version,
+        };
+    });
+    const codexInstalled = clis.find((cli) => cli.name === 'codex')?.installed ?? false;
+    const codexVersion = clis.find((cli) => cli.name === 'codex')?.version ?? null;
+    const gemini = clis.find((cli) => cli.name === 'gemini');
+    const claude = clis.find((cli) => cli.name === 'claude');
+    const acpxDetected = detectCliInstalled('acpx');
+    const selected_cli = process.env.SUPEN_CODING_CLI || readConfigSummary().coding_cli || 'codex';
+    const codexTransport = normalizeCodexTransport(process.env.SUPEN_CODEX_TRANSPORT) ||
+        normalizeCodexTransport(readConfigSummary().codex_transport) ||
+        'app-server';
+    const codexDefaultModel = readCodexDefaultModel();
+    const codexModelOptions = readCodexModelOptions(codexDefaultModel);
+    const installed_apps = DETECTABLE_SPACE_APPS.map((app) => {
+        const detected = detectCliInstalled(app.command);
+        return {
+            id: app.id,
+            installed: detected.installed,
+            version: detected.version,
+            managed: app.managed,
+        };
+    });
+    return {
+        selected_cli,
+        default_model: selected_cli === 'codex' ? codexDefaultModel : null,
+        model_options: selected_cli === 'codex' ? codexModelOptions : [],
+        clis,
+        agent_runtimes: [
+            {
+                id: 'codex-app-server',
+                label: 'Codex App Server',
+                installed: codexInstalled,
+                version: codexVersion,
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'app-server',
+                recommended: true,
+                default: selected_cli === 'codex' && codexTransport === 'app-server',
+                description: 'Daemon-managed codex app-server process with protocol-native streaming.',
+            },
+            {
+                id: 'codex-exec',
+                label: 'Codex CLI Exec',
+                installed: codexInstalled,
+                version: codexVersion,
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'exec',
+                recommended: false,
+                default: selected_cli === 'codex' && codexTransport === 'exec',
+                description: 'Direct codex exec fallback, typically one process per turn.',
+            },
+            {
+                id: 'codex-acpx',
+                label: 'Codex via ACPX',
+                installed: codexInstalled && acpxDetected.installed,
+                version: acpxDetected.version || codexVersion,
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'acpx',
+                recommended: false,
+                default: selected_cli === 'codex' && codexTransport === 'acpx',
+                description: 'Compatibility bridge through ACPX for hosts that still need it.',
+            },
+            {
+                id: 'claude-code',
+                label: 'Claude Code',
+                installed: Boolean(claude?.installed),
+                version: claude?.version ?? null,
+                transport: 'cli',
+                recommended: false,
+                default: selected_cli === 'claude',
+                description: 'Claude Code CLI runtime.',
+            },
+            {
+                id: 'gemini-cli',
+                label: 'Gemini CLI',
+                installed: Boolean(gemini?.installed),
+                version: gemini?.version ?? null,
+                transport: 'cli',
+                recommended: false,
+                default: selected_cli === 'gemini',
+                description: 'Gemini CLI runtime.',
+            },
+        ],
+        installed_apps,
+        codex_auth: detectCodexAuthStatus(codexInstalled),
+        codex_connect: codexConnectSnapshot(),
+    };
+}
+function readRuntimeModelStatusPayload() {
+    const selected_cli = process.env.SUPEN_CODING_CLI || readConfigSummary().coding_cli || 'codex';
+    const codexTransport = normalizeCodexTransport(process.env.SUPEN_CODEX_TRANSPORT) ||
+        normalizeCodexTransport(readConfigSummary().codex_transport) ||
+        'app-server';
+    const codexDefaultModel = readCodexDefaultModel();
+    const codexModelOptions = readCodexModelOptions(codexDefaultModel);
+    return {
+        selected_cli,
+        default_model: selected_cli === 'codex' ? codexDefaultModel : null,
+        model_options: selected_cli === 'codex' ? codexModelOptions : [],
+        agent_runtimes: [
+            {
+                id: 'codex-app-server',
+                default: selected_cli === 'codex' && codexTransport === 'app-server',
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'app-server',
+            },
+            {
+                id: 'codex-exec',
+                default: selected_cli === 'codex' && codexTransport === 'exec',
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'exec',
+            },
+            {
+                id: 'codex-acpx',
+                default: selected_cli === 'codex' && codexTransport === 'acpx',
+                default_model: codexDefaultModel,
+                model_options: codexModelOptions,
+                transport: 'acpx',
+            },
+            {
+                id: 'claude-code',
+                default: selected_cli === 'claude',
+                default_model: null,
+                model_options: [],
+                transport: 'cli',
+            },
+            {
+                id: 'gemini-cli',
+                default: selected_cli === 'gemini',
+                default_model: null,
+                model_options: [],
+                transport: 'cli',
+            },
+        ],
+    };
+}
+function setDefaultCodingCli(cli) {
+    const rawYaml = readConfigYamlFile();
+    const parsed = yaml.parse(rawYaml);
+    const doc = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    doc.coding_cli = cli;
+    const result = writeConfigYamlFile(yaml.stringify(doc));
+    if (result.ok === false) {
+        throw new Error(result.message);
+    }
+    process.env.SUPEN_CODING_CLI = cli;
+    return { selected_cli: readConfigSummary().coding_cli };
+}
+function setDefaultCodexTransport(transport) {
+    const rawYaml = readConfigYamlFile();
+    const parsed = yaml.parse(rawYaml);
+    const doc = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    doc.coding_cli = 'codex';
+    doc.codex_transport = transport;
+    const result = writeConfigYamlFile(yaml.stringify(doc));
+    if (result.ok === false) {
+        throw new Error(result.message);
+    }
+    process.env.SUPEN_CODING_CLI = 'codex';
+    process.env.SUPEN_CODEX_TRANSPORT = transport;
+    const summary = readConfigSummary();
+    return { selected_cli: summary.coding_cli, codex_transport: summary.codex_transport };
+}
+function startCodexConnectFlow() {
+    if (codexConnectRuntime.child && codexConnectRuntime.state === 'running') {
+        return codexConnectSnapshot();
+    }
+    codexConnectRuntime.state = 'running';
+    codexConnectRuntime.updatedAt = nowIso();
+    codexConnectRuntime.logs = [];
+    codexConnectRuntime.error = null;
+    const child = spawn('codex', ['login', '--device-auth'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    codexConnectRuntime.child = child;
+    child.stdout.on('data', (chunk) => pushCodexConnectLog(String(chunk)));
+    child.stderr.on('data', (chunk) => pushCodexConnectLog(String(chunk)));
+    child.on('error', (err) => {
+        codexConnectRuntime.state = 'failed';
+        codexConnectRuntime.error = err.message || 'Failed to start codex login flow';
+        codexConnectRuntime.updatedAt = nowIso();
+        codexConnectRuntime.child = null;
+    });
+    child.on('close', (code) => {
+        codexConnectRuntime.state = code === 0 ? 'succeeded' : 'failed';
+        if (code !== 0 && !codexConnectRuntime.error) {
+            codexConnectRuntime.error = `codex login exited with code ${code ?? -1}`;
+        }
+        codexConnectRuntime.updatedAt = nowIso();
+        codexConnectRuntime.child = null;
+    });
+    return codexConnectSnapshot();
+}
+function cancelCodexConnectFlow() {
+    const child = codexConnectRuntime.child;
+    if (child && codexConnectRuntime.state === 'running') {
+        child.kill('SIGTERM');
+        codexConnectRuntime.state = 'failed';
+        codexConnectRuntime.error = 'Cancelled by user';
+        codexConnectRuntime.updatedAt = nowIso();
+        codexConnectRuntime.child = null;
+    }
+    return codexConnectSnapshot();
+}
+export async function handleSystemRoutes(req, res, url, pathname, method) {
+    if (pathname === '/health' && method === 'GET') {
+        writeJson(res, 200, { status: 'ok' });
+        return true;
+    }
+    if (pathname === '/api/computer/openapi.json' && method === 'GET') {
+        writeJson(res, 200, buildDaemonOpenApiSpec());
+        return true;
+    }
+    if (pathname === '/api/computer/models' && method === 'GET') {
+        writeJson(res, 200, { models: MODELS_REGISTRY });
+        return true;
+    }
+    if (pathname === '/api/computer/config/reload' && method === 'POST') {
+        const before = {
+            total_models: MODELS_REGISTRY.length,
+            default_model: DEFAULT_MODEL?.id ?? null,
+        };
+        const after = reloadModelsRegistry();
+        writeJson(res, 200, {
+            ok: true,
+            reloaded: {
+                models: true,
+            },
+            before,
+            after,
+        });
+        return true;
+    }
+    if (pathname === '/api/computer/config-summary' && method === 'GET') {
+        writeJson(res, 200, readConfigSummary());
+        return true;
+    }
+    if (pathname === '/api/computer/logs' && method === 'GET') {
+        const agentId = coerceSingleQueryParam(url.searchParams.get('agent_id'));
+        const sessionId = coerceSingleQueryParam(url.searchParams.get('session_id'));
+        const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
+        const limit = limitRaw ? Number.parseInt(limitRaw, 10) : SPACE_LOG_EVENT_LIMIT;
+        writeJson(res, 200, collectSpaceLogEntries({
+            agentId: agentId?.trim() || null,
+            sessionId: sessionId?.trim() || null,
+            limit: Number.isFinite(limit) ? limit : SPACE_LOG_EVENT_LIMIT,
+        }));
+        return true;
+    }
+    if (pathname === '/api/computer/logs/stream' && method === 'GET') {
+        const agentId = coerceSingleQueryParam(url.searchParams.get('agent_id'));
+        const sessionId = coerceSingleQueryParam(url.searchParams.get('session_id'));
+        const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
+        const limit = limitRaw ? Number.parseInt(limitRaw, 10) : SPACE_LOG_EVENT_LIMIT;
+        const filters = {
+            agentId: agentId?.trim() || null,
+            sessionId: sessionId?.trim() || null,
+            limit: Number.isFinite(limit) ? limit : SPACE_LOG_EVENT_LIMIT,
+        };
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        res.flushHeaders?.();
+        const seenIds = new Set(collectSpaceLogEntries(filters).entries.map((entry) => entry.id));
+        const emitDiff = () => {
+            const payload = collectSpaceLogEntries(filters);
+            const entries = payload.entries.filter((entry) => !seenIds.has(entry.id));
+            if (entries.length === 0)
+                return;
+            for (const entry of entries)
+                seenIds.add(entry.id);
+            writeSse(res, {
+                type: 'log_entries',
+                generated_at: payload.generated_at,
+                timezone: payload.timezone,
+                entries,
+            });
+        };
+        const pollTimer = setInterval(emitDiff, SPACE_LOG_STREAM_POLL_MS);
+        const pingTimer = setInterval(() => writeSse(res), SPACE_LOG_STREAM_PING_MS);
+        const cleanup = () => {
+            clearInterval(pollTimer);
+            clearInterval(pingTimer);
+        };
+        req.on('close', cleanup);
+        res.on('close', cleanup);
+        writeSse(res);
+        return true;
+    }
+    if (pathname === '/api/computer/config-yaml' && method === 'GET') {
+        try {
+            const yaml = readConfigYamlFile();
+            writeJson(res, 200, { yaml });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'read_failed', err?.message || 'Failed to read config.yaml');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/config-yaml' && method === 'PUT') {
+        try {
+            const parsed = await readJsonBody(req);
+            const yamlText = typeof parsed === 'object' && parsed && typeof parsed.yaml === 'string'
+                ? String(parsed.yaml)
+                : '';
+            if (!yamlText.trim()) {
+                writeProtocolError(res, 400, 'validation_error', 'missing_yaml', 'Request body must include a non-empty "yaml" string.');
+                return true;
+            }
+            const result = writeConfigYamlFile(yamlText);
+            if (result.ok === false) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_yaml', result.message);
+                return true;
+            }
+            const after = reloadModelsRegistry();
+            writeJson(res, 200, {
+                ok: true,
+                summary: readConfigSummary(),
+                reloaded: { models: true, default_model: after.default_model },
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'write_failed', err?.message || 'Failed to write config.yaml');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/gateway-uplink' && method === 'GET') {
+        writeJson(res, 200, gatewayUplinkStatus());
+        return true;
+    }
+    if (pathname === '/api/computer/gateway-uplink' && (method === 'PUT' || method === 'PATCH')) {
+        if (process.env.SUPEN_GATEWAY_URL) {
+            writeProtocolError(res, 409, 'config_error', 'env_override', 'SUPEN_GATEWAY_URL is set; update the daemon environment to change the gateway uplink.');
+            return true;
+        }
+        try {
+            const body = await readJsonBody(req);
+            const rawGatewayUrl = body && typeof body === 'object' && typeof body.gateway_url === 'string'
+                ? String(body.gateway_url)
+                : '';
+            const rawTrustToken = body && typeof body === 'object' && typeof body.trust_token === 'string'
+                ? String(body.trust_token).trim()
+                : '';
+            const disconnect = body && typeof body === 'object' && body.disconnect === true;
+            const existing = readGatewayConfig();
+            const next = {
+                ...existing,
+            };
+            if (disconnect || !rawGatewayUrl.trim()) {
+                delete next.gateway_url;
+                if (disconnect)
+                    delete next.trust_token;
+            }
+            else {
+                next.gateway_url = normalizeGatewayUplinkUrl(rawGatewayUrl);
+            }
+            if (rawTrustToken)
+                next.trust_token = rawTrustToken;
+            writeGatewayConfig(next);
+            const gateway = getGatewayInstance();
+            if (gateway) {
+                await gateway.reloadConfigAndReconnect();
+            }
+            writeJson(res, 200, {
+                ok: true,
+                ...gatewayUplinkStatus(next),
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 400, 'validation_error', 'invalid_gateway_uplink', err?.message || 'Invalid gateway uplink config.');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/env' && method === 'GET') {
+        writeJson(res, 200, { env: readSpaceEnvMap() });
+        return true;
+    }
+    if (pathname === '/api/computer/llm-env' && method === 'GET') {
+        const token = getLlmToken() || process.env.SUPEN_LLM_TOKEN || process.env.SUPEN_LLM_API_KEY || '';
+        const env = withSupenLlmEnv({
+            ...process.env,
+            ...(token ? { SUPEN_LLM_TOKEN: token, SUPEN_LLM_API_KEY: token } : {}),
+        });
+        const responseEnv = {};
+        for (const key of ['SUPEN_LLM_TOKEN', 'SUPEN_LLM_API_KEY', 'SUPEN_LLM_GATEWAY_URL', 'SUPEN_LLM_BASE_URL']) {
+            const value = env[key];
+            if (typeof value === 'string' && value.trim()) {
+                responseEnv[key] = value.trim();
+            }
+        }
+        writeJson(res, 200, {
+            ok: true,
+            available: Boolean(responseEnv.SUPEN_LLM_TOKEN && (responseEnv.SUPEN_LLM_GATEWAY_URL || responseEnv.SUPEN_LLM_BASE_URL)),
+            env: responseEnv,
+        });
+        return true;
+    }
+    if (pathname === '/api/computer/apps' && method === 'GET') {
+        writeJson(res, 200, readCodingCliStatusPayload());
+        return true;
+    }
+    if (pathname === '/api/computer/runtime-models' && method === 'GET') {
+        writeJson(res, 200, readRuntimeModelStatusPayload());
+        return true;
+    }
+    if (pathname === '/api/computer/runtime-models/default' && method === 'PUT') {
+        try {
+            const parsed = await readJsonBody(req);
+            const model = typeof parsed === 'object' && parsed && typeof parsed.model === 'string'
+                ? String(parsed.model).trim()
+                : '';
+            if (!model) {
+                writeProtocolError(res, 400, 'validation_error', 'missing_model', 'Request body must include a non-empty "model" string.');
+                return true;
+            }
+            writeCodexDefaultModel(model);
+            writeJson(res, 200, {
+                ok: true,
+                status: readRuntimeModelStatusPayload(),
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'codex_model_default_failed', err?.message || 'Failed to set Codex default model');
+        }
+        return true;
+    }
+    const spaceCodexTransportDefaultMatch = pathname.match(/^\/api\/computer\/apps\/codex\/transports\/([^/]+)\/default$/);
+    if (spaceCodexTransportDefaultMatch && method === 'PUT') {
+        try {
+            const transport = normalizeCodexTransport(decodeURIComponent(spaceCodexTransportDefaultMatch[1] || '').trim());
+            if (!transport) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_codex_transport', 'transport must be one of: app-server, exec, acpx');
+                return true;
+            }
+            const result = setDefaultCodexTransport(transport);
+            writeJson(res, 200, {
+                ok: true,
+                ...result,
+                status: readCodingCliStatusPayload(),
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'codex_transport_default_failed', err?.message || 'Failed to set default Codex transport');
+        }
+        return true;
+    }
+    const spaceAppDefaultMatch = pathname.match(/^\/api\/computer\/apps\/([^/]+)\/default$/);
+    if (spaceAppDefaultMatch && method === 'PUT') {
+        try {
+            const cli = normalizeCliName(decodeURIComponent(spaceAppDefaultMatch[1] || '').trim());
+            if (!cli) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_cli', 'cli must be one of: codex, gemini, claude');
+                return true;
+            }
+            const result = setDefaultCodingCli(cli);
+            writeJson(res, 200, {
+                ok: true,
+                ...result,
+                status: readCodingCliStatusPayload(),
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'coding_cli_default_failed', err?.message || 'Failed to set default coding CLI');
+        }
+        return true;
+    }
+    const spaceAppInstallMatch = pathname.match(/^\/api\/computer\/apps\/([^/]+)\/install$/);
+    if (spaceAppInstallMatch && method === 'POST') {
+        try {
+            const cli = normalizeCliName(decodeURIComponent(spaceAppInstallMatch[1] || '').trim());
+            if (!cli) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_cli', 'cli must be one of: codex, gemini, claude');
+                return true;
+            }
+            if (!isManagedCliName(cli)) {
+                writeProtocolError(res, 400, 'validation_error', 'install_not_supported', 'Only codex and gemini support managed install at the moment');
+                return true;
+            }
+            const installSpec = MANAGED_CODING_CLI_INSTALL_COMMANDS[cli];
+            const result = spawnSync(installSpec.command, installSpec.args, {
+                encoding: 'utf8',
+                timeout: 120_000,
+            });
+            if (result.status !== 0) {
+                const output = `${result.stdout || ''}\n${result.stderr || ''}`.trim() || `Failed to install ${cli}`;
+                writeProtocolError(res, 500, 'install_error', 'coding_cli_install_failed', output);
+                return true;
+            }
+            writeJson(res, 200, {
+                ok: true,
+                cli,
+                status: readCodingCliStatusPayload(),
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'install_error', 'coding_cli_install_failed', err?.message || 'Failed to install coding cli');
+        }
+        return true;
+    }
+    const spaceAppConnectMatch = pathname.match(/^\/api\/computer\/apps\/([^/]+)\/connect$/);
+    if (spaceAppConnectMatch && method === 'POST') {
+        const cli = normalizeCliName(decodeURIComponent(spaceAppConnectMatch[1] || '').trim());
+        if (cli !== 'codex') {
+            writeProtocolError(res, 400, 'validation_error', 'connect_not_supported', 'Only codex supports connect flow at the moment');
+            return true;
+        }
+        const status = readCodingCliStatusPayload();
+        const codex = status.clis.find((entry) => entry.name === 'codex');
+        if (!codex?.installed) {
+            writeProtocolError(res, 400, 'validation_error', 'codex_not_installed', 'codex CLI is not installed');
+            return true;
+        }
+        writeJson(res, 200, {
+            ok: true,
+            codex_connect: startCodexConnectFlow(),
+            status: readCodingCliStatusPayload(),
+        });
+        return true;
+    }
+    if (spaceAppConnectMatch && method === 'DELETE') {
+        const cli = normalizeCliName(decodeURIComponent(spaceAppConnectMatch[1] || '').trim());
+        if (cli !== 'codex') {
+            writeProtocolError(res, 400, 'validation_error', 'connect_not_supported', 'Only codex supports connect flow at the moment');
+            return true;
+        }
+        writeJson(res, 200, {
+            ok: true,
+            codex_connect: cancelCodexConnectFlow(),
+            status: readCodingCliStatusPayload(),
+        });
+        return true;
+    }
+    const spaceAppSessionMatch = pathname.match(/^\/api\/computer\/apps\/([^/]+)\/session$/);
+    if (spaceAppSessionMatch && method === 'DELETE') {
+        const cli = normalizeCliName(decodeURIComponent(spaceAppSessionMatch[1] || '').trim());
+        if (cli !== 'codex') {
+            writeProtocolError(res, 400, 'validation_error', 'session_not_supported', 'Only codex supports session connect/disconnect at the moment');
+            return true;
+        }
+        const cmd = spawnSync('codex', ['logout'], {
+            encoding: 'utf8',
+            timeout: 15_000,
+        });
+        if (cmd.status !== 0) {
+            const output = `${cmd.stdout || ''}\n${cmd.stderr || ''}`.trim() || 'codex logout failed';
+            writeProtocolError(res, 500, 'auth_error', 'codex_logout_failed', output);
+            return true;
+        }
+        writeJson(res, 200, { ok: true, status: readCodingCliStatusPayload() });
+        return true;
+    }
+    if (pathname === '/api/computer/env' && method === 'PUT') {
+        try {
+            const parsed = await readJsonBody(req);
+            const updates = parsed && typeof parsed === 'object' && parsed.env && typeof parsed.env === 'object' && !Array.isArray(parsed.env)
+                ? parsed.env
+                : null;
+            if (!updates) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_env_payload', 'Request body must include an "env" object.');
+                return true;
+            }
+            const env = updateSpaceEnvMap(updates);
+            writeJson(res, 200, { ok: true, env });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'config_error', 'space_env_write_failed', err?.message || 'Failed to update space env vars');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/hub-snapshot' && method === 'GET') {
+        const spaceId = (url.searchParams.get('space_id') || process.env.SUPEN_SPACE_ID || 'local').trim() || 'local';
+        writeJson(res, 200, buildHubSnapshotForSpace(spaceId));
+        return true;
+    }
+    if (pathname === '/api/computer/usage' && method === 'GET') {
+        writeJson(res, 200, getGlobalUsage());
+        return true;
+    }
+    if (pathname === '/api/computer/usage/daily' && method === 'GET') {
+        writeJson(res, 200, { daily: getDailyUsage() });
+        return true;
+    }
+    if (pathname === '/api/computer/codex/subscription' && method === 'GET') {
+        try {
+            writeJson(res, 200, await readCodexSubscription());
+        }
+        catch (err) {
+            writeProtocolError(res, 503, 'service_unavailable', 'codex_subscription_unavailable', err?.message || 'Unable to read Codex subscription details.');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/quota-status' && method === 'GET') {
+        writeJson(res, 200, readLatestSpaceQuotaStatus());
+        return true;
+    }
+    if (pathname === '/api/computer/codex/threads' && method === 'GET') {
+        const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
+        const limit = limitRaw ? Number.parseInt(limitRaw, 10) : MIRRORED_THREAD_LIMIT;
+        writeJson(res, 200, readMirroredTaskProjects(Number.isFinite(limit) ? limit : MIRRORED_THREAD_LIMIT));
+        return true;
+    }
+    const mirroredThreadStreamMatch = pathname.match(/^\/api\/computer\/codex\/threads\/([^/]+)\/stream$/);
+    if (mirroredThreadStreamMatch && method === 'GET') {
+        const threadId = decodeURIComponent(mirroredThreadStreamMatch[1] || '').trim();
+        if (!threadId) {
+            writeProtocolError(res, 400, 'validation_error', 'missing_thread_id', 'Thread id is required.');
+            return true;
+        }
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        const afterSequence = lastEventIdFromRequest(req) ??
+            numericQueryParam(coerceSingleQueryParam(url.searchParams.get('after')));
+        const replayAfter = afterSequence ?? readThreadEventLogHead(threadId);
+        addThreadStreamClient(threadId, res);
+        const pingTimer = setInterval(() => {
+            writeSse(res);
+            res.flush?.();
+        }, SPACE_LOG_STREAM_PING_MS);
+        pingTimer.unref?.();
+        const cleanup = () => {
+            clearInterval(pingTimer);
+            removeThreadStreamClient(threadId, res);
+        };
+        req.on('close', cleanup);
+        res.on('close', cleanup);
+        res.flushHeaders?.();
+        res.write('retry: 1000\n');
+        writeSse(res);
+        for (const event of listRecentThreadEventsAfter(threadId, replayAfter, {
+            limit: MIRRORED_THREAD_STREAM_REPLAY_LIMIT,
+            maxBytes: MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES,
+        })) {
+            const chunk = threadStreamChunkForEvent(event);
+            if (!chunk)
+                continue;
+            writeThreadStreamEvent(res, chunk, { id: event.sequence });
+        }
+        res.flush?.();
+        return true;
+    }
+    const mirroredThreadHistoryMatch = pathname.match(/^\/api\/computer\/codex\/threads\/([^/]+)\/messages$/);
+    if (mirroredThreadHistoryMatch && method === 'GET') {
+        const threadId = decodeURIComponent(mirroredThreadHistoryMatch[1] || '').trim();
+        const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
+        const limit = limitRaw ? Number.parseInt(limitRaw, 10) : MIRRORED_THREAD_HISTORY_LIMIT;
+        const history = threadId
+            ? readCodexThreadHistory(threadId, Number.isFinite(limit) ? limit : MIRRORED_THREAD_HISTORY_LIMIT)
+            : null;
+        if (!history) {
+            writeProtocolError(res, 404, 'not_found', 'mirrored_thread_not_found', 'Mirrored task history was not found.');
+            return true;
+        }
+        writeJson(res, 200, history);
+        return true;
+    }
+    const mirroredThreadAdoptMatch = pathname.match(/^\/api\/computer\/codex\/threads\/([^/]+)\/adopt$/);
+    if (mirroredThreadAdoptMatch && method === 'POST') {
+        const threadId = decodeURIComponent(mirroredThreadAdoptMatch[1] || '').trim();
+        const parsed = await readJsonBody(req);
+        const requestedAgentId = parsed && typeof parsed === 'object' && typeof parsed.agent_id === 'string'
+            ? String(parsed.agent_id).trim()
+            : '';
+        const fallbackAgentId = getAllAgents()[0]?.agent_id || 'local-agent-mirror';
+        const agentId = requestedAgentId || fallbackAgentId;
+        const session = threadId ? adoptMirroredThread(threadId, agentId) : null;
+        if (!session) {
+            writeProtocolError(res, 404, 'not_found', 'mirrored_thread_not_found', 'Mirrored task history was not found.');
+            return true;
+        }
+        writeJson(res, 200, { thread: serializeAdoptedMirroredThread(session) });
+        return true;
+    }
+    if (pathname === '/api/computer/codex/projects/open' && method === 'POST') {
+        try {
+            const parsed = await readJsonBody(req);
+            const projectPath = parsed && typeof parsed === 'object' && typeof parsed.path === 'string'
+                ? String(parsed.path).trim()
+                : '';
+            if (!projectPath || !path.isAbsolute(projectPath) || !fs.existsSync(projectPath)) {
+                writeProtocolError(res, 400, 'validation_error', 'invalid_project_path', 'Request body must include an existing absolute project path.');
+                return true;
+            }
+            const opener = process.platform === 'darwin'
+                ? { command: 'open', args: [projectPath] }
+                : process.platform === 'win32'
+                    ? { command: 'cmd', args: ['/c', 'start', '', projectPath] }
+                    : { command: 'xdg-open', args: [projectPath] };
+            const child = spawn(opener.command, opener.args, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            writeJson(res, 200, { ok: true });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'open_error', 'project_open_failed', err?.message || 'Failed to open project.');
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/mcp/servers' && method === 'GET') {
+        writeJson(res, 200, { servers: buildMcpSettingsResponse().servers });
+        return true;
+    }
+    /** Tools discovered via MCP `tools/list` for each connected server (in-memory; empty if servers not connected). */
+    if (pathname === '/api/computer/mcp/tool-catalog' && method === 'GET') {
+        try {
+            const force = url.searchParams.get('refresh') === '1' || url.searchParams.get('force') === '1';
+            const mgr = await getMcpManager({ forceConfigRefresh: force });
+            const tools = mgr.getAllTools().map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+                serverId: t.serverId,
+                serverName: t.serverName,
+            }));
+            const mcpProcessMeta = mgr.getMcpProcessMetaByServerId();
+            writeJson(res, 200, { tools, mcpProcessMeta });
+        }
+        catch {
+            writeJson(res, 200, { tools: [], mcpProcessMeta: [] });
+        }
+        return true;
+    }
+    if (pathname === '/api/computer/mcp/settings' && method === 'GET') {
+        writeJson(res, 200, buildMcpSettingsResponse());
+        return true;
+    }
+    if (pathname === '/api/computer/mcp/settings' && method === 'PUT') {
+        const parsed = await readJsonBody(req);
+        const allowedKeys = new Set(listMcpEnvKeys());
+        const payloadEnv = parsed && typeof parsed === 'object' && parsed.env && typeof parsed.env === 'object'
+            ? parsed.env
+            : {};
+        const updates = {};
+        for (const [key, rawValue] of Object.entries(payloadEnv)) {
+            if (!allowedKeys.has(key))
+                continue;
+            if (typeof rawValue !== 'string') {
+                updates[key] = null;
+                continue;
+            }
+            const normalized = rawValue.trim();
+            updates[key] = normalized.length > 0 ? normalized : null;
+        }
+        updateMcpEnvOverrides(updates);
+        writeJson(res, 200, buildMcpSettingsResponse());
+        return true;
+    }
+    if (pathname === '/api/computer' && method === 'GET') {
+        const cpus = os.cpus();
+        const memTotal = os.totalmem();
+        const memFree = os.freemem();
+        const enroll = readEnrollmentState(DAEMON_HOSTNAME || undefined);
+        let disk_total;
+        let disk_free;
+        let disk_used;
+        try {
+            const stats = fs.statfsSync(SUPEN_HOME);
+            disk_total = stats.bsize * stats.blocks;
+            disk_free = stats.bsize * stats.bavail;
+            disk_used = disk_total - disk_free;
+        }
+        catch { /* ignore */ }
+        writeJson(res, 200, {
+            daemon_id: enroll.daemon_id,
+            hostname: os.hostname(),
+            version: process.env.SUPEN_DAEMON_VERSION || process.env.npm_package_version || null,
+            runtime: {
+                node: process.version,
+                platform: process.platform,
+                arch: process.arch,
+            },
+            build: {
+                git_sha: process.env.SUPEN_DAEMON_GIT_SHA || process.env.RENDER_GIT_COMMIT || null,
+                image: process.env.RENDER_COMPUTER_IMAGE || process.env.SUPEN_DAEMON_IMAGE || null,
+            },
+            enrollment: {
+                trust_state: enroll.trust_state,
+                fingerprint: enroll.daemon_fingerprint,
+                trusted_at: enroll.trusted_at ?? null,
+                failed_attempts: enroll.failed_attempts,
+            },
+            executor: {
+                active_tasks: 0,
+                queued_tasks: 0,
+                total_slots: 0,
+            },
+            os: {
+                hostname: os.hostname(),
+                platform: os.platform(),
+                arch: os.arch(),
+                cpus: cpus.length,
+                cpu_model: cpus[0]?.model || 'Unknown',
+                load_avg: os.loadavg(),
+                mem_total: memTotal,
+                mem_free: memFree,
+                mem_used: memTotal - memFree,
+                uptime: os.uptime(),
+                disk_total,
+                disk_free,
+                disk_used,
+            },
+        });
+        return true;
+    }
+    // ── Enrollment ──
+    if (pathname === '/api/computer/enroll/status' && method === 'GET') {
+        const state = readEnrollmentState(DAEMON_HOSTNAME || undefined);
+        writeJson(res, 200, state);
+        return true;
+    }
+    if (pathname === '/api/computer/enroll/verify' && method === 'POST') {
+        const parsed = await readJsonBody(req);
+        const result = verifyEnrollmentToken({
+            token: parsed.token,
+            daemonFingerprint: parsed.daemon_fingerprint,
+            daemonId: DAEMON_HOSTNAME || undefined,
+        });
+        writeJson(res, result.ok ? 200 : 401, result);
+        return true;
+    }
+    if (pathname === '/api/computer/trust' && method === 'POST') {
+        writeProtocolError(res, 410, 'auth_error', 'trust_endpoint_removed', 'Direct trust elevation is disabled. Use the enrollment flow (/api/computer/enroll/token + /api/computer/enroll/verify) to transition a daemon to trusted state.');
+        return true;
+    }
+    // Create enrollment token
+    if (pathname === '/api/computer/enroll/token' && method === 'POST') {
+        try {
+            const parsed = await readJsonBody(req);
+            const ttlMinutes = parsed?.ttl_minutes || DEFAULT_TOKEN_TTL_MINUTES;
+            const result = createEnrollmentToken({
+                ttlMinutes,
+                daemonId: DAEMON_HOSTNAME || undefined,
+            });
+            writeJson(res, 200, {
+                ok: true,
+                token: result.token,
+                expires_at: result.expires_at,
+            });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'enrollment_error', 'token_creation_failed', err.message);
+        }
+        return true;
+    }
+    // Revoke enrollment
+    if (pathname === '/api/computer/enroll/revoke' && method === 'POST') {
+        try {
+            setTrustState('revoked', { daemonId: DAEMON_HOSTNAME || undefined });
+            writeJson(res, 200, { ok: true, trust_state: 'revoked' });
+        }
+        catch (err) {
+            writeProtocolError(res, 500, 'enrollment_error', 'revoke_failed', err.message);
+        }
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=system.js.map