@supen-ai/cli 1.3.3 → 1.4.0

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

@@ -6,7 +6,7 @@ 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 { readSpaceEnvMap, updateSpaceEnvMap, withRuntimeSpaceEnv, 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';
@@ -22,6 +22,7 @@ import { logger } from '../../core/logger.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 { projectThreadRuntimeState } from '../../core/thread-runtime-state.js';
 import { addThreadStreamClient, removeThreadStreamClient, writeThreadStreamEvent } from '../thread-stream.js';
 const DEFAULT_TOKEN_TTL_MINUTES = 20;
 const SPACE_LOG_EVENT_LIMIT = 200;
@@ -29,22 +30,23 @@ 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_HISTORY_MAX_BYTES = 256 * 1024 * 1024;
+const MIRRORED_THREAD_PROJECTION_VERSION = 2;
 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_STREAM_JSONL_POLL_MS = 500;
+const MIRRORED_THREAD_STREAM_JSONL_READ_MAX_BYTES = 2 * 1024 * 1024;
+const MIRRORED_THREAD_STATUS_TAIL_MAX_BYTES = 256 * 1024;
 const MIRRORED_THREAD_RUNNING_LEASE_MS = 30 * 60 * 1000;
 const MIRRORED_THREAD_HISTORY_CHUNK_BYTES = 1024 * 1024;
+const MIRRORED_THREAD_SESSION_FILE_INDEX_TTL_MS = 2_000;
 const require = createRequire(import.meta.url);
 const HOST_DAEMON_INSTALL_DIR = path.join(SUPEN_HOME, 'daemon');
 const HOST_DAEMON_CLI_PACKAGE_ROOT = path.join(HOST_DAEMON_INSTALL_DIR, 'node_modules', '@supen-ai', 'cli');
 const HOST_DAEMON_BIN_PATH = path.join(HOST_DAEMON_CLI_PACKAGE_ROOT, 'daemon', 'scripts', 'supen-daemon.js');
-const HOST_DAEMON_PACKAGE_SPEC = '@supen-ai/cli';
+const HOST_DAEMON_PACKAGE_SPEC = '@supen-ai/cli@latest';
 function readSqliteRows(dbPath, query) {
     try {
         const { DatabaseSync } = require('node:sqlite');
@@ -437,6 +439,9 @@ export function readRecentJsonlLines(filePath, maxBytes = MIRRORED_THREAD_HISTOR
     }
 }
 function isCodexHistoryMessageLine(line) {
+    if (!line.includes('"type":"message"') && !line.includes('"type":"user_message"')) {
+        return false;
+    }
     const parsed = parseJsonLine(line);
     const payload = parsed?.payload && typeof parsed.payload === 'object'
         ? parsed.payload
@@ -444,8 +449,78 @@ function isCodexHistoryMessageLine(line) {
     return ((parsed?.type === 'event_msg' && payload.type === 'user_message') ||
         (parsed?.type === 'response_item' && payload.type === 'message'));
 }
+function isCodexVisibleUserHistoryLine(line) {
+    const parsed = parseJsonLine(line);
+    const payload = parsed?.payload && typeof parsed.payload === 'object'
+        ? parsed.payload
+        : {};
+    if (parsed?.type === 'event_msg' && payload.type === 'user_message') {
+        const text = typeof payload.message === 'string' ? payload.message.trim() : '';
+        return Boolean(text && !isInternalMirroredUserMessage(text));
+    }
+    if (parsed?.type !== 'response_item' || payload.type !== 'message' || payload.role !== 'user') {
+        return false;
+    }
+    const text = mirroredMessageContentParts(payload.content).text;
+    return Boolean(text && !isInternalMirroredUserMessage(sanitizeMirroredUserText(text)));
+}
+function isCodexHistoryTranscriptEventLine(line) {
+    if (!line.includes('"type":"function_call"') &&
+        !line.includes('"type":"custom_tool_call"') &&
+        !line.includes('"type":"patch_apply_end"') &&
+        !line.includes('"type":"tool_search_call"') &&
+        !line.includes('"type":"web_search_call"') &&
+        !line.includes('"type":"mcp_tool_call"')) {
+        return false;
+    }
+    const parsed = parseJsonLine(line);
+    const payload = parsed?.payload && typeof parsed.payload === 'object'
+        ? parsed.payload
+        : {};
+    if (parsed?.type === 'event_msg') {
+        return payload.type === 'patch_apply_end';
+    }
+    if (parsed?.type !== 'response_item')
+        return false;
+    return (payload.type === 'function_call' ||
+        payload.type === 'custom_tool_call' ||
+        payload.type === 'tool_search_call' ||
+        payload.type === 'web_search_call' ||
+        payload.type === 'mcp_tool_call');
+}
+function isCodexHistoryTranscriptLine(line) {
+    return isCodexHistoryMessageLine(line) || isCodexHistoryTranscriptEventLine(line);
+}
+function isCodexJsonlMessageRecord(parsed) {
+    const payload = parsed?.payload && typeof parsed.payload === 'object'
+        ? parsed.payload
+        : {};
+    return parsed?.type === 'response_item' && payload.type === 'message';
+}
+function codexJsonlEventChunk(parsed) {
+    const payload = parsed.payload && typeof parsed.payload === 'object'
+        ? parsed.payload
+        : {};
+    const payloadType = typeof payload.type === 'string' ? payload.type : '';
+    return {
+        type: 'data-codex-event',
+        data: {
+            eventType: `codex-jsonl/${parsed.type || 'record'}${payloadType ? `/${payloadType}` : ''}`,
+            raw: parsed,
+        },
+    };
+}
+function codexAppServerEventChunk(method, params = {}) {
+    return {
+        type: 'data-codex-event',
+        data: {
+            eventType: method,
+            raw: { method, params },
+        },
+    };
+}
 function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRRORED_THREAD_HISTORY_MAX_BYTES) {
-    const safeTargetMessages = Math.max(1, Math.min(Math.floor(targetMessages), 501));
+    const safeTargetMessages = Math.max(1, Math.min(Math.floor(targetMessages), 5_000));
     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');
@@ -468,12 +543,9 @@ function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRROR
                 lines.unshift(leadingPartial);
                 leadingPartial = '';
             }
-            const completeLines = lines.filter(Boolean);
-            for (const line of completeLines) {
-                if (isCodexHistoryMessageLine(line))
-                    messageCount += 1;
-            }
-            collected = [...completeLines, ...collected];
+            const historyLines = lines.filter((line) => line && isCodexHistoryTranscriptLine(line));
+            messageCount += historyLines.filter(isCodexVisibleUserHistoryLine).length;
+            collected = [...historyLines, ...collected];
         }
         return collected.filter(Boolean);
     }
