@supen-ai/cli 1.4.0 → 1.4.2

package/daemon/dist/http/routes/threads.d.ts

@@ -0,0 +1,11 @@
+import http from 'http';
+import { URL } from 'url';
+import { type HttpAdminContext } from '../context.js';
+import type { OnThreadStop } from '../../core/types.js';
+export declare function captureWebUserMessage(input: {
+    threadId: string;
+    runtimeThreadId?: string | null;
+    userMessage: unknown;
+}): void;
+export declare function handleThreadsRoutes(req: http.IncomingMessage, res: http.ServerResponse, url: URL, pathname: string, method: string, adminContext: HttpAdminContext | null, onMessage: (chatJid: string, msg: any) => void, onThreadStop?: OnThreadStop): Promise<boolean>;
+//# sourceMappingURL=threads.d.ts.map

package/daemon/dist/http/routes/threads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads.d.ts","sourceRoot":"","sources":["../../../src/http/routes/threads.ts"],"names":[],"mappings":"AAEA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AA6B1B,OAAO,EAA4B,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMhF,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,qBAAqB,CAAC;AAUtE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,OAAO,CAAC;CACtB,GAAG,IAAI,CAmBP;AA4SD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,gBAAgB,GAAG,IAAI,EACrC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,IAAI,EAC9C,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,OAAO,CAAC,CAuhBlB"}

package/daemon/dist/http/routes/{sessions.js → threads.js}

@@ -2,15 +2,15 @@ import fs from 'fs';
 import path from 'path';
 import { randomUUID } from 'crypto';
 import { logger } from '../../core/logger.js';
-import { ensureSession, getSessionForAgent, getSessionInteractionEvents, getSessionsForAgent, getArchivedSessionsForAgent, getAutomationRunById, getAutomationById, getAutomationState, listAutomationRuns, finalizeRunningAutomationRunForSession, finalizeAutomationRun, clearSessionSdkId, deleteSessionForAgent, archiveSessionForAgent, restoreSessionForAgent, updateAutomationState, updateSessionMetadata, updateSessionStatus, storeMessage, } from '../../core/store.js';
+import { ensureThread, getThreadForAgent, getThreadInteractionEvents, getThreadsForAgent, getArchivedThreadsForAgent, getAutomationRunById, getAutomationById, getAutomationState, listAutomationRuns, finalizeRunningAutomationRunForThread, finalizeAutomationRun, clearThreadSdkSessionId, deleteThreadForAgent, archiveThreadForAgent, restoreThreadForAgent, updateAutomationState, updateThreadMetadata, updateThreadStatus, storeMessage, } from '../../core/store.js';
 import { ASSISTANT_NAME, SUPEN_HOME } from '../../core/config.js';
 import { writeJson, writeProtocolError, readJsonBody } from '../response.js';
-import { broadcastToChat, buildHttpSessionId } from '../stream.js';
+import { broadcastToChat, buildHttpThreadId } from '../stream.js';
 import { deriveHttpSenderIdentity } from '../context.js';
-import { readCodexThreadTitleFromStateDb, readCodexThreadTitleFromSessionIndex, } from '../thread-title.js';
+import { readCodexThreadTitleFromStateDb, readCodexThreadTitleFromThreadIndex, } from '../thread-title.js';
 import { listWebCommands, resolveWebCommandInput } from '../command-catalog.js';
 import { AgentCortex } from '../../core/cortex.js';
-import { recordSessionControlCommand } from '../../core/control-commands.js';
+import { recordThreadControlCommand } from '../../core/control-commands.js';
 import { listControlLogEntries } from '../../core/control-log.js';
 import { appendThreadEvent } from '../../core/thread-event-log.js';
 import { projectThreadRuntimeState } from '../../core/thread-runtime-state.js';
@@ -34,11 +34,11 @@ export function captureWebUserMessage(input) {
         }, 'Failed to capture web user message');
     }
 }
