@supen-ai/cli 1.4.0 → 1.4.2

package/daemon/dist/core/cortex.js

@@ -3,9 +3,8 @@ import path from 'path';
 import { logger } from './logger.js';
 import { getGatewayInstance, getLlmToken, getLlmTokenOrWait } from './gateway.js';
 import { AGENT_MIND_FILES, ASSISTANT_NAME, agentPaths, getAgentModelConfig, } from './config.js';
-import { cleanupTaskFolderWithoutMeaningfulArtifacts, ensureTaskArtifactLayout, resolveSessionTaskArtifactPaths, } from './task-artifacts.js';
-import { getUsageStats, appendGlobalUsage, clearSessionSdkId, ensureSession, updateSessionStatus, updateSessionSdkId, updateSessionUsage, getSessionForAgent, storeSessionUiEvent, } from './store.js';
-import { appendThreadEvent } from './thread-event-log.js';
+import { cleanupTaskFolderWithoutMeaningfulArtifacts, ensureTaskArtifactLayout, resolveThreadTaskArtifactPaths, } from './task-artifacts.js';
+import { getUsageStats, appendGlobalUsage, clearThreadSdkSessionId, ensureThread, updateThreadStatus, updateThreadSdkSessionId, updateThreadUsage, getThreadForAgent, storeThreadUiEvent, } from './store.js';
 import { LoopGuard } from './loop-guard.js';
 import { convertSdkEventToUiMessageChunks, enrichUiMessageChunksWithDocumentRefs, serializeUiMessageChunks, } from './protocol-adapter.js';
 import { resolveMcpServers } from '../mcp/default-servers.js';
@@ -15,10 +14,10 @@ import { resolveInstalledPluginMcpServers } from '../plugins/hub.js';
 import { resolveEnabledSkillMcpServers } from '../skills/mcp-config.js';
 import { getRuntimeSpaceEnvVars, withRuntimeSpaceEnv } from './space-env.js';
 import { buildAssistantOutputExcerpt, buildObservableToolDetail, buildTaskContextExcerpt, excerptText, } from './observable-logging.js';
-import { classifySessionInsight } from '../agent-sdk/session-events.js';
-import { SessionManager } from '../agent-sdk/session-manager.js';
+import { classifyThreadInsight } from '../agent-sdk/thread-events.js';
+import { ThreadManager } from '../agent-sdk/thread-manager.js';
 import { convertDriverOutputsToUiMessageChunks } from '../agent-sdk/driver-output-ui.js';