@@ -578,7 +650,8 @@ function readThreadStateEntries(limit) {
         return [];
     }
 }
-function walkSessionFiles(dir, out = new Map()) {
+let mirroredSessionFileIndexCache = null;
+function walkSessionFilesUncached(dir, out = new Map()) {
     if (!fs.existsSync(dir))
         return out;
     let entries;
@@ -591,7 +664,7 @@ function walkSessionFiles(dir, out = new Map()) {
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            walkSessionFiles(fullPath, out);
+            walkSessionFilesUncached(fullPath, out);
             continue;
         }
         if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
@@ -602,6 +675,21 @@ function walkSessionFiles(dir, out = new Map()) {
     }
     return out;
 }
+function walkSessionFiles(dir) {
+    const now = Date.now();
+    if (mirroredSessionFileIndexCache &&
+        mirroredSessionFileIndexCache.root === dir &&
+        now - mirroredSessionFileIndexCache.indexedAt <= MIRRORED_THREAD_SESSION_FILE_INDEX_TTL_MS) {
+        return new Map(mirroredSessionFileIndexCache.files);
+    }
+    const files = walkSessionFilesUncached(dir);
+    mirroredSessionFileIndexCache = {
+        root: dir,
+        indexedAt: now,
+        files: new Map(files),
+    };
+    return files;
+}
 function readFileHead(filePath, maxBytes = 64 * 1024) {
     const fd = fs.openSync(filePath, 'r');
     try {
@@ -626,6 +714,34 @@ function readFileTail(filePath, maxBytes = 256 * 1024) {
         fs.closeSync(fd);
     }
 }
+function readAppendedJsonlLines(filePath, offset) {
+    if (!fs.existsSync(filePath))
+        return { offset, lines: [], partial: '' };
+    const stat = fs.statSync(filePath);
+    if (stat.size <= offset)
+        return { offset: stat.size, lines: [], partial: '' };
+    const bytesToRead = Math.min(stat.size - offset, MIRRORED_THREAD_STREAM_JSONL_READ_MAX_BYTES);
+    const readStart = stat.size - offset > MIRRORED_THREAD_STREAM_JSONL_READ_MAX_BYTES
+        ? stat.size - MIRRORED_THREAD_STREAM_JSONL_READ_MAX_BYTES
+        : offset;
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(bytesToRead);
+        const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, readStart);
+        const text = buffer.subarray(0, bytesRead).toString('utf-8');
+        const parts = text.split(/\r?\n/);
+        const partial = text.endsWith('\n') || text.endsWith('\r') ? '' : (parts.pop() || '');
+        const completeLines = parts.filter(Boolean);
+        return {
+            offset: readStart + bytesRead - Buffer.byteLength(partial),
+            lines: readStart === offset ? completeLines : completeLines.slice(1),
+            partial,
+        };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function readThreadWorkspacePath(filePath) {
     if (!filePath)
         return null;
@@ -649,6 +765,91 @@ function readThreadWorkspacePath(filePath) {
     }
     return null;
 }
+function startCodexThreadObserver(input) {
+    const child = spawn('codex', ['app-server', '--listen', 'stdio://'], {
+        cwd: input.cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: withRuntimeSpaceEnv(process.env),
+    });
+    let buffer = '';
+    let nextId = 1;
+    let observerEventIndex = 0;
+    let initialized = false;
+    const send = (message) => {
+        if (!child.stdin.writable)
+            return;
+        child.stdin.write(`${JSON.stringify(message)}\n`);
+    };
+    const request = (method, params) => {
+        send({ id: nextId++, method, ...(params ? { params } : {}) });
+    };
+    child.stdout.on('data', (chunk) => {
+        buffer += String(chunk);
+        while (true) {
+            const newlineIndex = buffer.indexOf('\n');
+            if (newlineIndex < 0)
+                break;
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line.startsWith('{'))
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.id !== undefined && typeof parsed.method === 'string') {
+                send({ id: parsed.id, result: {} });
+                continue;
+            }
+            if (parsed.id !== undefined) {
+                if (!initialized && parsed.id === 1) {
+                    initialized = true;
+                    send({ method: 'initialized' });
+                    request('thread/resume', {
+                        threadId: input.threadId,
+                        cwd: input.cwd,
+                        experimentalRawEvents: true,
+                    });
+                }
+                continue;
+            }
+            const method = typeof parsed.method === 'string' ? parsed.method : '';
+            if (!method)
+                continue;
+            const params = parsed.params && typeof parsed.params === 'object'
+                ? parsed.params
+                : {};
+            const eventThreadId = typeof params.threadId === 'string' ? params.threadId : '';
+            if (eventThreadId !== input.threadId)
+                continue;
+            observerEventIndex += 1;
+            input.write(codexAppServerEventChunk(method, params), `observer-${Date.now()}-${observerEventIndex}`);
+        }
+    });
+    child.stderr.on('data', () => { });
+    child.once('error', (error) => {
+        logger.debug({ err: error, threadId: input.threadId }, 'Codex thread observer failed');
+    });
+    request('initialize', {
+        clientInfo: {
+            name: 'supen-daemon-thread-observer',
+            title: 'Supen',
+            version: '0.1.0',
+        },
+        capabilities: { experimentalApi: true },
+    });
+    return () => {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch {
+            // Observer cleanup is best-effort; the HTTP stream is already closing.
+        }
+    };
+}
 function normalizeThreadStatusToken(value) {
     return typeof value === 'string'
         ? value.trim().toLowerCase().replace(/[-_\s]/g, '')
@@ -701,7 +902,7 @@ function readThreadStatus(filePath) {
         let sawUserTurn = false;
         let completedAfterLastUser = false;
         let lastRunningActivityMs = null;
-        const tail = readFileTail(filePath, MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES);
+        const tail = readFileTail(filePath, MIRRORED_THREAD_STATUS_TAIL_MAX_BYTES);
         for (const line of tail.split(/\r?\n/)) {
             if (!line.trim())
                 continue;
@@ -711,7 +912,9 @@ function readThreadStatus(filePath) {
                 ? parsed.payload
                 : {};
             if (parsed?.type === 'event_msg') {
-                if (payload.type === 'task_started' || payload.type === 'user_message') {
+                if (payload.type === 'task_started' ||
+                    payload.type === 'user_message' ||
+                    payload.type === 'thread_goal_updated') {
                     sawUserTurn = true;
                     completedAfterLastUser = false;
                     lastRunningActivityMs = timestampMs;
@@ -734,6 +937,26 @@ function readThreadStatus(filePath) {
                 lastRunningActivityMs = timestampMs;
                 continue;
             }
+            if (parsed?.type === 'response_item' &&
+                payload.type === 'message' &&
+                payload.role === 'assistant') {
+                if (payload.phase === 'final_answer') {
+                    completedAfterLastUser = true;
+                    continue;
+                }
+                if (sawUserTurn) {
+                    completedAfterLastUser = false;
+                    lastRunningActivityMs = timestampMs;
+                }
+                continue;
+            }
+            if (parsed?.type === 'response_item' &&
+                sawUserTurn &&
+                !completedAfterLastUser &&
+                payload.type !== 'reasoning') {
+                lastRunningActivityMs = timestampMs;
+                continue;
+            }
             const raw = payload.raw && typeof payload.raw === 'object'
                 ? payload.raw
                 : null;
@@ -778,6 +1001,17 @@ function readThreadStatus(filePath) {
         return 'idle';
     }
 }
+function readMirroredThreadStatus(threadId, filePath) {
+    try {
+        const runtimeState = projectThreadRuntimeState(threadId);
+        if (isRunningThreadStatusToken(runtimeState.runtime.status))
+            return 'running';
+    }
+    catch {
+        // Fall back to the Codex session file status below.
+    }
+    return readThreadStatus(filePath);
+}
 function projectNameFromPath(projectPath) {
     if (!projectPath)
         return 'No workspace';
@@ -896,7 +1130,7 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
                 id: entry.id,
                 title,
                 updated_at: entry.updated_at,
-                status: readThreadStatus(sessionPath),
+                status: readMirroredThreadStatus(entry.id, sessionPath),
                 session_path: sessionPath,
             });
             projects.set(projectId, project);
@@ -927,7 +1161,7 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
             id: entry.id,
             title: entry.thread_name,
             updated_at: entry.updated_at,
-            status: readThreadStatus(sessionPath),
+            status: readMirroredThreadStatus(entry.id, sessionPath),
             session_path: sessionPath,
         });
         projects.set(projectId, project);
@@ -953,34 +1187,6 @@ function truncateMirroredHistoryString(value, limit, label) {
     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:') &&
@@ -1082,117 +1288,15 @@ function isInternalMirroredUserMessage(text) {
     const trimmed = text.trimStart();
     return (trimmed.startsWith('<environment_context>') ||
         trimmed.startsWith('<developer_context>') ||
+        trimmed.startsWith('<codex_internal_context') ||
+        trimmed.startsWith('<goal_context>') ||
+        trimmed.startsWith('<turn_aborted>') ||
         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-codex-event',
-            id: eventId,
-            data: { raw },
-        },
-    };
-}
 function mirroredThreadWorkspacePath(sessionPath, stateEntry) {
     const stateCwd = typeof stateEntry?.cwd === 'string' ? stateEntry.cwd : null;
     const sessionWorkspace = readThreadWorkspacePath(sessionPath);
@@ -1202,6 +1306,53 @@ function mirroredThreadWorkspacePath(sessionPath, stateEntry) {
     }
     return null;
 }
+function latestRawThreadEventTimestampMs(events) {
+    let latest = null;
+    for (const event of events) {
+        const timestampMs = Date.parse(event.received_at);
+        if (!Number.isFinite(timestampMs))
+            continue;
+        latest = latest === null ? timestampMs : Math.max(latest, timestampMs);
+    }
+    return latest;
+}
+function rawThreadEventsAreStaleForHistory(events, latestHistoryTimestamp) {
+    const latestEventTimestampMs = latestRawThreadEventTimestampMs(events);
+    if (latestEventTimestampMs === null)
+        return false;
+    const latestHistoryTimestampMs = Date.parse(latestHistoryTimestamp);
+    if (!Number.isFinite(latestHistoryTimestampMs))
+        return false;
+    return latestEventTimestampMs + 30_000 < latestHistoryTimestampMs;
+}
+function collapseCompletedAssistantProgressMessages(input) {
+    const output = [];
+    let assistantRun = [];
+    const flushAssistantRun = () => {
+        if (assistantRun.length === 0)
+            return;
+        const finalAnswers = assistantRun.filter((message) => message.phase === 'final_answer');
+        if (finalAnswers.length > 0) {
+            output.push(...finalAnswers);
+        }
+        else {
+            output.push(...assistantRun);
+        }
+        assistantRun = [];
+    };
+    for (const message of input) {
+        if (message.role === 'assistant') {
+            assistantRun.push(message);
+            continue;
+        }
+        flushAssistantRun();
+        output.push(message);
+    }
+    flushAssistantRun();
+    return output
+        .filter((message) => message.internal !== true)
+        .map(({ phase: _phase, internal: _internal, ...message }) => message);
+}
 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);
@@ -1212,24 +1363,50 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
     const workspacePath = mirroredThreadWorkspacePath(sessionPath, stateEntry);
     const indexEntry = readThreadIndexEntry(threadId);
     const eventLogHead = readThreadEventLogHead(eventLogThreadId);
-    const lines = readRecentCodexHistoryLines(sessionPath, safeLimit + 1);
+    const historyLineTarget = Math.min(120, Math.max(3, Math.ceil(safeLimit / 4)));
+    const lines = readRecentCodexHistoryLines(sessionPath, historyLineTarget);
     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);
+        const pushInternalBoundary = () => {
+            let lastVisibleMessage;
+            for (let index = messages.length - 1; index >= 0; index -= 1) {
+                if (messages[index].internal === true)
+                    continue;
+                lastVisibleMessage = messages[index];
+                break;
+            }
+            if (lastVisibleMessage?.role !== 'assistant' || lastVisibleMessage.phase !== 'final_answer') {
+                return;
+            }
+            messages.push({
+                id: messageId || `${threadId}-internal-${messageIndex + 1}`,
+                role: 'system',
+                content: '',
+                timestamp,
+                task_id: threadId,
+                internal: true,
+            });
+        };
         if (isMirroredGoalContextMessage(text)) {
             recentGoalContext = { text, timestamp };
+            pushInternalBoundary();
+            return;
         }
         text = truncateMirroredHistoryString(text, MIRRORED_THREAD_TEXT_LIMIT, 'Message');
-        if ((!text && attachments.length === 0) || isInternalMirroredUserMessage(text))
+        if (isInternalMirroredUserMessage(text)) {
+            pushInternalBoundary();
+            return;
+        }
+        if (!text && attachments.length === 0)
             return;
         const key = mirroredUserMessageKey(text);
         const timestampMs = Date.parse(timestamp);
@@ -1309,37 +1486,13 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
         const messageId = typeof payload.id === 'string' ? payload.id : `${threadId}-web-user-${event.sequence}`;
         pushUserMessage(text, timestamp, messageId, attachments);
     };