-function serializeTask(session) {
-    const { session_id: sessionId, ...rest } = session;
+function serializeTask(thread) {
+    const { thread_id: threadId, ...rest } = thread;
     return {
         ...rest,
-        task_id: sessionId,
+        task_id: threadId,
     };
 }
 function isNoOpAutomationRun(runId) {
@@ -125,7 +125,7 @@ function runtimeThreadIdCandidatesForThread(threadId) {
 }
 function readCodexTitleForThread(threadId) {
     for (const candidate of runtimeThreadIdCandidatesForThread(threadId)) {
-        const title = readCodexThreadTitleFromSessionIndex(candidate) ||
+        const title = readCodexThreadTitleFromThreadIndex(candidate) ||
             readCodexThreadTitleFromStateDb(candidate);
         if (title)
             return title;
@@ -142,19 +142,19 @@ function shouldReplaceTitle(input) {
     return false;
 }
 function refreshThreadTitleFromCodexIndex(agentId, threadId, options = {}) {
-    const session = getSessionForAgent(agentId, threadId);
-    if (!session)
+    const thread = getThreadForAgent(agentId, threadId);
+    if (!thread)
         return { updated: false, title: null, previousTitle: null, reason: 'thread_not_found' };
     const title = readCodexTitleForThread(threadId);
     if (!title) {
         return {
             updated: false,
             title: null,
-            previousTitle: session.title || null,
+            previousTitle: thread.title || null,
             reason: 'codex_title_not_found',
         };
     }
-    const previousTitle = session.title?.trim() || '';
+    const previousTitle = thread.title?.trim() || '';
     if (!shouldReplaceTitle({
         currentTitle: previousTitle,
         nextTitle: title,
@@ -167,10 +167,10 @@ function refreshThreadTitleFromCodexIndex(agentId, threadId, options = {}) {
             reason: 'title_preserved',
         };
     }
-    updateSessionMetadata(agentId, threadId, { title });
-    broadcastToChat(buildHttpSessionId(agentId, threadId), {
-        type: 'session_updated',
-        session: { task_id: threadId, title },
+    updateThreadMetadata(agentId, threadId, { title });
+    broadcastToChat(buildHttpThreadId(agentId, threadId), {
+        type: 'thread_updated',
+        thread: { task_id: threadId, title },
     });
     return {
         updated: true,
@@ -186,10 +186,10 @@ function runtimeStateSummary(projection) {
         runtime: projection.runtime,
     };
 }
-function prewarmSessionInBackground(agentId, sessionId, options) {
+function prewarmThreadInBackground(agentId, threadId, options) {
     const key = [
         agentId,
-        sessionId,
+        threadId,
         options?.model || '',
         options?.permissionMode || '',
         options?.networkAccess ? 'network' : '',
@@ -200,8 +200,8 @@ function prewarmSessionInBackground(agentId, sessionId, options) {
         return;
     }
     recentPrewarmAttempts.set(key, now);
-    const cortex = new AgentCortex(agentId, sessionId);
-    void cortex.prewarmNativeSession(options);
+    const cortex = new AgentCortex(agentId, threadId);
+    void cortex.prewarmNativeThread(options);
 }
 function readRuntimeOptions(body) {
     const model = typeof body?.model === 'string' && body.model.trim()
@@ -235,8 +235,8 @@ function readRuntimeOptions(body) {
         ...(networkAccess ? { networkAccess } : {}),
     };
 }
-function resetAutomationRuntimeForSession(sessionId) {
-    const automationMatch = sessionId.match(/^sched-(.+)$/);
+function resetAutomationRuntimeForThread(threadId) {
+    const automationMatch = threadId.match(/^sched-(.+)$/);
     if (!automationMatch)
         return null;
     const automationId = automationMatch[1];
@@ -280,8 +280,8 @@ function resetAutomationRuntimeForSession(sessionId) {
     });
     return { automation_id: automationId, status: 'reset_state' };
 }
-export async function handleSessionsRoutes(req, res, url, pathname, method, adminContext, onMessage, onSessionStop) {
-    const commandsV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/commands$/);
+export async function handleThreadsRoutes(req, res, url, pathname, method, adminContext, onMessage, onThreadStop) {
+    const commandsV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/commands$/);
     if (commandsV1Match && method === 'GET') {
         const agentId = decodeURIComponent(commandsV1Match[1]);
         const commands = await listWebCommands({ channel: 'web', agentId });
@@ -295,7 +295,7 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         writeJson(res, 200, { commands });
         return true;
     }
-    const resolveCommandsV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/commands\/resolve$/);
+    const resolveCommandsV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/commands\/resolve$/);
     if (resolveCommandsV1Match && method === 'POST') {
         const agentId = decodeURIComponent(resolveCommandsV1Match[1]);
         const parsed = await readJsonBody(req);
@@ -309,31 +309,31 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         writeJson(res, 200, resolved);
         return true;
     }
-    const stopV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/stop$/);
+    const stopV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/stop$/);
     if (stopV1Match && method === 'POST') {
         const agentId = decodeURIComponent(stopV1Match[1]);
-        const sessionId = decodeURIComponent(stopV1Match[2]);
-        if (!onSessionStop) {
-            writeProtocolError(res, 501, 'input_error', 'stop_not_supported', 'Session stop is not supported by this daemon.');
+        const threadId = decodeURIComponent(stopV1Match[2]);
+        if (!onThreadStop) {
+            writeProtocolError(res, 501, 'input_error', 'stop_not_supported', 'Thread stop is not supported by this daemon.');
             return true;
         }
         const actor = adminContext?.actor || 'http';
-        recordSessionControlCommand({
+        recordThreadControlCommand({
             agentId,
-            sessionId,
+            threadId,
             surface: 'web',
-            commandType: 'session.stop',
+            commandType: 'thread.stop',
             method: 'turn/interrupt',
             actor,
             status: 'received',
             payload: { endpoint: 'stop' },
         });
-        const result = onSessionStop(agentId, sessionId, actor);
-        if (!result.ok && result.code !== 'session_not_running') {
+        const result = onThreadStop(agentId, threadId, actor);
+        if (!result.ok && result.code !== 'thread_not_running') {
             writeProtocolError(res, 404, 'input_error', result.code, result.message);
             return true;
         }
-        const finalizedAutomationRun = finalizeRunningAutomationRunForSession(agentId, sessionId, {
+        const finalizedAutomationRun = finalizeRunningAutomationRunForThread(agentId, threadId, {
             actor,
         });
         const automationReset = finalizedAutomationRun
@@ -342,15 +342,15 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
                 status: 'finalized_run',
                 run_id: finalizedAutomationRun.run_id,
             }
-            : resetAutomationRuntimeForSession(sessionId);
+            : resetAutomationRuntimeForThread(threadId);
         const automationRuntimeReleased = automationReset?.status === 'finalized_run' || automationReset?.status === 'reset_state';
         if (automationRuntimeReleased) {
-            updateSessionStatus(agentId, sessionId, 'idle');
-            const refreshedSession = getSessionForAgent(agentId, sessionId);
-            if (refreshedSession) {
-                broadcastToChat(buildHttpSessionId(agentId, sessionId), {
-                    type: 'session_updated',
-                    session: refreshedSession,
+            updateThreadStatus(agentId, threadId, 'idle');
+            const refreshedThread = getThreadForAgent(agentId, threadId);
+            if (refreshedThread) {
+                broadcastToChat(buildHttpThreadId(agentId, threadId), {
+                    type: 'thread_updated',
+                    thread: refreshedThread,
                 });
             }
         }
@@ -361,114 +361,114 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         });
         return true;
     }
-    const resetRuntimeV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/reset-runtime$/);
+    const resetRuntimeV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/reset-runtime$/);
     if (resetRuntimeV1Match && method === 'POST') {
         const agentId = decodeURIComponent(resetRuntimeV1Match[1]);
-        const sessionId = decodeURIComponent(resetRuntimeV1Match[2]);
-        const session = getSessionForAgent(agentId, sessionId);
-        if (!session) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+        const threadId = decodeURIComponent(resetRuntimeV1Match[2]);
+        const thread = getThreadForAgent(agentId, threadId);
+        if (!thread) {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
-        const clearedSdkSessionId = Boolean(session.sdk_session_id);
-        clearSessionSdkId(agentId, sessionId);
-        updateSessionStatus(agentId, sessionId, 'idle');
-        const automationReset = resetAutomationRuntimeForSession(sessionId);
-        const refreshedSession = getSessionForAgent(agentId, sessionId) || {
-            ...session,
+        const clearedSdkSessionId = Boolean(thread.sdk_session_id);
+        clearThreadSdkSessionId(agentId, threadId);
+        updateThreadStatus(agentId, threadId, 'idle');
+        const automationReset = resetAutomationRuntimeForThread(threadId);
+        const refreshedThread = getThreadForAgent(agentId, threadId) || {
+            ...thread,
             status: 'idle',
         };
-        broadcastToChat(buildHttpSessionId(agentId, sessionId), {
-            type: 'session_updated',
-            session: serializeTask(refreshedSession),
+        broadcastToChat(buildHttpThreadId(agentId, threadId), {
+            type: 'thread_updated',
+            thread: serializeTask(refreshedThread),
         });
         writeJson(res, 200, {
             ok: true,
-            session: serializeTask(refreshedSession),
+            thread: serializeTask(refreshedThread),
             cleared_sdk_session_id: clearedSdkSessionId,
             automation_reset: automationReset,
         });
         return true;
     }
-    const prewarmV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/prewarm$/);
+    const prewarmV1Match = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/prewarm$/);
     if (prewarmV1Match && method === 'POST') {
         const agentId = decodeURIComponent(prewarmV1Match[1]);
-        const sessionId = decodeURIComponent(prewarmV1Match[2]);
-        const session = getSessionForAgent(agentId, sessionId);
-        if (!session) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+        const threadId = decodeURIComponent(prewarmV1Match[2]);
+        const thread = getThreadForAgent(agentId, threadId);
+        if (!thread) {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
         const parsed = await readJsonBody(req).catch(() => ({}));
         const runtimeOptions = readRuntimeOptions(parsed);
-        prewarmSessionInBackground(agentId, sessionId, runtimeOptions);
-        writeJson(res, 202, { ok: true, task_id: sessionId, prewarming: true });
+        prewarmThreadInBackground(agentId, threadId, runtimeOptions);
+        writeJson(res, 202, { ok: true, task_id: threadId, prewarming: true });
         return true;
     }
-    // ── List Sessions ──
-    const listSessionsMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions$/);
-    if (listSessionsMatch && method === 'POST') {
-        const agentId = decodeURIComponent(listSessionsMatch[1]);
+    // ── List Threads ──
+    const listThreadsMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads$/);
+    if (listThreadsMatch && method === 'POST') {
+        const agentId = decodeURIComponent(listThreadsMatch[1]);
         const parsed = await readJsonBody(req);
-        const requestedSessionId = typeof parsed?.task_id === 'string'
+        const requestedThreadId = typeof parsed?.task_id === 'string'
             ? parsed.task_id.trim()
-            : typeof parsed?.session_id === 'string'
-                ? parsed.session_id.trim()
+            : typeof parsed?.thread_id === 'string'
+                ? parsed.thread_id.trim()
                 : '';
         const requestedTitle = typeof parsed?.title === 'string' ? parsed.title.trim() : '';
         const requestedKnowledgeId = typeof parsed?.knowledge_id === 'string' ? parsed.knowledge_id.trim() : '';
         const requestedKnowledgeName = typeof parsed?.knowledge_name === 'string' ? parsed.knowledge_name.trim() : '';
-        if (requestedSessionId && getSessionForAgent(agentId, requestedSessionId)) {
-            writeProtocolError(res, 409, 'input_error', 'session_exists', `Task "${requestedSessionId}" already exists for agent "${agentId}"`);
+        if (requestedThreadId && getThreadForAgent(agentId, requestedThreadId)) {
+            writeProtocolError(res, 409, 'input_error', 'thread_exists', `Task "${requestedThreadId}" already exists for agent "${agentId}"`);
             return true;
         }
-        let sessionId = requestedSessionId;
-        if (!sessionId) {
+        let threadId = requestedThreadId;
+        if (!threadId) {
             do {
-                sessionId = `session-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
-            } while (getSessionForAgent(agentId, sessionId));
+                threadId = `thread-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+            } while (getThreadForAgent(agentId, threadId));
         }
-        const session = ensureSession({
+        const thread = ensureThread({
             agent_id: agentId,
-            session_id: sessionId,
+            thread_id: threadId,
             channel: 'http',
             agent_name: agentId,
-            source_ref: buildHttpSessionId(agentId, sessionId),
+            source_ref: buildHttpThreadId(agentId, threadId),
             knowledge_id: requestedKnowledgeId || undefined,
             knowledge_name: requestedKnowledgeName || undefined,
             title: requestedTitle || undefined,
         });
-        recordSessionControlCommand({
+        recordThreadControlCommand({
             agentId,
-            sessionId,
+            threadId,
             surface: 'web',
-            commandType: 'session.start',
+            commandType: 'thread.start',
             method: 'thread/start',
             actor: adminContext?.actor || 'http',
             status: 'completed',
             payload: {
-                requested_task_id: requestedSessionId || null,
+                requested_task_id: requestedThreadId || null,
                 title: requestedTitle || null,
                 knowledge_id: requestedKnowledgeId || null,
                 knowledge_name: requestedKnowledgeName || null,
             },
         });
-        const refreshedSession = getSessionForAgent(agentId, sessionId) || session;
-        prewarmSessionInBackground(agentId, sessionId);
-        writeJson(res, 200, { session: serializeTask(refreshedSession) });
+        const refreshedThread = getThreadForAgent(agentId, threadId) || thread;
+        prewarmThreadInBackground(agentId, threadId);
+        writeJson(res, 200, { thread: serializeTask(refreshedThread) });
         return true;
     }
-    if (listSessionsMatch && method === 'GET') {
-        const agentId = decodeURIComponent(listSessionsMatch[1]);
-        const sessions = getSessionsForAgent(agentId).map(serializeTask);
-        writeJson(res, 200, { sessions });
+    if (listThreadsMatch && method === 'GET') {
+        const agentId = decodeURIComponent(listThreadsMatch[1]);
+        const threads = getThreadsForAgent(agentId).map(serializeTask);
+        writeJson(res, 200, { threads });
         return true;
     }
-    const archivedSessionsMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/archived_sessions$/);
-    if (archivedSessionsMatch && method === 'GET') {
-        const agentId = decodeURIComponent(archivedSessionsMatch[1]);
-        const sessions = getArchivedSessionsForAgent(agentId).map(serializeTask);
-        writeJson(res, 200, { sessions });
+    const archivedThreadsMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/archived_threads$/);
+    if (archivedThreadsMatch && method === 'GET') {
+        const agentId = decodeURIComponent(archivedThreadsMatch[1]);
+        const threads = getArchivedThreadsForAgent(agentId).map(serializeTask);
+        writeJson(res, 200, { threads });
         return true;
     }
     const refreshTitlesMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/refresh-titles$/);
@@ -476,11 +476,11 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         const agentId = decodeURIComponent(refreshTitlesMatch[1]);
         const parsed = await readJsonBody(req).catch(() => ({}));
         const force = parsed?.force === true;
-        const sessions = getSessionsForAgent(agentId);
-        const results = sessions.map((session) => {
-            const result = refreshThreadTitleFromCodexIndex(agentId, session.session_id, { force });
+        const threads = getThreadsForAgent(agentId);
+        const results = threads.map((thread) => {
+            const result = refreshThreadTitleFromCodexIndex(agentId, thread.thread_id, { force });
             return {
-                thread_id: session.session_id,
+                thread_id: thread.thread_id,
                 updated: result.updated,
                 title: result.title,
                 previous_title: result.previousTitle,
@@ -518,94 +518,94 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         });
         return true;
     }
-    const sessionLifecycleMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)$/);
-    if (sessionLifecycleMatch && method === 'PATCH') {
-        const agentId = decodeURIComponent(sessionLifecycleMatch[1]);
-        const sessionId = decodeURIComponent(sessionLifecycleMatch[2]);
+    const threadLifecycleMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)$/);
+    if (threadLifecycleMatch && method === 'PATCH') {
+        const agentId = decodeURIComponent(threadLifecycleMatch[1]);
+        const threadId = decodeURIComponent(threadLifecycleMatch[2]);
         const parsed = await readJsonBody(req);
         if (parsed?.archived === true) {
-            const archived = archiveSessionForAgent(agentId, sessionId);
+            const archived = archiveThreadForAgent(agentId, threadId);
             if (!archived) {
-                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+                writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
                 return true;
             }
             writeJson(res, 200, { ok: true, archived: true });
             return true;
         }
         if (parsed?.archived === false) {
-            const restored = restoreSessionForAgent(agentId, sessionId);
+            const restored = restoreThreadForAgent(agentId, threadId);
             if (!restored) {
-                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Archived task "${sessionId}" was not found for agent "${agentId}"`);
+                writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Archived task "${threadId}" was not found for agent "${agentId}"`);
                 return true;
             }
             writeJson(res, 200, {
                 ok: true,
                 archived: false,
-                session: serializeTask(getSessionForAgent(agentId, sessionId)),
+                thread: serializeTask(getThreadForAgent(agentId, threadId)),
             });
             return true;
         }
         if (typeof parsed?.title === 'string') {
-            const updated = updateSessionMetadata(agentId, sessionId, {
+            const updated = updateThreadMetadata(agentId, threadId, {
                 title: parsed.title.trim() || undefined,
             });
             if (!updated) {
-                writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+                writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
                 return true;
             }
-            const session = getSessionForAgent(agentId, sessionId);
-            writeJson(res, 200, { ok: true, session: session ? serializeTask(session) : null });
+            const thread = getThreadForAgent(agentId, threadId);
+            writeJson(res, 200, { ok: true, thread: thread ? serializeTask(thread) : null });
             return true;
         }
-        writeProtocolError(res, 400, 'input_error', 'invalid_session_update', 'Expected archived or title in request body.');
+        writeProtocolError(res, 400, 'input_error', 'invalid_thread_update', 'Expected archived or title in request body.');
         return true;
     }
-    if (sessionLifecycleMatch && method === 'DELETE') {
-        const agentId = decodeURIComponent(sessionLifecycleMatch[1]);
-        const sessionId = decodeURIComponent(sessionLifecycleMatch[2]);
-        const deleted = deleteSessionForAgent(agentId, sessionId) ||
-            deleteSessionForAgent(agentId, sessionId, true);
+    if (threadLifecycleMatch && method === 'DELETE') {
+        const agentId = decodeURIComponent(threadLifecycleMatch[1]);
+        const threadId = decodeURIComponent(threadLifecycleMatch[2]);
+        const deleted = deleteThreadForAgent(agentId, threadId) ||
+            deleteThreadForAgent(agentId, threadId, true);
         if (!deleted) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
         writeJson(res, 200, { ok: true });
         return true;
     }
-    const runtimeStateMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/runtime-state$/);
+    const runtimeStateMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/runtime-state$/);
     if (runtimeStateMatch && method === 'GET') {
         const agentId = decodeURIComponent(runtimeStateMatch[1]);
-        const sessionId = decodeURIComponent(runtimeStateMatch[2]);
-        const session = getSessionForAgent(agentId, sessionId);
-        if (!session) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Session "${sessionId}" was not found for agent "${agentId}"`);
+        const threadId = decodeURIComponent(runtimeStateMatch[2]);
+        const thread = getThreadForAgent(agentId, threadId);
+        if (!thread) {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Thread "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
-        const projection = projectThreadRuntimeState(sessionId);
+        const projection = projectThreadRuntimeState(threadId);
         writeJson(res, 200, {
-            session,
+            thread,
             runtimeState: runtimeStateSummary(projection),
             projection,
         });
         return true;
     }
-    const sessionMessagesMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/sessions\/([^/]+)\/messages$/);
-    if (sessionMessagesMatch && method === 'GET') {
-        const agentId = decodeURIComponent(sessionMessagesMatch[1]);
-        const sessionId = decodeURIComponent(sessionMessagesMatch[2]);
-        const session = getSessionForAgent(agentId, sessionId);
-        if (!session) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+    const threadMessagesMatch = pathname.match(/^\/api\/computers\/\{computer_id\}\/agents\/([^/]+)\/threads\/([^/]+)\/messages$/);
+    if (threadMessagesMatch && method === 'GET') {
+        const agentId = decodeURIComponent(threadMessagesMatch[1]);
+        const threadId = decodeURIComponent(threadMessagesMatch[2]);
+        const thread = getThreadForAgent(agentId, threadId);
+        if (!thread) {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
-        const limit = Math.max(1, parseInt(url.searchParams.get('limit') || '100', 10) || 100);
-        const interactionEvents = getSessionInteractionEvents(agentId, sessionId, limit);
-        const controlLog = listControlLogEntries(sessionId, limit);
-        const runtimeState = runtimeStateForThread(sessionId);
+        const limit = Math.max(1, parseInt(url.searchParams.get('limit') || '200', 10) || 200);
+        const interactionEvents = getThreadInteractionEvents(agentId, threadId, limit);
+        const controlLog = listControlLogEntries(threadId, limit);
+        const runtimeState = runtimeStateForThread(threadId);
         const responseMessages = runtimeState.messages.slice(-limit);
         const responseEvents = runtimeState.events.slice(-limit);
         writeJson(res, 200, {
-            session,
+            thread,
             messages: responseMessages,
             events: responseEvents,
             interaction_events: interactionEvents,
@@ -614,12 +614,12 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
         });
         return true;
     }
-    if (sessionMessagesMatch && method === 'POST') {
-        const agentId = decodeURIComponent(sessionMessagesMatch[1]);
-        const sessionId = decodeURIComponent(sessionMessagesMatch[2]);
-        const session = getSessionForAgent(agentId, sessionId);
-        if (!session) {
-            writeProtocolError(res, 404, 'input_error', 'session_not_found', `Task "${sessionId}" was not found for agent "${agentId}"`);
+    if (threadMessagesMatch && method === 'POST') {
+        const agentId = decodeURIComponent(threadMessagesMatch[1]);
+        const threadId = decodeURIComponent(threadMessagesMatch[2]);
+        const thread = getThreadForAgent(agentId, threadId);
+        if (!thread) {
+            writeProtocolError(res, 404, 'input_error', 'thread_not_found', `Task "${threadId}" was not found for agent "${agentId}"`);
             return true;
         }
         const parsed = await readJsonBody(req);
@@ -629,15 +629,15 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
             writeProtocolError(res, 400, 'input_error', 'content_required', 'user_text and assistant_text are required non-empty strings');
             return true;
         }
-        const chatJid = buildHttpSessionId(agentId, sessionId);
+        const chatJid = buildHttpThreadId(agentId, threadId);
         const senderIdentity = deriveHttpSenderIdentity(adminContext);
         const pairId = randomUUID();
-        recordSessionControlCommand({
+        recordThreadControlCommand({
             agentId,
-            sessionId,
+            threadId,
             turnId: pairId,
             surface: 'web',
-            commandType: 'session.instruct',
+            commandType: 'thread.instruct',
             method: 'turn/start',
             actor: senderIdentity.sender,
             status: 'completed',
@@ -653,7 +653,7 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
             id: `http-slash-${pairId}-user`,
             chat_jid: chatJid,
             agent_id: agentId,
-            session_id: sessionId,
+            thread_id: threadId,
             sender: senderIdentity.sender,
             sender_name: senderIdentity.sender_name,
             content: userText,
@@ -666,7 +666,7 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
             id: `http-slash-${pairId}-assistant`,
             chat_jid: chatJid,
             agent_id: agentId,
-            session_id: sessionId,
+            thread_id: threadId,
             sender: ASSISTANT_NAME,
             sender_name: ASSISTANT_NAME,
             content: assistantText,
@@ -675,14 +675,14 @@ export async function handleSessionsRoutes(req, res, url, pathname, method, admi
             is_bot_message: true,
             metadata: { source: 'http-slash-command' },
         });
-        await ensureThreadTitleFromBackend(agentId, sessionId);
+        await ensureThreadTitleFromBackend(agentId, threadId);
         writeJson(res, 200, { ok: true });
         return true;
     }
     return false;
 }
 async function ensureThreadTitleFromBackend(agentId, threadId) {
-    const existingTitle = getSessionForAgent(agentId, threadId)?.title?.trim();
+    const existingTitle = getThreadForAgent(agentId, threadId)?.title?.trim();
     if (existingTitle)
         return;
     let title = readCodexTitleForThread(threadId);
@@ -698,10 +698,10 @@ async function ensureThreadTitleFromBackend(agentId, threadId) {
         return;
     if (existingTitle === title)
         return;
-    updateSessionMetadata(agentId, threadId, { title });
-    broadcastToChat(buildHttpSessionId(agentId, threadId), {
-        type: 'session_updated',
-        session: { task_id: threadId, title },
+    updateThreadMetadata(agentId, threadId, { title });
+    broadcastToChat(buildHttpThreadId(agentId, threadId), {
+        type: 'thread_updated',
+        thread: { task_id: threadId, title },
     });
 }
-//# sourceMappingURL=sessions.js.map
+//# sourceMappingURL=threads.js.map