-import { createSession, createTurn } from '../agent-sdk/session-events.js';
+import { createThread, createTurn } from '../agent-sdk/thread-events.js';
 import { createFileMemorySubsystem } from '../agent-sdk/memory/filesystem.js';
 function isVisualRuntimeAttachment(attachment) {
     const type = typeof attachment?.type === 'string' ? attachment.type : '';
@@ -105,7 +104,7 @@ function appendNormalizedOutputToFinalText(normalizedOutputs, current) {
     let next = current;
     let receivedText = false;
     for (const output of normalizedOutputs) {
-        if (output.kind === 'session-event' && output.event?.type === 'text.delta') {
+        if (output.kind === 'thread-event' && output.event?.type === 'text.delta') {
             const payload = output.event.payload;
             const text = typeof payload?.text === 'string' ? payload.text : '';
             if (text) {
@@ -149,7 +148,7 @@ function appendNormalizedOutputToFinalText(normalizedOutputs, current) {
 }
 function extractTerminalResultText(normalizedOutputs) {
     for (const output of normalizedOutputs) {
-        if (output.kind !== 'session-event')
+        if (output.kind !== 'thread-event')
             continue;
         if (output.event?.type !== 'turn.completed')
             continue;
@@ -162,7 +161,7 @@ function extractTerminalResultText(normalizedOutputs) {
 }
 function extractTerminalFailureText(normalizedOutputs) {
     for (const output of normalizedOutputs) {
-        if (output.kind !== 'session-event')
+        if (output.kind !== 'thread-event')
             continue;
         if (output.event?.type !== 'turn.failed' && output.event?.type !== 'turn.cancelled')
             continue;
@@ -211,10 +210,10 @@ const RECENT_JOURNAL_TOTAL_MAX_CHARS = 6_000;
 function resolveAgentRuntimePaths(agentId) {
     return agentPaths(agentId);
 }
-function nativeSessionPrewarmKey(agentId, sessionId, driverId, options) {
+function nativeSessionPrewarmKey(agentId, threadId, driverId, options) {
     return [
         agentId,
-        sessionId,
+        threadId,
         driverId,
         options?.model || '',
         options?.effort || '',
@@ -229,7 +228,7 @@ function pruneNativeSessionPrewarmCache(now = Date.now()) {
             continue;
         nativeSessionPrewarmCache.delete(key);
         entry.promise
-            .then((session) => session.close())
+            .then((thread) => thread.close())
             .catch(() => { });
     }
 }
@@ -261,7 +260,7 @@ function extractUsageTotals(raw) {
         return null;
     return { tokensIn: input, tokensOut: output };
 }
-function reportUsageToGateway(agentId, sessionId, tokensIn, tokensOut) {
+function reportUsageToGateway(agentId, threadId, tokensIn, tokensOut) {
     const gateway = getGatewayInstance();
     if (!gateway || !gateway.isConnected())
         return;
@@ -274,7 +273,7 @@ function reportUsageToGateway(agentId, sessionId, tokensIn, tokensOut) {
     gateway.reportUsage({
         token: getLlmToken(),
         agent_id: agentId,
-        thread_id: sessionId,
+        thread_id: threadId,
         provider: selectedModel?.provider_id,
         model: selectedModel?.model,
         input_tokens: tokensIn,
@@ -290,25 +289,25 @@ export class AgentCortex {
     lastInputTokens = 0;
     lastOutputTokens = 0;
     loopGuard;
-    sessionManager = new SessionManager();
+    threadManager = new ThreadManager();
     memorySubsystem;
-    sessionRecord;
-    constructor(agentId, sessionId, events = {}) {
+    threadRecord;
+    constructor(agentId, threadId, events = {}) {
         this.events = events;
-        const sessionRecord = getSessionForAgent(agentId, sessionId) ||
-            ensureSession({
+        const threadRecord = getThreadForAgent(agentId, threadId) ||
+            ensureThread({
                 agent_id: agentId,
-                session_id: sessionId,
+                thread_id: threadId,
                 channel: 'daemon',
                 agent_name: agentId,
             });
-        this.sessionRecord = sessionRecord;
+        this.threadRecord = threadRecord;
         this.state = {
             status: 'idle',
             agent_id: agentId,
-            session_id: sessionId,
-            sdk_session_id: sessionRecord?.sdk_session_id,
-            backend_driver_id: sessionRecord?.backend_driver_id,
+            thread_id: threadId,
+            sdk_session_id: threadRecord?.sdk_session_id,
+            backend_driver_id: threadRecord?.backend_driver_id,
             activity: { phase: 'idle' },
             recent_logs: [],
             last_activity_at: Date.now(),
@@ -320,7 +319,7 @@ export class AgentCortex {
         return { ...this.state };
     }
     resolveBackendDriverId(explicitDriverId) {
-        const driverId = this.sessionManager.resolveDriverId(explicitDriverId || this.state.backend_driver_id);
+        const driverId = this.threadManager.resolveDriverId(explicitDriverId || this.state.backend_driver_id);
         if (this.state.backend_driver_id !== driverId) {
             this.state.backend_driver_id = driverId;
         }
@@ -333,7 +332,7 @@ export class AgentCortex {
     async buildMcpServersConfig() {
         // The user's global MCP config (own custom servers, catalog toggles, env
         // overrides) is owned by the gateway. Fetch with a short TTL so every
-        // session pick-up reflects recent toggles without a per-session
+        // thread pick-up reflects recent toggles without a per-thread
         // round-trip penalty.
         const globalConfig = await fetchGlobalMcpConfig();
         const localEnvOverrides = getMcpEnvOverrides();
@@ -343,7 +342,7 @@ export class AgentCortex {
         };
         const disabledIds = new Set(globalConfig.disabled_mcp_server_ids);
         const pluginMcpServers = await resolveInstalledPluginMcpServers();
-        // Preload built-in catalog MCP servers for every session, skipping ids
+        // Preload built-in catalog MCP servers for every thread, skipping ids
         // the user disabled globally. Skills/manager declarations may override by
         // id below.
         const runtimeEnv = withRuntimeSpaceEnv(process.env);
@@ -403,11 +402,11 @@ export class AgentCortex {
     }
     async createNativeSdkSession(options) {
         const paths = resolveAgentRuntimePaths(this.state.agent_id);
-        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
-        const sessionKey = `${this.state.agent_id}:${this.state.session_id}`;
+        const artifacts = resolveThreadTaskArtifactPaths(this.threadRecord, this.state.task_id);
+        const threadKey = `${this.state.agent_id}:${this.state.thread_id}`;
         const driverId = this.resolveBackendDriverId();
-        const sdkSession = createSession({ id: this.state.session_id });
-        const sdkTurn = createTurn({ sessionId: sdkSession.id });
+        const sdkThread = createThread({ id: this.state.thread_id });
+        const sdkTurn = createTurn({ threadId: sdkThread.id });
         this.initBrain(paths.base, artifacts.cwd);
         ensureTaskArtifactLayout(artifacts);
         if (shouldWaitForGatewayToken(this.state.agent_id)) {
@@ -421,10 +420,10 @@ export class AgentCortex {
             }
         }
         const mcpServers = await this.buildMcpServersConfig();
-        return this.sessionManager.createSessionForTurn({
+        return this.threadManager.createThreadForTurn({
             driverId,
             agentId: this.state.agent_id,
-            session: sdkSession,
+            thread: sdkThread,
             turn: sdkTurn,
             cwd: artifacts.cwd,
             writableRoots: artifacts.writableRoots,
@@ -433,7 +432,7 @@ export class AgentCortex {
             permissionMode: options?.permissionMode,
             networkAccess: options?.networkAccess,
             trustedDataHosts: options?.trustedDataHosts,
-            env: this.sessionRecord.environment_snapshot?.environment_variables,
+            env: this.threadRecord.environment_snapshot?.environment_variables,
             resume: options?.resume === false ? undefined : this.state.sdk_session_id,
             mcpServers,
             systemPromptAppend: this.preparePrompt(paths.base, artifacts),
@@ -443,7 +442,7 @@ export class AgentCortex {
         const now = Date.now();
         pruneNativeSessionPrewarmCache(now);
         const driverId = this.resolveBackendDriverId();
-        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.session_id, driverId, options);
+        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.thread_id, driverId, options);
         const prewarmed = nativeSessionPrewarmCache.get(key);
         if (prewarmed && prewarmed.expiresAt > now) {
             nativeSessionPrewarmCache.delete(key);
@@ -451,16 +450,16 @@ export class AgentCortex {
                 return await prewarmed.promise;
             }
             catch (err) {
-                logger.debug({ err, agent_id: this.state.agent_id, session_id: this.state.session_id }, 'Native session prewarm was unavailable; creating a fresh session');
+                logger.debug({ err, agent_id: this.state.agent_id, thread_id: this.state.thread_id }, 'Native thread prewarm was unavailable; creating a fresh thread');
             }
         }
         return this.createNativeSdkSession(options);
     }
-    async prewarmNativeSession(options) {
+    async prewarmNativeThread(options) {
         const now = Date.now();
         pruneNativeSessionPrewarmCache(now);
         const driverId = this.resolveBackendDriverId();
-        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.session_id, driverId, options);
+        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.thread_id, driverId, options);
         const existing = nativeSessionPrewarmCache.get(key);
         if (existing && existing.expiresAt > now) {
             try {
@@ -482,9 +481,9 @@ export class AgentCortex {
                 networkAccess: options?.networkAccess,
                 trustedDataHosts: options?.trustedDataHosts,
                 waitForTokenTimeoutMs: 1_500,
-            }).then(async (session) => {
-                await session.prepare?.();
-                return session;
+            }).then(async (thread) => {
+                await thread.prepare?.();
+                return thread;
             }),
         };
         nativeSessionPrewarmCache.set(key, entry);
@@ -493,7 +492,7 @@ export class AgentCortex {
                 return;
             nativeSessionPrewarmCache.delete(key);
             entry.promise
-                .then((session) => session.close())
+                .then((thread) => thread.close())
                 .catch(() => { });
         }, NATIVE_SESSION_PREWARM_TTL_MS);
         timeout.unref?.();
@@ -504,12 +503,12 @@ export class AgentCortex {
             if (nativeSessionPrewarmCache.get(key) === entry) {
                 nativeSessionPrewarmCache.delete(key);
             }
-            logger.debug({ err, agent_id: this.state.agent_id, session_id: this.state.session_id }, 'Native session prewarm failed');
+            logger.debug({ err, agent_id: this.state.agent_id, thread_id: this.state.thread_id }, 'Native thread prewarm failed');
         }
     }
     async run(taskId, prompt, options) {
         if (this.state.status === 'busy') {
-            throw new Error(`Cortex ${this.state.agent_id}:${this.state.session_id} is already busy.`);
+            throw new Error(`Cortex ${this.state.agent_id}:${this.state.thread_id} is already busy.`);
         }
         this.state.task_id = taskId || `task-${Date.now()}`;
         this.state.status = 'busy';
@@ -520,11 +519,11 @@ export class AgentCortex {
         this.loopGuard.reset();
         if (options?.resume === false && this.state.sdk_session_id) {
             this.state.sdk_session_id = undefined;
-            clearSessionSdkId(this.state.agent_id, this.state.session_id);
+            clearThreadSdkSessionId(this.state.agent_id, this.state.thread_id);
         }
-        updateSessionStatus(this.state.agent_id, this.state.session_id, 'running');
+        updateThreadStatus(this.state.agent_id, this.state.thread_id, 'running');
         const paths = resolveAgentRuntimePaths(this.state.agent_id);
-        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
+        const artifacts = resolveThreadTaskArtifactPaths(this.threadRecord, this.state.task_id);
         this.initBrain(paths.base, artifacts.cwd);
         ensureTaskArtifactLayout(artifacts);
         logger.info({
@@ -535,7 +534,7 @@ export class AgentCortex {
         await this.notifyState();
         let runtimeTimeout = null;
         let runtimeTimedOut = false;
-        let activeSession = null;
+        let activeThread = null;
         const runtimeTimeoutMs = typeof options?.timeoutMs === 'number' && Number.isFinite(options.timeoutMs)
             ? Math.max(0, options.timeoutMs)
             : 0;
@@ -559,12 +558,12 @@ export class AgentCortex {
                 .join('\n\n');
             const mcpServers = await this.buildMcpServersConfig();
             const driverId = this.resolveBackendDriverId();
-            const sdkSession = createSession({ id: this.state.session_id });
-            const sdkTurn = createTurn({ sessionId: sdkSession.id });
-            const session = await this.sessionManager.createSessionForTurn({
+            const sdkThread = createThread({ id: this.state.thread_id });
+            const sdkTurn = createTurn({ threadId: sdkThread.id });
+            const thread = await this.threadManager.createThreadForTurn({
                 driverId,
                 agentId: this.state.agent_id,
-                session: sdkSession,
+                thread: sdkThread,
                 turn: sdkTurn,
                 cwd: artifacts.cwd,
                 writableRoots: artifacts.writableRoots,
@@ -573,18 +572,18 @@ export class AgentCortex {
                 permissionMode: options?.permissionMode,
                 networkAccess: options?.networkAccess,
                 trustedDataHosts: options?.trustedDataHosts,
-                env: this.sessionRecord.environment_snapshot?.environment_variables,
+                env: this.threadRecord.environment_snapshot?.environment_variables,
                 resume: options?.resume === false ? undefined : this.state.sdk_session_id,
                 mcpServers,
                 systemPromptAppend: systemPrompt,
             });
-            activeSession = session;
+            activeThread = thread;
             if (runtimeTimeoutMs > 0) {
                 runtimeTimeout = setTimeout(() => {
                     runtimeTimedOut = true;
                     this.controller?.abort();
                     try {
-                        activeSession?.close();
+                        activeThread?.close();
                     }
                     catch {
                         // Closing is best-effort; the loop below will surface the timeout.
@@ -595,26 +594,26 @@ export class AgentCortex {
             this.state.activity.action = 'thinking';
             await this.notifyState();
             // Send the prompt to the SDK session
-            await session.send(prompt);
+            await thread.send(prompt);
             let finalText = '';
             let receivedStreamedText = false;
-            const stream = session.stream();
+            const stream = thread.stream();
             for await (const message of stream) {
                 if (runtimeTimedOut) {
                     throw new Error(runtimeTimeoutMessage);
                 }
                 if (this.controller?.signal.aborted) {
-                    session.close();
+                    thread.close();
                     throw new Error('Aborted');
                 }
                 const msg = message;
-                if (msg.session_id && !this.state.sdk_session_id) {
-                    this.state.sdk_session_id = msg.session_id;
-                    updateSessionSdkId(this.state.agent_id, this.state.session_id, msg.session_id);
+                if (msg.thread_id && !this.state.sdk_session_id) {
+                    this.state.sdk_session_id = msg.thread_id;
+                    updateThreadSdkSessionId(this.state.agent_id, this.state.thread_id, msg.thread_id);
                 }
-                const normalizedOutputs = this.sessionManager.normalizeOutput({
+                const normalizedOutputs = this.threadManager.normalizeOutput({
                     driverId: this.state.backend_driver_id,
-                    sessionId: this.state.session_id,
+                    threadId: this.state.thread_id,
                     turnId: sdkTurn.id,
                     output: msg,
                 });
@@ -680,14 +679,14 @@ export class AgentCortex {
             await this.events.onReply?.(finalText);
             await this.consolidateMemory(paths.base, finalText);
             try {
-                const usage = extractUsageTotals(await session.getContextUsage?.());
+                const usage = extractUsageTotals(await thread.getContextUsage?.());
                 if (usage) {
-                    reportUsageToGateway(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                    reportUsageToGateway(this.state.agent_id, this.state.thread_id, usage.tokensIn, usage.tokensOut);
                     try {
-                        updateSessionUsage(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                        updateThreadUsage(this.state.agent_id, this.state.thread_id, usage.tokensIn, usage.tokensOut);
                     }
                     catch {
-                        appendGlobalUsage(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                        appendGlobalUsage(this.state.agent_id, this.state.thread_id, usage.tokensIn, usage.tokensOut);
                     }
                 }
             }
@@ -697,19 +696,19 @@ export class AgentCortex {
                     message: usageErr instanceof Error ? usageErr.message : String(usageErr),
                     stack: usageErr instanceof Error ? usageErr.stack : undefined,
                     agent_id: this.state.agent_id,
-                    session_id: this.state.session_id,
-                }, 'Failed to persist session usage after run');
+                    thread_id: this.state.thread_id,
+                }, 'Failed to persist thread usage after run');
             }
             this.state.status = 'idle';
             this.state.last_activity_at = Date.now();
             this.state.activity = { phase: 'done' };
-            updateSessionStatus(this.state.agent_id, this.state.session_id, 'idle');
+            updateThreadStatus(this.state.agent_id, this.state.thread_id, 'idle');
         }
         catch (err) {
             if (runtimeTimedOut) {
                 this.state.status = 'error';
                 this.state.activity = { phase: 'error', action: runtimeTimeoutMessage };
-                updateSessionStatus(this.state.agent_id, this.state.session_id, 'error');
+                updateThreadStatus(this.state.agent_id, this.state.thread_id, 'error');
                 logger.error({ err, agent_id: this.state.agent_id, task_id: this.state.task_id }, 'Cortex: Task timed out');
                 try {
                     await this.events.onError?.(runtimeTimeoutMessage, new Error(runtimeTimeoutMessage));
@@ -719,12 +718,12 @@ export class AgentCortex {
             else if (this.controller?.signal.aborted) {
                 this.state.status = 'interrupted';
                 this.state.activity = { phase: 'interrupted' };
-                updateSessionStatus(this.state.agent_id, this.state.session_id, 'idle');
+                updateThreadStatus(this.state.agent_id, this.state.thread_id, 'idle');
             }
             else {
                 this.state.status = 'error';
                 this.state.activity = { phase: 'error', action: err.message };
-                updateSessionStatus(this.state.agent_id, this.state.session_id, 'error');
+                updateThreadStatus(this.state.agent_id, this.state.thread_id, 'error');
                 logger.error({ err, agent_id: this.state.agent_id }, 'Cortex: Loop failed');
                 const displayError = `> 🚨 **Agent Pipeline Halted:**\n> ${err.message}`;
                 try {
@@ -752,14 +751,14 @@ export class AgentCortex {
     }
     async runNativeStream(taskId, messages, options) {
         if (this.state.status === 'busy') {
-            throw new Error(`Cortex ${this.state.agent_id}:${this.state.session_id} is already busy.`);
+            throw new Error(`Cortex ${this.state.agent_id}:${this.state.thread_id} is already busy.`);
         }
         this.state.task_id = taskId || `task-${Date.now()}`;
         this.state.status = 'busy';
         this.controller = new AbortController();
-        updateSessionStatus(this.state.agent_id, this.state.session_id, 'running');
+        updateThreadStatus(this.state.agent_id, this.state.thread_id, 'running');
         const paths = resolveAgentRuntimePaths(this.state.agent_id);
-        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
+        const artifacts = resolveThreadTaskArtifactPaths(this.threadRecord, this.state.task_id);
         ensureTaskArtifactLayout(artifacts);
         logger.info({
             agent_id: this.state.agent_id,
@@ -792,7 +791,7 @@ export class AgentCortex {
             prompt_excerpt: promptExcerpt,
             context_excerpt: contextExcerpt,
         }, 'Task stream context');
-        storeSessionUiEvent(this.state.agent_id, this.state.session_id, {
+        storeThreadUiEvent(this.state.agent_id, this.state.thread_id, {
             id: `${this.state.task_id}:task-started:${Date.now()}`,
             timestamp: new Date().toISOString(),
             task_id: this.state.task_id,
@@ -811,7 +810,7 @@ export class AgentCortex {
         });
         const encoder = new TextEncoder();
         const agentId = this.state.agent_id;
-        const sessionId = this.state.session_id;
+        const threadId = this.state.thread_id;
         const self = this;
         return new ReadableStream({
             async start(controller) {
@@ -832,8 +831,8 @@ export class AgentCortex {
                 let receivedIncrementalText = false;
                 let receivedIncrementalReasoning = false;
                 const assistantMessageId = `${taskId}-assistant`;
-                const sdkSessionRecord = createSession({ id: self.state.session_id });
-                const sdkTurn = createTurn({ sessionId: sdkSessionRecord.id });
+                const sdkSessionRecord = createThread({ id: self.state.thread_id });
+                const sdkTurn = createTurn({ threadId: sdkSessionRecord.id });
                 const isAborted = () => self.controller?.signal.aborted === true;
                 const abortSdkSession = () => {
                     try {
@@ -847,30 +846,12 @@ export class AgentCortex {
                 const persistUiChunks = (chunks) => {
                     const timestamp = new Date().toISOString();
                     for (const chunk of chunks) {
-                        storeSessionUiEvent(self.state.agent_id, self.state.session_id, {
+                        storeThreadUiEvent(self.state.agent_id, self.state.thread_id, {
                             id: `${taskId}:${timestamp}:${Math.random().toString(36).slice(2, 8)}`,
                             timestamp,
                             task_id: taskId,
                             chunk,
                         });
-                        if (chunk.type === 'data-codex-event') {
-                            const data = chunk.data && typeof chunk.data === 'object'
-                                ? chunk.data
-                                : {};
-                            const raw = data.raw && typeof data.raw === 'object'
-                                ? data.raw
-                                : null;
-                            if (raw && typeof raw.method === 'string') {
-                                appendThreadEvent({
-                                    threadId: self.state.session_id,
-                                    runtimeThreadId: self.state.sdk_session_id || self.state.session_id,
-                                    source: 'codex-app-server',
-                                    eventType: raw.method,
-                                    rawPayload: raw,
-                                    receivedAt: timestamp,
-                                });
-                            }
-                        }
                     }
                 };
                 const nextTextPartId = () => {
@@ -1087,9 +1068,9 @@ export class AgentCortex {
                             type: message.type,
                             method: typeof message.method === 'string' ? message.method : undefined,
                         }, 'Task stream event');
-                        if (message.session_id && !self.state.sdk_session_id) {
-                            self.state.sdk_session_id = message.session_id;
-                            updateSessionSdkId(self.state.agent_id, self.state.session_id, message.session_id);
+                        if (message.thread_id && !self.state.sdk_session_id) {
+                            self.state.sdk_session_id = message.thread_id;
+                            updateThreadSdkSessionId(self.state.agent_id, self.state.thread_id, message.thread_id);
                         }
                         if (message.type === 'assistant') {
                             const phase = typeof message.phase === 'string' ? message.phase : '';
@@ -1123,9 +1104,9 @@ export class AgentCortex {
                                 receivedIncrementalReasoning = true;
                             }
                         }
-                        const normalizedOutputs = self.sessionManager.normalizeOutput({
+                        const normalizedOutputs = self.threadManager.normalizeOutput({
                             driverId: self.state.backend_driver_id,
-                            sessionId: self.state.session_id,
+                            threadId: self.state.thread_id,
                             turnId: sdkTurn.id,
                             output: message,
                         });
@@ -1199,7 +1180,7 @@ export class AgentCortex {
                             : extractTerminalFailureText(normalizedOutputs);
                         if (terminalFailureText && !streamError) {
                             streamError = new Error(terminalFailureText);
-                            clearSessionSdkId(self.state.agent_id, self.state.session_id);
+                            clearThreadSdkSessionId(self.state.agent_id, self.state.thread_id);
                             self.state.sdk_session_id = undefined;
                         }
                         if (message.type === 'result') {
@@ -1265,7 +1246,7 @@ export class AgentCortex {
                     self.controller?.signal.removeEventListener('abort', abortSdkSession);
                     self.state.status = 'idle';
                     self.state.last_activity_at = Date.now();
-                    updateSessionStatus(self.state.agent_id, self.state.session_id, 'idle');
+                    updateThreadStatus(self.state.agent_id, self.state.thread_id, 'idle');
                     await self.notifyState();
                     self.controller = null;
                     if (streamError && !wasAborted) {
@@ -1283,12 +1264,12 @@ export class AgentCortex {
                         try {
                             const usage = extractUsageTotals(await sdkSession?.getContextUsage?.());
                             if (usage) {
-                                reportUsageToGateway(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                reportUsageToGateway(self.state.agent_id, self.state.thread_id, usage.tokensIn, usage.tokensOut);
                                 try {
-                                    updateSessionUsage(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                    updateThreadUsage(self.state.agent_id, self.state.thread_id, usage.tokensIn, usage.tokensOut);
                                 }
                                 catch {
-                                    appendGlobalUsage(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                    appendGlobalUsage(self.state.agent_id, self.state.thread_id, usage.tokensIn, usage.tokensOut);
                                 }
                             }
                         }
@@ -1298,15 +1279,15 @@ export class AgentCortex {
                                 message: usageErr instanceof Error ? usageErr.message : String(usageErr),
                                 stack: usageErr instanceof Error ? usageErr.stack : undefined,
                                 agent_id: self.state.agent_id,
-                                session_id: self.state.session_id,
-                            }, 'Failed to persist session usage after native stream run');
+                                thread_id: self.state.thread_id,
+                            }, 'Failed to persist thread usage after native stream run');
                         }
                         try {
-                            const taskFolderRemoved = cleanupTaskFolderWithoutMeaningfulArtifacts(self.state.session_id, self.state.task_id);
+                            const taskFolderRemoved = cleanupTaskFolderWithoutMeaningfulArtifacts(self.state.thread_id, self.state.task_id);
                             if (taskFolderRemoved) {
                                 logger.info({
                                     agent_id: self.state.agent_id,
-                                    session_id: self.state.session_id,
+                                    thread_id: self.state.thread_id,
                                     task_id: self.state.task_id,
                                 }, 'Removed completed task folder without meaningful artifacts');
                             }
@@ -1315,7 +1296,7 @@ export class AgentCortex {
                             logger.warn({
                                 cleanupErr,
                                 agent_id: self.state.agent_id,
-                                session_id: self.state.session_id,
+                                thread_id: self.state.thread_id,
                                 task_id: self.state.task_id,
                             }, 'Failed to remove completed task folder without meaningful artifacts');
                         }
@@ -1472,16 +1453,16 @@ ${result}`;
             summary = data.choices?.[0]?.message?.content?.trim();
             if (summary && !summary.toLowerCase().includes('no new facts')) {
                 await this.memorySubsystem.writeEphemeral({
-                    scope: 'session',
+                    scope: 'thread',
                     content: summary,
                     tags: ['consolidated', 'task-result'],
                 });
-                const classification = classifySessionInsight({
+                const classification = classifyThreadInsight({
                     summary,
                     successfulOutcomeCount: 0,
                     repetitionCount: 0,
                 });
-                logger.info({ classification, agent_id: this.state.agent_id }, 'Classified extracted session insight');
+                logger.info({ classification, agent_id: this.state.agent_id }, 'Classified extracted thread insight');
                 const entry = `\n- [${now.toISOString()}] Task: ${this.state.task_id}\n  Facts: ${summary.replace(/\n/g, '\n    ')}\n`;
                 fs.mkdirSync(path.dirname(journalPath), { recursive: true });
                 fs.appendFileSync(journalPath, entry, 'utf-8');