-    const pushEvent = (timestamp, chunk) => {
+    const pushCodexJsonlEvent = (parsed, timestamp) => {
         eventIndex += 1;
         events.push({
-            id: `${threadId}-event-${eventIndex}`,
+            id: `${threadId}-jsonl-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)) }),
+            chunk: codexJsonlEventChunk(parsed),
         });
     };
     for (const line of lines) {
@@ -1356,148 +1509,20 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
             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;
+            else if (payload.type === 'patch_apply_end') {
+                pushCodexJsonlEvent(parsed, timestamp);
             }
-        }
-        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));
+        if (payload.type !== 'message') {
+            if (isCodexHistoryTranscriptEventLine(line)) {
+                pushCodexJsonlEvent(parsed, timestamp);
             }
             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;
@@ -1517,16 +1542,22 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
             content: truncateMirroredHistoryString(text, MIRRORED_THREAD_TEXT_LIMIT, 'Message'),
             timestamp,
             task_id: threadId,
+            ...(typeof payload.phase === 'string' && payload.phase.trim()
+                ? { phase: payload.phase.trim() }
+                : {}),
         });
     }
     const eventLogEvents = listRecentThreadEventsAfter(eventLogThreadId, 0, {
         limit: MIRRORED_THREAD_STREAM_REPLAY_LIMIT,
         maxBytes: MIRRORED_THREAD_STREAM_REPLAY_MAX_BYTES,
     });
-    for (const event of eventLogEvents) {
+    const usableEventLogEvents = rawThreadEventsAreStaleForHistory(eventLogEvents, latestTimestamp)
+        ? []
+        : eventLogEvents;
+    for (const event of usableEventLogEvents) {
         pushWebUserMessage(event);
     }
-    for (const event of eventLogEvents) {
+    for (const event of usableEventLogEvents) {
         const chunk = threadStreamChunkForEvent(event);
         if (!chunk)
             continue;
@@ -1538,14 +1569,15 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
             chunk,
         });
     }
-    const slicedMessages = messages.slice(-safeLimit);
+    const collapsedMessages = collapseCompletedAssistantProgressMessages(messages);
+    const slicedMessages = collapsedMessages.slice(-safeLimit);
     const slicedEvents = events.slice(-safeLimit * 8);
-    const status = readThreadStatus(sessionPath);
+    const status = readMirroredThreadStatus(eventLogThreadId, sessionPath);
     const latestGoalContext = recentGoalContext;
     return {
         session: {
             task_id: threadId,
-            agent_id: 'local-agent-mirror',
+            agent_id: 'codex',
             channel: 'local-agent',
             source_ref: `local-agent:${threadId}`,
             title: indexEntry?.thread_name || stateEntry?.title || slicedMessages.find((message) => message.role === 'user')?.content || 'New Task',
@@ -1561,14 +1593,14 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
         items: [],
         runtimeState: {
             event_log_head: eventLogHead,
-            projection_version: 1,
+            projection_version: MIRRORED_THREAD_PROJECTION_VERSION,
             event_log: { status: 'current' },
             runtime: {
                 status: status === 'running' ? 'running' : 'idle',
                 updated_at: latestTimestamp || undefined,
             },
         },
-        has_more: messages.length > safeLimit,
+        has_more: collapsedMessages.length > safeLimit || lines.length >= historyLineTarget,
         ...(latestGoalContext ? { goal_context: latestGoalContext } : {}),
     };
 }
@@ -1616,14 +1648,14 @@ function coerceSingleQueryParam(value) {
     return value || null;
 }
 function codexThreadsListRoute(pathname) {
-    return /^\/api\/computers\/\{computer_id\}\/agents\/[^/]+\/codex\/threads$/.test(pathname);
+    return /^\/api\/computers\/\{computer_id\}\/agents\/codex\/threads$/.test(pathname);
 }
 function codexThreadActionRoute(pathname, action) {
     const suffix = action === 'messages' ? 'messages' : action;
-    return pathname.match(new RegExp(`^/api/computers/\\{computer_id\\}/agents/[^/]+/codex/threads/([^/]+)/${suffix}$`));
+    return pathname.match(new RegExp(`^/api/computers/\\{computer_id\\}/agents/codex/threads/([^/]+)/${suffix}$`));
 }
 function codexProjectsOpenRoute(pathname) {
-    return /^\/api\/computers\/\{computer_id\}\/agents\/[^/]+\/codex\/projects\/open$/.test(pathname);
+    return /^\/api\/computers\/\{computer_id\}\/agents\/codex\/projects\/open$/.test(pathname);
 }
 function collectSpaceLogEntries(filters = {}) {
     const spaceId = currentSpaceId();
@@ -1708,7 +1740,7 @@ function threadStreamChunkForEvent(event) {
         !Array.isArray(event.raw_payload) &&
         typeof event.raw_payload.type === 'string' &&
         String(event.raw_payload.type).trim()) {
-        return normalizeStoredCodexThreadChunk(event.raw_payload);
+        return event.raw_payload;
     }
     return {
         type: 'data-codex-event',
@@ -1718,28 +1750,6 @@ function threadStreamChunkForEvent(event) {
         },
     };
 }
-function normalizeStoredCodexThreadChunk(chunk) {
-    if (chunk.type !== 'data-supen-event')
-        return chunk;
-    const data = chunk.data && typeof chunk.data === 'object' && !Array.isArray(chunk.data)
-        ? chunk.data
-        : {};
-    const raw = data.raw && typeof data.raw === 'object' && !Array.isArray(data.raw)
-        ? data.raw
-        : {};
-    return {
-        ...chunk,
-        type: 'data-codex-event',
-        data: {
-            ...data,
-            eventType: typeof data.eventType === 'string' && data.eventType.trim()
-                ? data.eventType
-                : typeof raw.method === 'string' && raw.method.trim()
-                    ? raw.method
-                    : 'codex-event',
-        },
-    };
-}
 function buildMcpSettingsResponse() {
     const overrides = getMcpEnvOverrides();
     const runtimeEnv = { ...process.env };
@@ -1768,11 +1778,9 @@ function buildMcpSettingsResponse() {
 }
 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,
 };
 function resolveManagedCodingCliInstallCommand(cli, current) {
     if (cli === 'codex' && current.install_source === 'homebrew') {
@@ -1783,7 +1791,7 @@ function resolveManagedCodingCliInstallCommand(cli, current) {
     }
     return MANAGED_CODING_CLI_INSTALL_COMMANDS[cli];
 }
-const CODING_CLI_NAMES = ['codex', 'gemini', 'claude'];
+const CODING_CLI_NAMES = ['codex'];
 const DETECTABLE_SPACE_APPS = [
     { id: 'libreoffice', command: 'libreoffice', managed: false },
     { id: 'dotnet', command: 'dotnet', managed: false },
@@ -1806,18 +1814,18 @@ function nowIso() {
 }
 function normalizeCliName(raw) {
     const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
-    if (value === 'codex' || value === 'gemini' || value === 'claude')
+    if (value === 'codex')
         return value;
     return null;
 }
 function normalizeCodexTransport(raw) {
     const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
-    if (value === 'app-server' || value === 'exec' || value === 'acpx')
+    if (value === 'app-server')
         return value;
     return null;
 }
 function isManagedCliName(name) {
-    return name === 'codex' || name === 'gemini';
+    return name === 'codex';
 }
 function trimLogNoise(value) {
     const line = value.trim();
@@ -1902,7 +1910,6 @@ function readPackageVersion(packageRoot) {
     }
 }
 function detectDaemonPackageStatus() {
-    const envVersion = process.env.SUPEN_DAEMON_VERSION || process.env.npm_package_version || null;
     let packageRoot = null;
     try {
         packageRoot = findPackageRootFrom(require.resolve('@supen-ai/daemon'), '@supen-ai/daemon');
@@ -1945,7 +1952,7 @@ function detectDaemonPackageStatus() {
                 ? 'local-package'
                 : null;
     return {
-        version: envVersion || bundledDaemonVersion || packageVersion,
+        version: bundledDaemonVersion || packageVersion,
         package_root: packageRoot || bundledDaemonRoot,
         install_source: installSource,
         update_supported: installSource === 'supen-cli-bundle' || installSource === 'npm-global',
@@ -2002,16 +2009,6 @@ function inferCliInstallSource(name, executablePath, resolvedPath) {
             return { install_source: 'node-package', update_supported: false };
         }
     }
-    if (name === 'gemini') {
-        const npmRoot = detectGlobalNpmRoot();
-        const geminiPackagePath = resolvedPath || executablePath || '';
-        if (npmRoot && geminiPackagePath.startsWith(`${npmRoot}${path.sep}@google${path.sep}gemini-cli${path.sep}`)) {
-            return { install_source: 'npm-global', update_supported: true };
-        }
-        if (normalized.includes('/node_modules/@google/gemini-cli/')) {
-            return { install_source: 'node-package', update_supported: false };
-        }
-    }
     return { install_source: null, update_supported: false };
 }
 function detectCliInstalled(name) {
@@ -2234,13 +2231,6 @@ function readCodingCliStatusPayload() {
     });
     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) => {
@@ -2257,9 +2247,9 @@ function readCodingCliStatusPayload() {
         };
     });
     return {
-        selected_cli,
-        default_model: selected_cli === 'codex' ? codexDefaultModel : null,
-        model_options: selected_cli === 'codex' ? codexModelOptions : [],
+        selected_cli: 'codex',
+        default_model: codexDefaultModel,
+        model_options: codexModelOptions,
         clis,
         agent_runtimes: [
             {
@@ -2271,53 +2261,9 @@ function readCodingCliStatusPayload() {
                 model_options: codexModelOptions,
                 transport: 'app-server',
                 recommended: true,
-                default: selected_cli === 'codex' && codexTransport === 'app-server',
+                default: true,
                 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),
@@ -2341,6 +2287,47 @@ function readInstalledAppsPayload() {
         }),
     };
 }
+const CODEX_SUBSCRIPTION_STATUS_WAIT_MS = 1800;
+const CODEX_SUBSCRIPTION_CACHE_TTL_MS = 5 * 60 * 1000;
+let cachedCodexSubscription = null;
+let codexSubscriptionRefreshInFlight = null;
+function refreshCodexSubscriptionStatus() {
+    if (codexSubscriptionRefreshInFlight)
+        return codexSubscriptionRefreshInFlight;
+    codexSubscriptionRefreshInFlight = readCodexSubscription()
+        .then((payload) => {
+        cachedCodexSubscription = { payload, cachedAt: Date.now() };
+        return payload;
+    })
+        .finally(() => {
+        codexSubscriptionRefreshInFlight = null;
+    });
+    return codexSubscriptionRefreshInFlight;
+}
+async function readCodexSubscriptionForStatus() {
+    if (cachedCodexSubscription &&
+        Date.now() - cachedCodexSubscription.cachedAt < CODEX_SUBSCRIPTION_CACHE_TTL_MS) {
+        return { payload: cachedCodexSubscription.payload, error: null };
+    }
+    const refresh = refreshCodexSubscriptionStatus();
+    const timeout = new Promise((resolve) => {
+        setTimeout(() => resolve(null), CODEX_SUBSCRIPTION_STATUS_WAIT_MS).unref?.();
+    });
+    try {
+        const payload = await Promise.race([refresh, timeout]);
+        if (payload)
+            return { payload, error: null };
+    }
+    catch (err) {
+        if (cachedCodexSubscription)
+            return { payload: cachedCodexSubscription.payload, error: null };
+        return { payload: null, error: err?.message || 'Unable to read Codex subscription details.' };
+    }
+    if (cachedCodexSubscription)
+        return { payload: cachedCodexSubscription.payload, error: null };
+    refresh.catch(() => undefined);
+    return { payload: null, error: null };
+}
 function readCachedCodingCliStatusPayload(options) {
     startCodingCliStatusCache({
         build: () => ({
@@ -2415,14 +2402,22 @@ function codexSubscriptionSummary(subscription) {
         : {};
     return {
         plan_type: typeof rateLimits.planType === 'string' && rateLimits.planType.trim() ? rateLimits.planType.trim() : null,
-        credits_balance: typeof credits.balance === 'string' && credits.balance.trim() ? credits.balance.trim() : null,
+        credits_balance: typeof credits.balance === 'string' && credits.balance.trim()
+            ? credits.balance.trim()
+            : typeof credits.balance === 'number' && Number.isFinite(credits.balance)
+                ? String(credits.balance)
+                : null,
     };
 }
 async function readCodexAgentStatusPayload() {
-    const status = readCachedCodingCliStatusPayload();
+    const status = {
+        ...readCachedCodingCliStatusPayload(),
+        daemon: detectDaemonPackageStatus(),
+    };
     const quotaStatus = readLatestSpaceQuotaStatus();
-    try {
-        const subscription = await readCodexSubscription();
+    const subscriptionResult = await readCodexSubscriptionForStatus();
+    const subscription = subscriptionResult.payload;
+    if (subscription) {
         const subscriptionWindows = mergeQuotaWindows(normalizeCodexSubscriptionQuotaWindows(subscription), normalizeQuotaWindows(subscription.rate_limits), normalizeQuotaWindows(subscription.rate_limits_by_limit_id));
         return {
             ...status,
@@ -2437,71 +2432,37 @@ async function readCodexAgentStatusPayload() {
             quota_windows: mergeQuotaWindows(quotaStatus.windows, subscriptionWindows),
         };
     }
-    catch (err) {
-        return {
-            ...status,
-            subscription: {
-                ok: false,
-                fetched_at: null,
-                payload: null,
-                error: err?.message || 'Unable to read Codex subscription details.',
-            },
-            subscription_summary: {
-                plan_type: null,
-                credits_balance: null,
-            },
-            quota_status: quotaStatus,
-            quota_windows: quotaStatus.windows,
-        };
-    }
+    return {
+        ...status,
+        subscription: {
+            ok: false,
+            fetched_at: null,
+            payload: null,
+            error: subscriptionResult.error,
+        },
+        subscription_summary: {
+            plan_type: null,
+            credits_balance: null,
+        },
+        quota_status: quotaStatus,
+        quota_windows: quotaStatus.windows,
+    };
 }
 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 : [],
+        selected_cli: 'codex',
+        default_model: codexDefaultModel,
+        model_options: codexModelOptions,
         agent_runtimes: [
             {
                 id: 'codex-app-server',
-                default: selected_cli === 'codex' && codexTransport === 'app-server',
+                default: true,
                 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',
-            },
         ],
     };
 }
@@ -2787,7 +2748,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         try {
             const transport = normalizeCodexTransport(decodeURIComponent(codexTransportDefaultMatch[1] || '').trim());
             if (!transport) {
-                writeProtocolError(res, 400, 'validation_error', 'invalid_codex_transport', 'transport must be one of: app-server, exec, acpx');
+                writeProtocolError(res, 400, 'validation_error', 'invalid_codex_transport', 'transport must be app-server');
                 return true;
             }
             const result = setDefaultCodexTransport(transport);
@@ -2804,11 +2765,20 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
     }
     if (pathname === '/api/computers/{computer_id}/agents/codex/default' && method === 'PUT') {
         try {
+            const parsed = await readJsonBody(req);
+            const model = parsed && typeof parsed === 'object' && typeof parsed.model === 'string'
+                ? String(parsed.model).trim()
+                : '';
             const result = setDefaultCodingCli('codex');
+            if (model) {
+                writeCodexDefaultModel(model);
+            }
             writeJson(res, 200, {
                 ok: true,
                 ...result,
-                status: readCachedCodingCliStatusPayload({ force: true }),
+                status: model
+                    ? readRuntimeModelStatusPayload()
+                    : readCachedCodingCliStatusPayload({ force: true }),
             });
         }
         catch (err) {
@@ -2999,13 +2969,48 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
             numericQueryParam(coerceSingleQueryParam(url.searchParams.get('after')));
         const replayAfter = afterSequence ?? readThreadEventLogHead(threadId);
         addThreadStreamClient(threadId, res);
+        const sessionPath = walkSessionFiles(path.join(localAgentHome(), 'sessions')).get(threadId);
+        let jsonlOffset = sessionPath && fs.existsSync(sessionPath) ? fs.statSync(sessionPath).size : 0;
+        let jsonlEventIndex = 0;
+        const workspacePath = readThreadWorkspacePath(sessionPath) || process.cwd();
+        const stopCodexObserver = process.env.NODE_ENV === 'test'
+            ? () => { }
+            : startCodexThreadObserver({
+                threadId,
+                cwd: workspacePath,
+                write: (chunk, id) => writeThreadStreamEvent(res, chunk, id ? { id } : {}),
+            });
         const pingTimer = setInterval(() => {
             writeSse(res);
             res.flush?.();
         }, SPACE_LOG_STREAM_PING_MS);
         pingTimer.unref?.();
+        const jsonlPollTimer = sessionPath
+            ? setInterval(() => {
+                const read = readAppendedJsonlLines(sessionPath, jsonlOffset);
+                jsonlOffset = read.offset;
+                for (const line of read.lines) {
+                    if (!isCodexHistoryTranscriptLine(line))
+                        continue;
+                    const parsed = parseJsonLine(line);
+                    if (!parsed)
+                        continue;
+                    if (isCodexJsonlMessageRecord(parsed))
+                        continue;
+                    jsonlEventIndex += 1;
+                    writeThreadStreamEvent(res, codexJsonlEventChunk(parsed), {
+                        id: `jsonl-${jsonlOffset}-${jsonlEventIndex}`,
+                    });
+                }
+                res.flush?.();
+            }, MIRRORED_THREAD_STREAM_JSONL_POLL_MS)
+            : null;
+        jsonlPollTimer?.unref?.();
         const cleanup = () => {
             clearInterval(pingTimer);
+            if (jsonlPollTimer)
+                clearInterval(jsonlPollTimer);
+            stopCodexObserver();
             removeThreadStreamClient(threadId, res);
         };
         req.on('close', cleanup);
@@ -3047,7 +3052,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         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 fallbackAgentId = getAllAgents()[0]?.agent_id || 'codex';
         const agentId = requestedAgentId || fallbackAgentId;
         const session = threadId ? adoptMirroredThread(threadId, agentId) : null;
         if (!session) {