@supen-ai/cli 1.4.1 → 1.4.3

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

@@ -14,7 +14,7 @@ import { collectOsTelemetryFields } from '../../core/os-info.js';
 import { getCodingCliStatusResponse, startCodingCliStatusCache, } from '../../core/coding-cli-status-cache.js';
 import { getGatewayInstance, getLlmToken } from '../../core/gateway.js';
 import { normalizeGatewayUplinkUrl, readGatewayConfig, writeGatewayConfig, } from '../../core/gateway-config.js';
-import { ensureSession, getAllAgents, getDailyUsage, getGlobalUsage, getSessionsForAgent, getSessionUiEvents, updateSessionBackendDriverId, updateSessionSdkId, } from '../../core/store.js';
+import { ensureThread, getAllAgents, getDailyUsage, getGlobalUsage, getThreadsForAgent, getThreadUiEvents, updateThreadBackendDriverId, updateThreadSdkSessionId, } from '../../core/store.js';
 import { listMcpEnvKeys, listMcpServers } from '../../mcp/default-servers.js';
 import { getMcpEnvOverrides, updateMcpEnvOverrides } from '../../mcp/settings.js';
 import { getMcpManager } from '../../mcp/index.js';
@@ -32,6 +32,9 @@ const SPACE_LOG_STREAM_PING_MS = 15000;
 const MIRRORED_THREAD_LIMIT = 80;
 const MIRRORED_THREAD_HISTORY_LIMIT = 200;
 const MIRRORED_THREAD_HISTORY_MAX_BYTES = 256 * 1024 * 1024;
+const MIRRORED_THREAD_HISTORY_FAST_MAX_BYTES = 8 * 1024 * 1024;
+const MIRRORED_THREAD_HISTORY_FAST_MAX_LINES = 2_000;
+const MIRRORED_THREAD_JSONL_CACHE_LIMIT = 64;
 const MIRRORED_THREAD_PROJECTION_VERSION = 2;
 const MIRRORED_THREAD_TEXT_LIMIT = 48_000;
 const MIRRORED_THREAD_INLINE_DATA_URL_LIMIT = 120_000;
