@supen-ai/cli 1.3.4 → 1.4.1

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,20 +22,27 @@ 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 { attachThreadContextToChunk, readThreadContext, } from '../../core/thread-context.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_HISTORY_LIMIT = 200;
+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_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');
@@ -433,6 +440,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
@@ -440,8 +450,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');
@@ -464,12 +544,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);
     }
@@ -574,7 +651,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;
@@ -587,7 +665,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'))
@@ -598,6 +676,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 {
@@ -622,6 +715,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;
@@ -645,6 +766,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, '')
@@ -697,7 +903,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;
@@ -707,7 +913,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;
@@ -730,6 +938,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;
@@ -774,6 +1002,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';
@@ -892,7 +1131,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);
@@ -923,7 +1162,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);
@@ -1050,6 +1289,9 @@ 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) {
@@ -1065,8 +1307,55 @@ 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 safeLimit = Math.max(1, Math.min(limit, 1000));
     const sessionPath = walkSessionFiles(path.join(localAgentHome(), 'sessions')).get(threadId);
     if (!sessionPath)
         return null;
@@ -1075,10 +1364,12 @@ 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(250, 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 mirroredUserMessageKey = (text) => sanitizeMirroredUserText(text)
@@ -1086,11 +1377,37 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
         .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);
@@ -1170,6 +1487,15 @@ 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 pushCodexJsonlEvent = (parsed, timestamp) => {
+        eventIndex += 1;
+        events.push({
+            id: `${threadId}-jsonl-event-${eventIndex}`,
+            timestamp,
+            task_id: threadId,
+            chunk: codexJsonlEventChunk(parsed),
+        });
+    };
     for (const line of lines) {
         const parsed = parseJsonLine(line);
         if (typeof parsed?.timestamp === 'string')
@@ -1185,12 +1511,19 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
                 const text = typeof payload.message === 'string' ? payload.message.trim() : '';
                 pushUserMessage(text, timestamp, undefined, imageAttachmentsFromUnknown(payload.images));
             }
+            else if (payload.type === 'patch_apply_end') {
+                pushCodexJsonlEvent(parsed, timestamp);
+            }
             continue;
         }
         if (parsed?.type !== 'response_item')
             continue;
-        if (payload.type !== 'message')
+        if (payload.type !== 'message') {
+            if (isCodexHistoryTranscriptEventLine(line)) {
+                pushCodexJsonlEvent(parsed, timestamp);
+            }
             continue;
+        }
         messageIndex += 1;
         const messageId = `${threadId}-message-${messageIndex}`;
         const role = payload.role;
@@ -1210,16 +1543,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;
@@ -1231,14 +1570,20 @@ 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;
+    const context = readThreadContext({
+        threadId,
+        eventLogThreadId,
+        workspace: workspacePath,
+    });
     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',
@@ -1254,14 +1599,15 @@ 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,
+        context,
+        has_more: collapsedMessages.length > safeLimit || lines.length >= historyLineTarget,
         ...(latestGoalContext ? { goal_context: latestGoalContext } : {}),
     };
 }
@@ -1309,14 +1655,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();
@@ -1439,11 +1785,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') {
@@ -1454,7 +1798,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 },
@@ -1477,18 +1821,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();
@@ -1672,16 +2016,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) {
@@ -1904,13 +2238,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) => {
@@ -1927,9 +2254,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: [
             {
@@ -1941,53 +2268,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),
@@ -2173,52 +2456,20 @@ async function readCodexAgentStatusPayload() {
     };
 }
 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',
-            },
         ],
     };
 }
@@ -2504,7 +2755,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);
@@ -2521,11 +2772,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) {
@@ -2716,13 +2976,49 @@ 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 withThreadContext = (chunk) => attachThreadContextToChunk(chunk, readThreadContext({ threadId, workspace: workspacePath }));
+        const stopCodexObserver = process.env.NODE_ENV === 'test'
+            ? () => { }
+            : startCodexThreadObserver({
+                threadId,
+                cwd: workspacePath,
+                write: (chunk, id) => writeThreadStreamEvent(res, withThreadContext(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, withThreadContext(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);
@@ -2737,7 +3033,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
             const chunk = threadStreamChunkForEvent(event);
             if (!chunk)
                 continue;
-            writeThreadStreamEvent(res, chunk, { id: event.sequence });
+            writeThreadStreamEvent(res, withThreadContext(chunk), { id: event.sequence });
         }
         res.flush?.();
         return true;
@@ -2764,7 +3060,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) {