@@ -114,6 +117,9 @@ function truncateStreamDelta(value, max = 160) {
 function currentSpaceId() {
     return (process.env.SUPEN_SPACE_ID || '').trim() || 'local';
 }
+const recentJsonlLineCache = new Map();
+const recentCodexHistoryLineCache = new Map();
+const mirroredFileTextCache = new Map();
 function summarizeStreamEvent(raw) {
     const inner = raw.event && typeof raw.event === 'object'
         ? raw.event
@@ -384,13 +390,13 @@ function extractQuotaEvent(event) {
     };
 }
 function readLatestSpaceQuotaStatus() {
-    const sessions = getAllAgents()
-        .flatMap((agent) => getSessionsForAgent(agent.agent_id).map((session) => ({
+    const threads = getAllAgents()
+        .flatMap((agent) => getThreadsForAgent(agent.agent_id).map((thread) => ({
         agent_id: agent.agent_id,
-        session_id: session.session_id,
+        thread_id: thread.thread_id,
     })));
-    const latest = sessions
-        .flatMap((session) => getSessionUiEvents(session.agent_id, session.session_id, 200)
+    const latest = threads
+        .flatMap((thread) => getThreadUiEvents(thread.agent_id, thread.thread_id, 200)
         .map((event) => extractQuotaEvent(event)))
         .filter((entry) => Boolean(entry))
         .sort((a, b) => a.updated_at.localeCompare(b.updated_at))
@@ -414,17 +420,84 @@ function parseJsonLine(line) {
         return null;
     }
 }
-export function readRecentJsonlLines(filePath, maxBytes = MIRRORED_THREAD_HISTORY_MAX_BYTES) {
-    const safeMaxBytes = Math.max(1, Math.min(Math.floor(maxBytes), MIRRORED_THREAD_HISTORY_MAX_BYTES));
-    const size = fs.statSync(filePath).size;
-    if (size <= safeMaxBytes) {
-        return fs.readFileSync(filePath, 'utf-8').split(/\r?\n/).filter(Boolean);
+function jsonlCacheKey(parts) {
+    return parts.map((part) => part === undefined ? '' : String(part)).join('\u0000');
+}
+function getCachedJsonlLines(cache, key, stat) {
+    const cached = cache.get(key);
+    if (!cached)
+        return null;
+    if (cached.size !== stat.size || cached.mtimeMs !== stat.mtimeMs) {
+        cache.delete(key);
+        return null;
+    }
+    cached.accessedAt = Date.now();
+    return cached.lines;
+}
+function setCachedJsonlLines(cache, key, entry) {
+    if (cache.size >= MIRRORED_THREAD_JSONL_CACHE_LIMIT && !cache.has(key)) {
+        let oldestKey = null;
+        let oldestAccess = Number.POSITIVE_INFINITY;
+        for (const [candidateKey, candidate] of cache) {
+            if (candidate.accessedAt < oldestAccess) {
+                oldestAccess = candidate.accessedAt;
+                oldestKey = candidateKey;
+            }
+        }
+        if (oldestKey)
+            cache.delete(oldestKey);
+    }
+    cache.set(key, {
+        ...entry,
+        accessedAt: Date.now(),
+    });
+    return entry.lines;
+}
+function getCachedFileText(key, stat) {
+    const cached = mirroredFileTextCache.get(key);
+    if (!cached)
+        return null;
+    if (cached.size !== stat.size || cached.mtimeMs !== stat.mtimeMs) {
+        mirroredFileTextCache.delete(key);
+        return null;
+    }
+    cached.accessedAt = Date.now();
+    return cached.text;
+}
+function setCachedFileText(key, stat, text) {
+    if (mirroredFileTextCache.size >= MIRRORED_THREAD_JSONL_CACHE_LIMIT && !mirroredFileTextCache.has(key)) {
+        let oldestKey = null;
+        let oldestAccess = Number.POSITIVE_INFINITY;
+        for (const [candidateKey, candidate] of mirroredFileTextCache) {
+            if (candidate.accessedAt < oldestAccess) {
+                oldestAccess = candidate.accessedAt;
+                oldestKey = candidateKey;
+            }
+        }
+        if (oldestKey)
+            mirroredFileTextCache.delete(oldestKey);
     }
+    mirroredFileTextCache.set(key, {
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        text,
+        accessedAt: Date.now(),
+    });
+    return text;
+}
+export function readRecentJsonlLines(filePath, maxBytes = MIRRORED_THREAD_HISTORY_FAST_MAX_BYTES) {
+    const safeMaxBytes = Math.max(1, Math.min(Math.floor(maxBytes), MIRRORED_THREAD_HISTORY_MAX_BYTES));
+    const stat = fs.statSync(filePath);
+    const cachedKey = jsonlCacheKey(['recent', filePath, safeMaxBytes]);
+    const cachedLines = getCachedJsonlLines(recentJsonlLineCache, cachedKey, stat);
+    if (cachedLines)
+        return cachedLines;
+    const size = stat.size;
     const readLength = Math.min(size, safeMaxBytes);
     const start = size - readLength;
     const fd = fs.openSync(filePath, 'r');
     try {
-        const buffer = Buffer.alloc(readLength);
+        const buffer = Buffer.allocUnsafe(readLength);
         const bytesRead = fs.readSync(fd, buffer, 0, readLength, start);
         let text = buffer.subarray(0, bytesRead).toString('utf-8');
         if (start > 0) {
@@ -433,7 +506,14 @@ export function readRecentJsonlLines(filePath, maxBytes = MIRRORED_THREAD_HISTOR
                 return [];
             text = text.slice(firstLineEnd + 1);
         }
-        return text.split(/\r?\n/).filter(Boolean);
+        const lines = text.split(/\r?\n/).filter(Boolean);
+        return setCachedJsonlLines(recentJsonlLineCache, cachedKey, {
+            filePath,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            maxBytes: safeMaxBytes,
+            lines,
+        });
     }
     finally {
         fs.closeSync(fd);
@@ -520,10 +600,15 @@ function codexAppServerEventChunk(method, params = {}) {
         },
     };
 }
-function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRRORED_THREAD_HISTORY_MAX_BYTES) {
+function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRRORED_THREAD_HISTORY_FAST_MAX_BYTES) {
     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 stat = fs.statSync(filePath);
+    const cachedKey = jsonlCacheKey(['codex-history', filePath, safeTargetMessages, safeMaxBytes]);
+    const cachedLines = getCachedJsonlLines(recentCodexHistoryLineCache, cachedKey, stat);
+    if (cachedLines)
+        return cachedLines;
+    const size = stat.size;
     const fd = fs.openSync(filePath, 'r');
     try {
         let position = size;
@@ -531,7 +616,10 @@ function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRROR
         let leadingPartial = '';
         let messageCount = 0;
         let collected = [];
-        while (position > 0 && scannedBytes < safeMaxBytes && messageCount < safeTargetMessages) {
+        while (position > 0 &&
+            scannedBytes < safeMaxBytes &&
+            messageCount < safeTargetMessages &&
+            collected.length < MIRRORED_THREAD_HISTORY_FAST_MAX_LINES) {
             const readLength = Math.min(MIRRORED_THREAD_HISTORY_CHUNK_BYTES, position, safeMaxBytes - scannedBytes);
             position -= readLength;
             scannedBytes += readLength;
@@ -548,17 +636,28 @@ function readRecentCodexHistoryLines(filePath, targetMessages, maxBytes = MIRROR
             messageCount += historyLines.filter(isCodexVisibleUserHistoryLine).length;
             collected = [...historyLines, ...collected];
         }
-        return collected.filter(Boolean);
+        const lines = collected.filter(Boolean);
+        return setCachedJsonlLines(recentCodexHistoryLineCache, cachedKey, {
+            filePath,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            maxBytes: safeMaxBytes,
+            targetMessages: safeTargetMessages,
+            lines,
+        });
     }
     finally {
         fs.closeSync(fd);
     }
 }
 function readThreadIndex(limit) {
-    const indexPath = path.join(localAgentHome(), 'session_index.jsonl');
+    const agentHome = localAgentHome();
+    const sessionIndexPath = path.join(agentHome, 'session_index.jsonl');
+    const threadIndexPath = path.join(agentHome, 'thread_index.jsonl');
+    const indexPath = fs.existsSync(sessionIndexPath) ? sessionIndexPath : threadIndexPath;
     if (!fs.existsSync(indexPath))
         return [];
-    const lines = fs.readFileSync(indexPath, 'utf-8').split(/\r?\n/).filter(Boolean);
+    const lines = readRecentJsonlLines(indexPath);
     const byId = new Map();
     for (const line of lines) {
         const parsed = parseJsonLine(line);
@@ -651,8 +750,8 @@ function readThreadStateEntries(limit) {
         return [];
     }
 }
-let mirroredSessionFileIndexCache = null;
-function walkSessionFilesUncached(dir, out = new Map()) {
+let mirroredThreadFileIndexCache = new Map();
+function walkThreadFilesUncached(dir, out = new Map()) {
     if (!fs.existsSync(dir))
         return out;
     let entries;
@@ -665,7 +764,7 @@ function walkSessionFilesUncached(dir, out = new Map()) {
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            walkSessionFilesUncached(fullPath, out);
+            walkThreadFilesUncached(fullPath, out);
             continue;
         }
         if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
@@ -676,40 +775,54 @@ function walkSessionFilesUncached(dir, out = new Map()) {
     }
     return out;
 }
-function walkSessionFiles(dir) {
+function walkThreadFiles(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,
+    const cached = mirroredThreadFileIndexCache.get(dir);
+    if (cached && now - cached.indexedAt <= MIRRORED_THREAD_SESSION_FILE_INDEX_TTL_MS) {
+        return new Map(cached.files);
+    }
+    const files = walkThreadFilesUncached(dir);
+    mirroredThreadFileIndexCache.set(dir, {
         indexedAt: now,
         files: new Map(files),
-    };
+    });
     return files;
 }
+function codexThreadFiles() {
+    const agentHome = localAgentHome();
+    return new Map([
+        ...walkThreadFiles(path.join(agentHome, 'threads')),
+        ...walkThreadFiles(path.join(agentHome, 'sessions')),
+    ]);
+}
 function readFileHead(filePath, maxBytes = 64 * 1024) {
+    const stat = fs.statSync(filePath);
+    const cacheKey = jsonlCacheKey(['head', filePath, maxBytes]);
+    const cached = getCachedFileText(cacheKey, stat);
+    if (cached !== null)
+        return cached;
     const fd = fs.openSync(filePath, 'r');
     try {
         const buffer = Buffer.alloc(maxBytes);
         const bytesRead = fs.readSync(fd, buffer, 0, maxBytes, 0);
-        return buffer.subarray(0, bytesRead).toString('utf-8');
+        return setCachedFileText(cacheKey, stat, buffer.subarray(0, bytesRead).toString('utf-8'));
     }
     finally {
         fs.closeSync(fd);
     }
 }
 function readFileTail(filePath, maxBytes = 256 * 1024) {
+    const stat = fs.statSync(filePath);
+    const cacheKey = jsonlCacheKey(['tail', filePath, maxBytes]);
+    const cached = getCachedFileText(cacheKey, stat);
+    if (cached !== null)
+        return cached;
     const fd = fs.openSync(filePath, 'r');
     try {
-        const stat = fs.fstatSync(fd);
         const length = Math.min(maxBytes, stat.size);
         const buffer = Buffer.alloc(length);
         fs.readSync(fd, buffer, 0, length, Math.max(0, stat.size - length));
-        return buffer.toString('utf-8');
+        return setCachedFileText(cacheKey, stat, buffer.toString('utf-8'));
     }
     finally {
         fs.closeSync(fd);
@@ -752,7 +865,7 @@ function readThreadWorkspacePath(filePath) {
             if (!line.trim())
                 continue;
             const parsed = parseJsonLine(line);
-            if (parsed?.type !== 'session_meta')
+            if (parsed?.type !== 'thread_meta' && parsed?.type !== 'session_meta')
                 continue;
             const payload = parsed.payload && typeof parsed.payload === 'object'
                 ? parsed.payload
@@ -1009,7 +1122,7 @@ function readMirroredThreadStatus(threadId, filePath) {
             return 'running';
     }
     catch {
-        // Fall back to the Codex session file status below.
+        // Fall back to the Codex thread file status below.
     }
     return readThreadStatus(filePath);
 }
@@ -1106,18 +1219,19 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
     const safeLimit = Math.max(1, Math.min(limit, 200));
     const stateEntries = readThreadStateEntries(safeLimit);
     const indexEntries = readThreadIndex(safeLimit);
-    const sessionFiles = walkSessionFiles(path.join(localAgentHome(), 'sessions'));
+    const indexEntriesById = new Map(indexEntries.map((entry) => [entry.id, entry]));
+    const threadFiles = codexThreadFiles();
     const projects = new Map();
     if (stateEntries.length > 0) {
         for (const entry of stateEntries) {
-            const sessionPath = sessionFiles.get(entry.id) || null;
-            if (!sessionPath)
+            const threadPath = threadFiles.get(entry.id) || null;
+            if (!threadPath)
                 continue;
-            const workspacePath = entry.cwd || readThreadWorkspacePath(sessionPath);
+            const workspacePath = entry.cwd || readThreadWorkspacePath(threadPath);
             if (!isMirrorableCodexWorkspace(workspacePath))
                 continue;
             const projectId = workspacePath || 'no-workspace';
-            const indexEntry = readThreadIndexEntry(entry.id);
+            const indexEntry = indexEntriesById.get(entry.id) || null;
             const title = indexEntry?.thread_name || entry.title;
             if (isAutomationRunThreadTitle(title))
                 continue;
@@ -1131,8 +1245,8 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
                 id: entry.id,
                 title,
                 updated_at: entry.updated_at,
-                status: readMirroredThreadStatus(entry.id, sessionPath),
-                session_path: sessionPath,
+                status: readMirroredThreadStatus(entry.id, threadPath),
+                thread_path: threadPath,
             });
             projects.set(projectId, project);
         }
@@ -1145,8 +1259,8 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
         };
     }
     for (const entry of indexEntries) {
-        const sessionPath = sessionFiles.get(entry.id) || null;
-        const workspacePath = readThreadWorkspacePath(sessionPath);
+        const threadPath = threadFiles.get(entry.id) || null;
+        const workspacePath = readThreadWorkspacePath(threadPath);
         if (!isMirrorableCodexWorkspace(workspacePath))
             continue;
         if (isAutomationRunThreadTitle(entry.thread_name))
@@ -1162,8 +1276,8 @@ function readMirroredTaskProjects(limit = MIRRORED_THREAD_LIMIT) {
             id: entry.id,
             title: entry.thread_name,
             updated_at: entry.updated_at,
-            status: readMirroredThreadStatus(entry.id, sessionPath),
-            session_path: sessionPath,
+            status: readMirroredThreadStatus(entry.id, threadPath),
+            thread_path: threadPath,
         });
         projects.set(projectId, project);
     }
@@ -1298,10 +1412,10 @@ function isMirroredGoalContextMessage(text) {
     const trimmed = text.trim();
     return trimmed.startsWith('<goal_context>') && trimmed.endsWith('</goal_context>');
 }
-function mirroredThreadWorkspacePath(sessionPath, stateEntry) {
+function mirroredThreadWorkspacePath(threadPath, stateEntry) {
     const stateCwd = typeof stateEntry?.cwd === 'string' ? stateEntry.cwd : null;
-    const sessionWorkspace = readThreadWorkspacePath(sessionPath);
-    for (const candidate of [stateCwd, sessionWorkspace]) {
+    const threadWorkspace = readThreadWorkspacePath(threadPath);
+    for (const candidate of [stateCwd, threadWorkspace]) {
         if (candidate && isMirrorableCodexWorkspace(candidate))
             return candidate;
     }
@@ -1356,16 +1470,16 @@ function collapseCompletedAssistantProgressMessages(input) {
 }
 export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY_LIMIT, options = {}) {
     const safeLimit = Math.max(1, Math.min(limit, 1000));
-    const sessionPath = walkSessionFiles(path.join(localAgentHome(), 'sessions')).get(threadId);
-    if (!sessionPath)
+    const threadPath = codexThreadFiles().get(threadId);
+    if (!threadPath)
         return null;
     const eventLogThreadId = options.eventLogThreadId || threadId;
     const stateEntry = readThreadStateEntry(threadId);
-    const workspacePath = mirroredThreadWorkspacePath(sessionPath, stateEntry);
+    const workspacePath = mirroredThreadWorkspacePath(threadPath, stateEntry);
     const indexEntry = readThreadIndexEntry(threadId);
     const eventLogHead = readThreadEventLogHead(eventLogThreadId);
     const historyLineTarget = Math.min(250, Math.max(3, Math.ceil(safeLimit / 4)));
-    const lines = readRecentCodexHistoryLines(sessionPath, historyLineTarget);
+    const lines = readRecentCodexHistoryLines(threadPath, historyLineTarget);
     const messages = [];
     const events = [];
     let messageIndex = 0;
@@ -1573,7 +1687,7 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
     const collapsedMessages = collapseCompletedAssistantProgressMessages(messages);
     const slicedMessages = collapsedMessages.slice(-safeLimit);
     const slicedEvents = events.slice(-safeLimit * 8);
-    const status = readMirroredThreadStatus(eventLogThreadId, sessionPath);
+    const status = readMirroredThreadStatus(eventLogThreadId, threadPath);
     const latestGoalContext = recentGoalContext;
     const context = readThreadContext({
         threadId,
@@ -1581,7 +1695,7 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
         workspace: workspacePath,
     });
     return {
-        session: {
+        thread: {
             task_id: threadId,
             agent_id: 'codex',
             channel: 'local-agent',
@@ -1611,19 +1725,19 @@ export function readCodexThreadHistory(threadId, limit = MIRRORED_THREAD_HISTORY
         ...(latestGoalContext ? { goal_context: latestGoalContext } : {}),
     };
 }
-function serializeAdoptedMirroredThread(session) {
+function serializeAdoptedMirroredThread(thread) {
     return {
-        id: session.session_id,
-        taskId: session.session_id,
-        agentId: session.agent_id,
-        status: session.status || 'idle',
-        title: session.title,
-        createdAt: session.created_at,
-        updatedAt: session.updated_at,
+        id: thread.thread_id,
+        taskId: thread.thread_id,
+        agentId: thread.agent_id,
+        status: thread.status || 'idle',
+        title: thread.title,
+        createdAt: thread.created_at,
+        updatedAt: thread.updated_at,
         supen: {
-            channel: session.channel,
-            sourceRef: session.source_ref,
-            taskWorkspaceFolder: session.task_workspace_folder,
+            channel: thread.channel,
+            sourceRef: thread.source_ref,
+            taskWorkspaceFolder: thread.task_workspace_folder,
         },
     };
 }
@@ -1631,23 +1745,23 @@ function adoptMirroredThread(threadId, agentId) {
     const history = readCodexThreadHistory(threadId, 1);
     if (!history)
         return null;
-    const historySession = history.session;
-    const session = ensureSession({
+    const historyThread = history.thread;
+    const thread = ensureThread({
         agent_id: agentId,
-        session_id: threadId,
+        thread_id: threadId,
         channel: 'http',
         agent_name: agentId,
         source_ref: `local-agent:${threadId}`,
-        title: typeof historySession.title === 'string' ? historySession.title : undefined,
-        status: historySession.status === 'running' ? 'running' : 'idle',
+        title: typeof historyThread.title === 'string' ? historyThread.title : undefined,
+        status: historyThread.status === 'running' ? 'running' : 'idle',
         backend_driver_id: 'codex-app-server',
-        task_workspace_folder: typeof historySession.task_workspace_folder === 'string'
-            ? historySession.task_workspace_folder
+        task_workspace_folder: typeof historyThread.task_workspace_folder === 'string'
+            ? historyThread.task_workspace_folder
             : null,
     });
-    updateSessionSdkId(agentId, threadId, threadId);
-    updateSessionBackendDriverId(agentId, threadId, 'codex-app-server');
-    return session;
+    updateThreadSdkSessionId(agentId, threadId, threadId);
+    updateThreadBackendDriverId(agentId, threadId, 'codex-app-server');
+    return thread;
 }
 function coerceSingleQueryParam(value) {
     if (Array.isArray(value))
@@ -1670,24 +1784,24 @@ function collectSpaceLogEntries(filters = {}) {
     const agents = getAllAgents()
         // Single-Computer runtime: include all agents in this mounted volume.
         .sort((a, b) => (a.name || a.agent_id).localeCompare(b.name || b.agent_id));
-    const sessions = agents.flatMap((agent) => getSessionsForAgent(agent.agent_id)
-        .map((session) => ({
+    const threads = agents.flatMap((agent) => getThreadsForAgent(agent.agent_id)
+        .map((thread) => ({
         agent_id: agent.agent_id,
         agent_name: agent.name || null,
-        session_id: session.session_id,
-        status: session.status,
-        updated_at: session.updated_at,
-        title: session.title || null,
+        thread_id: thread.thread_id,
+        status: thread.status,
+        updated_at: thread.updated_at,
+        title: thread.title || null,
     })));
-    const filteredSessions = sessions.filter((session) => {
-        if (filters.agentId && session.agent_id !== filters.agentId)
+    const filteredThreads = threads.filter((thread) => {
+        if (filters.agentId && thread.agent_id !== filters.agentId)
             return false;
-        if (filters.sessionId && session.session_id !== filters.sessionId)
+        if (filters.threadId && thread.thread_id !== filters.threadId)
             return false;
         return true;
     });
-    const entries = filteredSessions
-        .flatMap((session) => getSessionUiEvents(session.agent_id, session.session_id, limit).map((event) => {
+    const entries = filteredThreads
+        .flatMap((thread) => getThreadUiEvents(thread.agent_id, thread.thread_id, limit).map((event) => {
         const logSummary = event.chunk && typeof event.chunk === 'object'
             ? summarizeUiChunk(event.chunk)
             : null;
@@ -1695,10 +1809,10 @@ function collectSpaceLogEntries(filters = {}) {
             ? {
                 id: event.id,
                 timestamp: event.timestamp,
-                agent_id: session.agent_id,
-                agent_name: session.agent_name,
-                session_id: session.session_id,
-                session_title: session.title,
+                agent_id: thread.agent_id,
+                agent_name: thread.agent_name,
+                thread_id: thread.thread_id,
+                thread_title: thread.title,
                 task_id: event.task_id || null,
                 category: logSummary.category,
                 summary: logSummary.summary,
@@ -1713,11 +1827,11 @@ function collectSpaceLogEntries(filters = {}) {
         generated_at: new Date().toISOString(),
         timezone: resolveHostTimeZone(),
         agents,
-        sessions,
+        threads,
         entries,
         filters: {
             agent_id: filters.agentId || null,
-            session_id: filters.sessionId || null,
+            thread_id: filters.threadId || null,
         },
     };
 }
@@ -2581,24 +2695,24 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
     }
     if (pathname === '/api/computers/{computer_id}/logs' && method === 'GET') {
         const agentId = coerceSingleQueryParam(url.searchParams.get('agent_id'));
-        const sessionId = coerceSingleQueryParam(url.searchParams.get('session_id'));
+        const threadId = coerceSingleQueryParam(url.searchParams.get('thread_id'));
         const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
         const limit = limitRaw ? Number.parseInt(limitRaw, 10) : SPACE_LOG_EVENT_LIMIT;
         writeJson(res, 200, collectSpaceLogEntries({
             agentId: agentId?.trim() || null,
-            sessionId: sessionId?.trim() || null,
+            threadId: threadId?.trim() || null,
             limit: Number.isFinite(limit) ? limit : SPACE_LOG_EVENT_LIMIT,
         }));
         return true;
     }
     if (pathname === '/api/computers/{computer_id}/logs/stream' && method === 'GET') {
         const agentId = coerceSingleQueryParam(url.searchParams.get('agent_id'));
-        const sessionId = coerceSingleQueryParam(url.searchParams.get('session_id'));
+        const threadId = coerceSingleQueryParam(url.searchParams.get('thread_id'));
         const limitRaw = coerceSingleQueryParam(url.searchParams.get('limit'));
         const limit = limitRaw ? Number.parseInt(limitRaw, 10) : SPACE_LOG_EVENT_LIMIT;
         const filters = {
             agentId: agentId?.trim() || null,
-            sessionId: sessionId?.trim() || null,
+            threadId: threadId?.trim() || null,
             limit: Number.isFinite(limit) ? limit : SPACE_LOG_EVENT_LIMIT,
         };
         res.writeHead(200, {
@@ -2881,7 +2995,7 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
         });
         return true;
     }
-    if (pathname === '/api/computers/{computer_id}/agents/codex/session' && method === 'DELETE') {
+    if (pathname === '/api/computers/{computer_id}/agents/codex/thread' && method === 'DELETE') {
         const cmd = spawnSync('codex', ['logout'], {
             encoding: 'utf8',
             timeout: 15_000,
@@ -2976,10 +3090,10 @@ 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;
+        const threadPath = codexThreadFiles().get(threadId);
+        let jsonlOffset = threadPath && fs.existsSync(threadPath) ? fs.statSync(threadPath).size : 0;
         let jsonlEventIndex = 0;
-        const workspacePath = readThreadWorkspacePath(sessionPath) || process.cwd();
+        const workspacePath = readThreadWorkspacePath(threadPath) || process.cwd();
         const withThreadContext = (chunk) => attachThreadContextToChunk(chunk, readThreadContext({ threadId, workspace: workspacePath }));
         const stopCodexObserver = process.env.NODE_ENV === 'test'
             ? () => { }
@@ -2993,9 +3107,9 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
             res.flush?.();
         }, SPACE_LOG_STREAM_PING_MS);
         pingTimer.unref?.();
-        const jsonlPollTimer = sessionPath
+        const jsonlPollTimer = threadPath
             ? setInterval(() => {
-                const read = readAppendedJsonlLines(sessionPath, jsonlOffset);
+                const read = readAppendedJsonlLines(threadPath, jsonlOffset);
                 jsonlOffset = read.offset;
                 for (const line of read.lines) {
                     if (!isCodexHistoryTranscriptLine(line))
@@ -3062,12 +3176,12 @@ export async function handleSystemRoutes(req, res, url, pathname, method) {
             : '';
         const fallbackAgentId = getAllAgents()[0]?.agent_id || 'codex';
         const agentId = requestedAgentId || fallbackAgentId;
-        const session = threadId ? adoptMirroredThread(threadId, agentId) : null;
-        if (!session) {
+        const thread = threadId ? adoptMirroredThread(threadId, agentId) : null;
+        if (!thread) {
             writeProtocolError(res, 404, 'not_found', 'mirrored_thread_not_found', 'Mirrored task history was not found.');
             return true;
         }
-        writeJson(res, 200, { thread: serializeAdoptedMirroredThread(session) });
+        writeJson(res, 200, { thread: serializeAdoptedMirroredThread(thread) });
         return true;
     }
     if (codexProjectsOpenRoute(pathname) && method === 'POST') {