@supen-ai/cli 1.4.1 → 1.4.3

package/daemon/dist/core/store.js

@@ -3,7 +3,7 @@
  *
  * Replaces SQLite (db.ts) with plain files:
  *   - agents/{id}/agent.json        → AgentRecord
- *   - sessions/{sid}/               → session.json + messages.jsonl
+ *   - threads/{sid}/               → thread.json + messages.jsonl
  *   - router-state.json             → key-value pairs
  *   - registered groups             → agent.json `sources` field (future)
  *
@@ -293,73 +293,73 @@ function agentJsonPath(agentId) {
         return resolved.configPath;
     return agentHomePaths(agentId).config;
 }
-function sessionsRootDir() {
-    return path.join(SUPEN_HOME, 'sessions');
+function threadsRootDir() {
+    return path.join(SUPEN_HOME, 'threads');
 }
-function archivedSessionsRootDir() {
-    return path.join(SUPEN_HOME, 'archived_sessions');
+function archivedThreadsRootDir() {
+    return path.join(SUPEN_HOME, 'archived_threads');
 }
-function rootSessionDir(sessionId) {
-    const safeSessionId = assertSafePathSegment(sessionId, 'session_id');
-    return resolveWithin(sessionsRootDir(), safeSessionId);
+function rootThreadDir(threadId) {
+    const safeThreadId = assertSafePathSegment(threadId, 'thread_id');
+    return resolveWithin(threadsRootDir(), safeThreadId);
 }
-function rootArchivedSessionDir(sessionId) {
-    const safeSessionId = assertSafePathSegment(sessionId, 'session_id');
-    return resolveWithin(archivedSessionsRootDir(), safeSessionId);
+function rootArchivedThreadDir(threadId) {
+    const safeThreadId = assertSafePathSegment(threadId, 'thread_id');
+    return resolveWithin(archivedThreadsRootDir(), safeThreadId);
 }
-function sessionDir(agentId, sessionId) {
+function threadDir(agentId, threadId) {
     assertSafePathSegment(agentId, 'agent_id');
-    return rootSessionDir(sessionId);
+    return rootThreadDir(threadId);
 }
-function resolveSessionDir(agentId, sessionId) {
+function resolveThreadDir(agentId, threadId) {
     assertSafePathSegment(agentId, 'agent_id');
-    const livePath = rootSessionDir(sessionId);
+    const livePath = rootThreadDir(threadId);
     if (fs.existsSync(livePath)) {
         return livePath;
     }
-    const archivedPath = rootArchivedSessionDir(sessionId);
+    const archivedPath = rootArchivedThreadDir(threadId);
     if (fs.existsSync(archivedPath)) {
         return archivedPath;
     }
-    return sessionDir(agentId, sessionId);
+    return threadDir(agentId, threadId);
 }
-function sessionJsonPath(agentId, sessionId) {
-    return path.join(resolveSessionDir(agentId, sessionId), 'session.json');
+function threadJsonPath(agentId, threadId) {
+    return path.join(resolveThreadDir(agentId, threadId), 'thread.json');
 }
-function messagesPath(agentId, sessionId) {
-    return path.join(resolveSessionDir(agentId, sessionId), 'messages.jsonl');
+function messagesPath(agentId, threadId) {
+    return path.join(resolveThreadDir(agentId, threadId), 'messages.jsonl');
 }
-function taskMetadataDir(sessionId, taskId) {
+function taskMetadataDir(threadId, taskId) {
     if (!taskId || !taskId.trim())
         return null;
-    return path.join(resolveTaskArtifactPaths(sessionId, taskId).taskRoot, '.supen');
+    return path.join(resolveTaskArtifactPaths(threadId, taskId).taskRoot, '.supen');
 }
-function taskUiEventsPath(sessionId, taskId) {
-    const dir = taskMetadataDir(sessionId, taskId);
+function taskUiEventsPath(threadId, taskId) {
+    const dir = taskMetadataDir(threadId, taskId);
     return dir ? path.join(dir, 'events.jsonl') : null;
 }
-function taskMetadataPath(sessionId, taskId) {
-    const dir = taskMetadataDir(sessionId, taskId);
+function taskMetadataPath(threadId, taskId) {
+    const dir = taskMetadataDir(threadId, taskId);
     return dir ? path.join(dir, 'task.json') : null;
 }
-function writeTaskMetadata(agentId, sessionId, taskId) {
-    const metadataPath = taskMetadataPath(sessionId, taskId);
+function writeTaskMetadata(agentId, threadId, taskId) {
+    const metadataPath = taskMetadataPath(threadId, taskId);
     if (!metadataPath || fs.existsSync(metadataPath))
         return;
     writeJson(metadataPath, {
         agent_id: agentId,
-        session_id: sessionId,
+        thread_id: threadId,
         task_id: taskId,
     });
 }
-function listTaskUiEventsForSession(agentId, sessionId, limit = TASK_UI_EVENT_HISTORY_LIMIT) {
+function listTaskUiEventsForThread(agentId, threadId, limit = TASK_UI_EVENT_HISTORY_LIMIT) {
     const tasksRoot = spacePaths('local').tasks;
     const events = [];
     const boundedLimit = Math.max(1, limit);
     for (const taskFolder of listDirs(tasksRoot)) {
         const metadataDir = path.join(tasksRoot, taskFolder, '.supen');
         const metadata = readJson(path.join(metadataDir, 'task.json'));
-        if (metadata?.agent_id !== agentId || metadata.session_id !== sessionId)
+        if (metadata?.agent_id !== agentId || metadata.thread_id !== threadId)
             continue;
         events.push(...readJsonlTail(path.join(metadataDir, 'events.jsonl'), boundedLimit));
     }
@@ -397,10 +397,10 @@ function automationEventJsonPath(automationId, eventId) {
 function automationTaskId(automationId) {
     return `task-automation-${automationId}`;
 }
-function automationChatJid(agentId, sessionId) {
+function automationChatJid(agentId, threadId) {
     return agentId === AUTOMATION_TASK_AGENT_ID
-        ? `task:${sessionId}`
-        : `web:${agentId}:${sessionId}`;
+        ? `task:${threadId}`
+        : `web:${agentId}:${threadId}`;
 }
 const getRouterStatePath = () => path.join(SUPEN_HOME, 'router-state.json');
 const getRegisteredGroupsPath = () => path.join(SUPEN_HOME, 'registered-groups.json');
@@ -409,8 +409,8 @@ const getRegisteredGroupsPath = () => path.join(SUPEN_HOME, 'registered-groups.j
 // ═══════════════════════════════════════════════════════════════
 export function initStore() {
     fs.mkdirSync(AGENTS_DIR, { recursive: true });
-    fs.mkdirSync(sessionsRootDir(), { recursive: true });
-    fs.mkdirSync(archivedSessionsRootDir(), { recursive: true });
+    fs.mkdirSync(threadsRootDir(), { recursive: true });
+    fs.mkdirSync(archivedThreadsRootDir(), { recursive: true });
     fs.mkdirSync(spacesDir(), { recursive: true });
     logger.info({ dir: AGENTS_DIR }, 'Store initialized (filesystem)');
 }
@@ -515,9 +515,9 @@ export function getAllAgents() {
     return agents.sort((a, b) => (b.updated_at || '').localeCompare(a.updated_at || ''));
 }
 // ═══════════════════════════════════════════════════════════════
-// Sessions
+// Threads
 // ═══════════════════════════════════════════════════════════════
-export function ensureSession(input) {
+export function ensureThread(input) {
     const existingAgent = findAgentRecord(input.agent_id);
     const resolvedSpaceId = input.space_id || existingAgent?.space_id || defaultSpaceId();
     ensureAgent({
@@ -525,7 +525,7 @@ export function ensureSession(input) {
         name: input.agent_name,
         space_id: resolvedSpaceId,
     });
-    const jsonPath = sessionJsonPath(input.agent_id, input.session_id);
+    const jsonPath = threadJsonPath(input.agent_id, input.thread_id);
     const existing = readJson(jsonPath);
     const now = new Date().toISOString();
     const normalizedCreatedAt = typeof input.created_at === 'string' && input.created_at.trim()
@@ -541,7 +541,7 @@ export function ensureSession(input) {
                 ? resolvedSpaceId
                 : existingSpaceId);
         const nextChannel = input.channel;
-        const nextChannelSession = input.channel_session ?? existing.channel_session;
+        const nextChannelThread = input.channel_thread ?? existing.channel_thread;
         const nextBackendDriverId = input.backend_driver_id || existing.backend_driver_id;
         const nextSourceRef = input.source_ref || existing.source_ref;
         const nextKnowledgeId = input.knowledge_id || existing.knowledge_id;
@@ -553,7 +553,7 @@ export function ensureSession(input) {
         const nextStatus = input.status || existing.status;
         const changed = nextSpaceId !== existing.space_id ||
             nextChannel !== existing.channel ||
-            nextChannelSession !== existing.channel_session ||
+            nextChannelThread !== existing.channel_thread ||
             nextBackendDriverId !== existing.backend_driver_id ||
             nextSourceRef !== existing.source_ref ||
             nextKnowledgeId !== existing.knowledge_id ||
@@ -567,7 +567,7 @@ export function ensureSession(input) {
             ...existing,
             space_id: nextSpaceId,
             channel: nextChannel,
-            channel_session: nextChannelSession,
+            channel_thread: nextChannelThread,
             backend_driver_id: nextBackendDriverId,
             source_ref: nextSourceRef,
             knowledge_id: nextKnowledgeId,
@@ -585,11 +585,11 @@ export function ensureSession(input) {
         return updated;
     }
     const record = {
-        session_id: input.session_id,
+        thread_id: input.thread_id,
         agent_id: input.agent_id,
         space_id: resolvedSpaceId,
         channel: input.channel,
-        channel_session: input.channel_session,
+        channel_thread: input.channel_thread,
         backend_driver_id: input.backend_driver_id,
         source_ref: input.source_ref,
         knowledge_id: input.knowledge_id,
@@ -605,70 +605,70 @@ export function ensureSession(input) {
     writeJson(jsonPath, record);
     return record;
 }
-export function getSession(sessionId) {
-    return (readJson(path.join(rootSessionDir(sessionId), 'session.json')) ||
-        readJson(path.join(rootArchivedSessionDir(sessionId), 'session.json')));
+export function getThread(threadId) {
+    return (readJson(path.join(rootThreadDir(threadId), 'thread.json')) ||
+        readJson(path.join(rootArchivedThreadDir(threadId), 'thread.json')));
 }
-export function getSessionForAgent(agentId, sessionId) {
-    const session = readJson(sessionJsonPath(agentId, sessionId));
-    return session?.agent_id === agentId ? session : undefined;
+export function getThreadForAgent(agentId, threadId) {
+    const thread = readJson(threadJsonPath(agentId, threadId));
+    return thread?.agent_id === agentId ? thread : undefined;
 }
 function ensureAutomationTasksForAgent(agentId) {
     for (const automation of listAutomations(agentId)) {
         ensureAutomationTask(automation);
     }
 }
-export function getSessionsForAgent(agentId) {
+export function getThreadsForAgent(agentId) {
     ensureAutomationTasksForAgent(agentId);
-    const sessions = [];
-    const sessionsBase = sessionsRootDir();
-    if (fs.existsSync(sessionsBase)) {
-        for (const sid of listDirs(sessionsBase)) {
-            const session = readJson(path.join(sessionsBase, sid, 'session.json'));
-            if (session?.agent_id === agentId)
-                sessions.push(session);
+    const threads = [];
+    const threadsBase = threadsRootDir();
+    if (fs.existsSync(threadsBase)) {
+        for (const sid of listDirs(threadsBase)) {
+            const thread = readJson(path.join(threadsBase, sid, 'thread.json'));
+            if (thread?.agent_id === agentId)
+                threads.push(thread);
         }
     }
-    return sessions.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
+    return threads.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
 }
-function touchSessionActivity(agentId, sessionId, timestamp = new Date().toISOString()) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (!session)
+function touchThreadActivity(agentId, threadId, timestamp = new Date().toISOString()) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (!thread)
         return;
     const nextUpdatedAt = Number.isNaN(new Date(timestamp).getTime())
         ? new Date().toISOString()
         : timestamp;
-    if (session.updated_at && session.updated_at > nextUpdatedAt)
+    if (thread.updated_at && thread.updated_at > nextUpdatedAt)
         return;
-    session.space_id = session.space_id || DEFAULT_SPACE_ID;
-    session.updated_at = nextUpdatedAt;
-    writeJson(jsonPath, session);
-}
-export function getArchivedSessionsForAgent(agentId) {
-    const sessionsBase = archivedSessionsRootDir();
-    const sessions = [];
-    if (fs.existsSync(sessionsBase)) {
-        for (const sid of listDirs(sessionsBase)) {
-            const jsonPath = path.join(sessionsBase, sid, 'session.json');
-            const session = readJson(jsonPath);
-            if (session?.agent_id === agentId) {
-                sessions.push({ ...session, status: 'archived' });
+    thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+    thread.updated_at = nextUpdatedAt;
+    writeJson(jsonPath, thread);
+}
+export function getArchivedThreadsForAgent(agentId) {
+    const threadsBase = archivedThreadsRootDir();
+    const threads = [];
+    if (fs.existsSync(threadsBase)) {
+        for (const sid of listDirs(threadsBase)) {
+            const jsonPath = path.join(threadsBase, sid, 'thread.json');
+            const thread = readJson(jsonPath);
+            if (thread?.agent_id === agentId) {
+                threads.push({ ...thread, status: 'archived' });
             }
         }
     }
-    return sessions.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
+    return threads.sort((a, b) => (b.updated_at || b.created_at || '').localeCompare(a.updated_at || a.created_at || ''));
 }
-export function getAllSessions() {
-    const sessions = [];
-    for (const sid of listDirs(sessionsRootDir())) {
-        const session = readJson(path.join(sessionsRootDir(), sid, 'session.json'));
-        if (session)
-            sessions.push(session);
+export function getAllThreads() {
+    const threads = [];
+    for (const sid of listDirs(threadsRootDir())) {
+        const thread = readJson(path.join(threadsRootDir(), sid, 'thread.json'));
+        if (thread)
+            threads.push(thread);
     }
-    return sessions.sort((a, b) => {
+    return threads.sort((a, b) => {
         const cmp = a.agent_id.localeCompare(b.agent_id);
-        return cmp !== 0 ? cmp : a.session_id.localeCompare(b.session_id);
+        return cmp !== 0 ? cmp : a.thread_id.localeCompare(b.thread_id);
     });
 }
 export function ensureAutomationTask(automation) {
@@ -676,27 +676,27 @@ export function ensureAutomationTask(automation) {
     const agentId = automation.kind === 'event'
         ? AUTOMATION_TASK_AGENT_ID
         : automation.agent_id;
-    const session = ensureSession({
+    const thread = ensureThread({
         agent_id: agentId,
-        session_id: taskId,
+        thread_id: taskId,
         channel: 'automation',
         source_ref: `automation:${automation.id}`,
         title: automation.name,
         task_workspace_folder: automation.cwds?.[0] ?? null,
     });
-    if (session.agent_id !== agentId) {
+    if (thread.agent_id !== agentId) {
         const updated = {
-            ...session,
+            ...thread,
             agent_id: agentId,
             channel: 'automation',
             source_ref: `automation:${automation.id}`,
             updated_at: new Date().toISOString(),
         };
         ensureAgent({ agent_id: agentId, name: agentId === AUTOMATION_TASK_AGENT_ID ? 'Automation Task' : undefined });
-        writeJson(sessionJsonPath(agentId, taskId), updated);
+        writeJson(threadJsonPath(agentId, taskId), updated);
         return updated;
     }
-    return session;
+    return thread;
 }
 export function automationExecutionIdentity(automationId) {
     return `supen-automation:${automationId}`;
@@ -809,7 +809,7 @@ export function buildAutomationTriggerMessage(input) {
         timestamp: input.nowIso,
         is_from_me: false,
         agent_id: input.automation.agent_id,
-        session_id: taskId,
+        thread_id: taskId,
         task_id: taskId,
         automation_id: input.automation.id,
         automation_run_id: runId,
@@ -832,57 +832,57 @@ export function buildAutomationTriggerMessage(input) {
         },
     };
 }
-export function updateSessionStatus(agentId, sessionId, status) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (session) {
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        session.status = status;
-        session.updated_at = new Date().toISOString();
-        writeJson(jsonPath, session);
-    }
-}
-export function updateSessionSdkId(agentId, sessionId, sdkSessionId) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (session) {
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        session.sdk_session_id = sdkSessionId;
-        session.updated_at = new Date().toISOString();
-        writeJson(jsonPath, session);
-    }
-}
-export function clearSessionSdkId(agentId, sessionId) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (session) {
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        delete session.sdk_session_id;
-        session.updated_at = new Date().toISOString();
-        writeJson(jsonPath, session);
-    }
-}
-export function updateSessionBackendDriverId(agentId, sessionId, backendDriverId) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (session) {
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        session.backend_driver_id = backendDriverId;
-        session.updated_at = new Date().toISOString();
-        writeJson(jsonPath, session);
-    }
-}
-export function updateSessionUsage(agentId, sessionId, tokensIn, tokensOut) {
+export function updateThreadStatus(agentId, threadId, status) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (thread) {
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        thread.status = status;
+        thread.updated_at = new Date().toISOString();
+        writeJson(jsonPath, thread);
+    }
+}
+export function updateThreadSdkSessionId(agentId, threadId, sdkSessionId) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (thread) {
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        thread.sdk_session_id = sdkSessionId;
+        thread.updated_at = new Date().toISOString();
+        writeJson(jsonPath, thread);
+    }
+}
+export function clearThreadSdkSessionId(agentId, threadId) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (thread) {
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        delete thread.sdk_session_id;
+        thread.updated_at = new Date().toISOString();
+        writeJson(jsonPath, thread);
+    }
+}
+export function updateThreadBackendDriverId(agentId, threadId, backendDriverId) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (thread) {
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        thread.backend_driver_id = backendDriverId;
+        thread.updated_at = new Date().toISOString();
+        writeJson(jsonPath, thread);
+    }
+}
+export function updateThreadUsage(agentId, threadId, tokensIn, tokensOut) {
     const now = new Date().toISOString();
-    // 1. Update Session Usage
-    const sessPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(sessPath);
-    if (session) {
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        session.tokens_in = (session.tokens_in || 0) + tokensIn;
-        session.tokens_out = (session.tokens_out || 0) + tokensOut;
-        session.updated_at = now;
-        writeJson(sessPath, session);
+    // 1. Update Thread Usage
+    const sessPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(sessPath);
+    if (thread) {
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        thread.tokens_in = (thread.tokens_in || 0) + tokensIn;
+        thread.tokens_out = (thread.tokens_out || 0) + tokensOut;
+        thread.updated_at = now;
+        writeJson(sessPath, thread);
     }
     // 2. Update Agent Usage (Aggregate)
     const aPath = agentJsonPath(agentId);
@@ -893,11 +893,11 @@ export function updateSessionUsage(agentId, sessionId, tokensIn, tokensOut) {
         agent.updated_at = now;
         writeJson(aPath, agent);
     }
-    appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut);
+    appendGlobalUsage(agentId, threadId, tokensIn, tokensOut);
 }
-export function appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut) {
+export function appendGlobalUsage(agentId, threadId, tokensIn, tokensOut) {
     const now = new Date().toISOString();
-    // This ensures deletion of agents/sessions does not impact the historical total.
+    // This ensures deletion of agents/threads does not impact the historical total.
     try {
         const today = now.split('T')[0];
         const models = getAgentModelConfig(agentId, true);
@@ -935,19 +935,19 @@ export function appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut) {
         if (!day.models[modelId]) {
             day.models[modelId] = {
                 total: { tokens_in: 0, tokens_out: 0, estimated_cost_usd: 0 },
-                sessions: {},
+                threads: {},
             };
         }
         const model = day.models[modelId];
-        if (!model.sessions[sessionId]) {
-            model.sessions[sessionId] = {
+        if (!model.threads[threadId]) {
+            model.threads[threadId] = {
                 agent_id: agentId,
                 tokens_in: 0,
                 tokens_out: 0,
                 estimated_cost_usd: 0,
             };
         }
-        const sessionEntry = model.sessions[sessionId];
+        const threadEntry = model.threads[threadId];
         const applyIncrement = (target) => {
             target.tokens_in += tokensIn;
             target.tokens_out += tokensOut;
@@ -958,7 +958,7 @@ export function appendGlobalUsage(agentId, sessionId, tokensIn, tokensOut) {
         ledger.total.updated_at = now;
         applyIncrement(day.total);
         applyIncrement(model.total);
-        applyIncrement(sessionEntry);
+        applyIncrement(threadEntry);
         writeJson(getGlobalUsagePath(), ledger);
     }
     catch (e) {
@@ -989,7 +989,7 @@ export function getUsageStats(record) {
         estimated_cost_usd: Number(estimated_cost_usd.toFixed(6)),
     };
 }
-/** Get global usage across all agents and sessions. */
+/** Get global usage across all agents and threads. */
 export function getGlobalUsage() {
     const ledger = readJson(getGlobalUsagePath());
     if (ledger && ledger.total) {
@@ -1023,25 +1023,25 @@ export function getDailyUsage() {
     return ledger?.daily || {};
 }
 /**
- * Reset sessions stuck as "running" — called at startup to recover from crashes.
- * A "running" session cannot survive a process restart, so these are stale.
+ * Reset threads stuck as "running" — called at startup to recover from crashes.
+ * A "running" thread cannot survive a process restart, so these are stale.
  */
-export function cleanupStaleSessions() {
+export function cleanupStaleThreads() {
     let cleaned = 0;
     for (const agentId of listDirs(AGENTS_DIR)) {
-        for (const session of getSessionsForAgent(agentId)) {
-            if (session.status === 'running') {
-                finalizeInterruptedSessionUiStream(agentId, session.session_id);
-                updateSessionStatus(agentId, session.session_id, 'idle');
+        for (const thread of getThreadsForAgent(agentId)) {
+            if (thread.status === 'running') {
+                finalizeInterruptedThreadUiStream(agentId, thread.thread_id);
+                updateThreadStatus(agentId, thread.thread_id, 'idle');
                 cleaned++;
-                logger.info({ agentId, sessionId: session.session_id }, 'Reset stale running session to idle');
+                logger.info({ agentId, threadId: thread.thread_id }, 'Reset stale running thread to idle');
             }
         }
     }
     return cleaned;
 }
-function finalizeInterruptedSessionUiStream(agentId, sessionId) {
-    const events = getSessionUiEvents(agentId, sessionId, SESSION_UI_EVENT_RECOVERY_LIMIT);
+function finalizeInterruptedThreadUiStream(agentId, threadId) {
+    const events = getThreadUiEvents(agentId, threadId, SESSION_UI_EVENT_RECOVERY_LIMIT);
     if (events.length === 0)
         return;
     let openTaskId;
@@ -1111,7 +1111,7 @@ function finalizeInterruptedSessionUiStream(agentId, sessionId) {
         { type: 'finish', finishReason: 'error' },
     ];
     chunks.forEach((chunk, index) => {
-        storeSessionUiEvent(agentId, sessionId, {
+        storeThreadUiEvent(agentId, threadId, {
             id: `${taskId}:stale-interrupted:${timestamp}:${index}`,
             timestamp,
             task_id: taskId,
@@ -1119,85 +1119,85 @@ function finalizeInterruptedSessionUiStream(agentId, sessionId) {
         });
     });
 }
-export function updateSessionMetadata(agentId, sessionId, updates) {
-    const jsonPath = sessionJsonPath(agentId, sessionId);
-    const session = readJson(jsonPath);
-    if (!session)
+export function updateThreadMetadata(agentId, threadId, updates) {
+    const jsonPath = threadJsonPath(agentId, threadId);
+    const thread = readJson(jsonPath);
+    if (!thread)
         return false;
-    session.space_id = session.space_id || DEFAULT_SPACE_ID;
+    thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
     if (updates.title !== undefined)
-        session.title = updates.title;
+        thread.title = updates.title;
     if (updates.knowledge_id !== undefined)
-        session.knowledge_id = updates.knowledge_id;
+        thread.knowledge_id = updates.knowledge_id;
     if (updates.knowledge_name !== undefined)
-        session.knowledge_name = updates.knowledge_name;
-    session.updated_at = new Date().toISOString();
-    writeJson(jsonPath, session);
+        thread.knowledge_name = updates.knowledge_name;
+    thread.updated_at = new Date().toISOString();
+    writeJson(jsonPath, thread);
     return true;
 }
-export function archiveSessionForAgent(agentId, sessionId) {
-    const dir = sessionDir(agentId, sessionId);
+export function archiveThreadForAgent(agentId, threadId) {
+    const dir = threadDir(agentId, threadId);
     if (!fs.existsSync(dir))
         return false;
-    const session = readJson(path.join(dir, 'session.json'));
-    if (session && session.agent_id !== agentId)
+    const thread = readJson(path.join(dir, 'thread.json'));
+    if (thread && thread.agent_id !== agentId)
         return false;
-    const archiveDir = archivedSessionsRootDir();
+    const archiveDir = archivedThreadsRootDir();
     fs.mkdirSync(archiveDir, { recursive: true });
-    const targetDir = rootArchivedSessionDir(sessionId);
+    const targetDir = rootArchivedThreadDir(threadId);
     if (fs.existsSync(targetDir))
         return false; // already archived
     fs.renameSync(dir, targetDir);
-    deleteSchedulesForSession(agentId, sessionId);
+    deleteSchedulesForThread(agentId, threadId);
     return true;
 }
-function deleteSchedulesForSession(agentId, sessionId) {
-    if (sessionId.startsWith('sched-')) {
-        deleteSchedule(sessionId.slice(6));
+function deleteSchedulesForThread(agentId, threadId) {
+    if (threadId.startsWith('sched-')) {
+        deleteSchedule(threadId.slice(6));
     }
     else {
         const schedules = getSchedulesForAgent(agentId);
         for (const s of schedules) {
-            if (s.target_jid && s.target_jid.endsWith(':' + sessionId)) {
+            if (s.target_jid && s.target_jid.endsWith(':' + threadId)) {
                 deleteSchedule(s.id);
             }
         }
     }
 }
-export function restoreSessionForAgent(agentId, sessionId) {
-    const archivePath = rootArchivedSessionDir(sessionId);
+export function restoreThreadForAgent(agentId, threadId) {
+    const archivePath = rootArchivedThreadDir(threadId);
     if (!fs.existsSync(archivePath))
         return false;
-    const restoreDir = sessionDir(agentId, sessionId);
+    const restoreDir = threadDir(agentId, threadId);
     fs.mkdirSync(path.dirname(restoreDir), { recursive: true });
     if (fs.existsSync(restoreDir))
         return false;
     fs.renameSync(archivePath, restoreDir);
     return true;
 }
-export function deleteSession(sessionId) {
-    const liveDir = rootSessionDir(sessionId);
+export function deleteThread(threadId) {
+    const liveDir = rootThreadDir(threadId);
     if (fs.existsSync(liveDir)) {
         fs.rmSync(liveDir, { recursive: true, force: true });
         return;
     }
-    const archivedDir = rootArchivedSessionDir(sessionId);
+    const archivedDir = rootArchivedThreadDir(threadId);
     if (fs.existsSync(archivedDir)) {
         fs.rmSync(archivedDir, { recursive: true, force: true });
         return;
     }
 }
-export function deleteSessionForAgent(agentId, sessionId, fromArchived = false) {
+export function deleteThreadForAgent(agentId, threadId, fromArchived = false) {
     const dir = fromArchived
-        ? rootArchivedSessionDir(sessionId)
-        : sessionDir(agentId, sessionId);
+        ? rootArchivedThreadDir(threadId)
+        : threadDir(agentId, threadId);
     if (!fs.existsSync(dir))
         return false;
-    const session = readJson(path.join(dir, 'session.json'));
-    if (session && session.agent_id !== agentId)
+    const thread = readJson(path.join(dir, 'thread.json'));
+    if (thread && thread.agent_id !== agentId)
         return false;
     fs.rmSync(dir, { recursive: true, force: true });
-    deleteSchedulesForSession(agentId, sessionId);
+    deleteSchedulesForThread(agentId, threadId);
     return true;
 }
 /** Convert internal JSONL format → NewMessage for API compatibility */
@@ -1225,71 +1225,67 @@ function storedToNewMessage(m, chatJid) {
         schedule_notify_policy: m.schedule_notify_policy,
     };
 }
-/** Resolve agent+session from chat_jid (format: "web:agent_id:session_id" or similar). */
+/** Resolve agent+thread from chat_jid (format: "web:agent_id:thread_id" or similar). */
 export function resolveFromChatJid(chatJid) {
     const taskMatch = chatJid.match(/^task:(.+)$/);
     if (taskMatch) {
-        return { agentId: AUTOMATION_TASK_AGENT_ID, sessionId: taskMatch[1] };
+        return { agentId: AUTOMATION_TASK_AGENT_ID, threadId: taskMatch[1] };
     }
-    // web:agent_id:session_id
+    // web:agent_id:thread_id
     const webMatch = chatJid.match(/^web:(.+?):(.+)$/);
     if (webMatch)
-        return { agentId: webMatch[1], sessionId: webMatch[2] };
-    // acp:agent_id:session_id
-    const acpMatch = chatJid.match(/^acp:(.+?):(.+)$/);
-    if (acpMatch)
-        return { agentId: acpMatch[1], sessionId: acpMatch[2] };
-    // gateway:agent_id:session_id
+        return { agentId: webMatch[1], threadId: webMatch[2] };
+    // gateway:agent_id:thread_id
     const gatewayMatch = chatJid.match(/^gateway:(.+?):(.+)$/);
     if (gatewayMatch)
-        return { agentId: gatewayMatch[1], sessionId: gatewayMatch[2] };
+        return { agentId: gatewayMatch[1], threadId: gatewayMatch[2] };
     // feishu:app_id:chat_id
     const feishuMatch = chatJid.match(/^feishu:(.+?):(.+)$/);
     if (feishuMatch)
-        return { agentId: feishuMatch[1], sessionId: feishuMatch[2] };
-    // For other channels, try to find the session across agents
-    for (const sid of listDirs(sessionsRootDir())) {
-        const session = readJson(path.join(sessionsRootDir(), sid, 'session.json'));
-        if (session?.source_ref === chatJid) {
-            return { agentId: session.agent_id, sessionId: session.session_id };
+        return { agentId: feishuMatch[1], threadId: feishuMatch[2] };
+    // For other channels, try to find the thread across agents
+    for (const sid of listDirs(threadsRootDir())) {
+        const thread = readJson(path.join(threadsRootDir(), sid, 'thread.json'));
+        if (thread?.source_ref === chatJid) {
+            return { agentId: thread.agent_id, threadId: thread.thread_id };
         }
     }
     return null;
 }
 export function storeMessage(msg) {
-    // Determine agent_id and session_id
+    // Determine agent_id and thread_id
     let agentId = msg.agent_id;
-    let sessionId = msg.session_id;
-    if (!agentId || !sessionId) {
+    let threadId = msg.thread_id;
+    if (!agentId || !threadId) {
         const resolved = resolveFromChatJid(msg.chat_jid);
         if (resolved) {
             agentId = agentId || resolved.agentId;
-            sessionId = sessionId || resolved.sessionId;
+            threadId = threadId || resolved.threadId;
         }
     }
-    if (!agentId || !sessionId) {
-        logger.warn({ chat_jid: msg.chat_jid }, 'Cannot store message: unable to resolve agent/session from chat_jid');
+    if (!agentId || !threadId) {
+        logger.warn({ chat_jid: msg.chat_jid }, 'Cannot store message: unable to resolve agent/thread from chat_jid');
         return;
     }
-    const channelSession = typeof msg.metadata?.channel_thread === 'string'
+    const channelThread = typeof msg.metadata?.channel_thread === 'string'
         ? msg.metadata.channel_thread
-        : typeof msg.metadata?.channel_session === 'string'
-            ? msg.metadata.channel_session
+        : typeof msg.metadata?.channel_thread === 'string'
+            ? msg.metadata.channel_thread
             : undefined;
-    if (channelSession) {
-        const existingSession = getSessionForAgent(agentId, sessionId);
-        if (existingSession) {
-            ensureSession({
+    if (channelThread) {
+        const existingThread = getThreadForAgent(agentId, threadId);
+        if (existingThread) {
+            ensureThread({
                 agent_id: agentId,
-                session_id: sessionId,
-                channel: existingSession.channel,
-                channel_session: channelSession,
-                source_ref: existingSession.source_ref || msg.chat_jid,
+                thread_id: threadId,
+                channel: existingThread.channel,
+                channel_thread: channelThread,
+                source_ref: existingThread.source_ref || msg.chat_jid,
             });
         }
     }
-    // Ensure session directory exists
-    const msgPath = messagesPath(agentId, sessionId);
+    // Ensure thread directory exists
+    const msgPath = messagesPath(agentId, threadId);
     const stored = {
         id: msg.id,
         ts: msg.timestamp,
@@ -1312,7 +1308,7 @@ export function storeMessage(msg) {
         schedule_notify_policy: msg.schedule_notify_policy,
     };
     appendJsonl(msgPath, stored);
-    touchSessionActivity(agentId, sessionId, msg.timestamp);
+    touchThreadActivity(agentId, threadId, msg.timestamp);
 }
 /** Alias for storeMessage — both had identical implementations in db.ts */
 export const storeMessageDirect = storeMessage;
@@ -1320,14 +1316,14 @@ export function getRecentMessages(chatJid, limit = 10) {
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return [];
-    const messages = readJsonlTail(messagesPath(resolved.agentId, resolved.sessionId), limit);
+    const messages = readJsonlTail(messagesPath(resolved.agentId, resolved.threadId), limit);
     return messages.map((m) => storedToNewMessage(m, chatJid));
 }
 export function getMessagesSince(chatJid, sinceTimestamp, _botPrefix) {
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return [];
-    const all = readJsonl(messagesPath(resolved.agentId, resolved.sessionId));
+    const all = readJsonl(messagesPath(resolved.agentId, resolved.threadId));
     return all
         .filter((m) => {
         const isNew = m.ts > sinceTimestamp;
@@ -1692,7 +1688,7 @@ export function createAutomation(input) {
         rrule: input.rrule.trim(),
         timezone: input.timezone.trim(),
         exdate: input.exdate?.filter(Boolean),
-        session_mode: input.session_mode,
+        thread_mode: input.thread_mode,
         model: input.model,
         reasoning_effort: input.reasoning_effort,
         permission_mode: input.permission_mode,
@@ -1810,7 +1806,7 @@ export function updateAutomation(id, updates) {
         ...(updates.timezone !== undefined ? { timezone: updates.timezone.trim() } : {}),
         ...(updates.exdate !== undefined ? { exdate: updates.exdate.filter(Boolean) } : {}),
         ...(updates.status !== undefined ? { status: updates.status } : {}),
-        ...(updates.session_mode !== undefined ? { session_mode: updates.session_mode } : {}),
+        ...(updates.thread_mode !== undefined ? { thread_mode: updates.thread_mode } : {}),
         ...(updates.model !== undefined ? { model: updates.model } : {}),
         ...(updates.reasoning_effort !== undefined
             ? { reasoning_effort: updates.reasoning_effort }
@@ -1965,10 +1961,10 @@ export function deleteAutomation(id) {
     if (fs.existsSync(dir)) {
         fs.rmSync(dir, { recursive: true, force: true });
     }
-    const sessionId = `sched-${id}`;
+    const threadId = `sched-${id}`;
     for (const agentId of listDirs(AGENTS_DIR)) {
-        deleteSessionForAgent(agentId, sessionId);
-        deleteSessionForAgent(agentId, sessionId, true);
+        deleteThreadForAgent(agentId, threadId);
+        deleteThreadForAgent(agentId, threadId, true);
     }
 }
 export function createAutomationRun(automationId, input = {}) {
@@ -1995,7 +1991,7 @@ export function createAutomationRun(automationId, input = {}) {
         claimed_at: claimedAt,
         started_at: startedAt,
         finished_at: null,
-        session_id: input.session_id,
+        thread_id: input.thread_id,
         task_id: input.task_id,
         prompt: bundle.automation.prompt,
         model: bundle.automation.model,
@@ -2255,16 +2251,16 @@ export function listAutomationRuns(input = {}) {
     })
         .slice(0, limit);
 }
-export function finalizeRunningAutomationRunForSession(agentId, sessionId, input = {}) {
+export function finalizeRunningAutomationRunForThread(agentId, threadId, input = {}) {
     const normalizedAgentId = agentId.trim();
-    const normalizedSessionId = sessionId.trim();
-    if (!normalizedAgentId || !normalizedSessionId)
+    const normalizedThreadId = threadId.trim();
+    if (!normalizedAgentId || !normalizedThreadId)
         return undefined;
     const runningRun = listAutomationRuns({
         agent_id: normalizedAgentId,
         status: 'running',
         limit: 100,
-    }).find((run) => run.session_id === normalizedSessionId);
+    }).find((run) => run.thread_id === normalizedThreadId);
     if (!runningRun)
         return undefined;
     const actor = input.actor?.trim() || 'user';
@@ -2283,7 +2279,7 @@ function automationToScheduleRecord(automation, state) {
         prompt: automation.prompt,
         cron: automation.rrule,
         type: 'cron',
-        session: automation.session_mode ?? 'isolated',
+        thread: automation.thread_mode ?? 'isolated',
         status: automation.status === 'ACTIVE' ? 'active' : 'paused',
         target_jid: undefined,
         created_by: undefined,
@@ -2310,7 +2306,7 @@ function automationRunToScheduleRun(run) {
         agent_id: run.agent_id,
         prompt: run.prompt,
         status: run.status,
-        session_id: run.session_id,
+        thread_id: run.thread_id,
         task_id: run.task_id,
         result_preview: run.result_preview,
         error: run.error,
@@ -2324,7 +2320,7 @@ export function createScheduleRun(scheduleId, input) {
     const run = createAutomationRun(scheduleId, {
         triggered_at: input.started_at,
         started_at: input.started_at,
-        session_id: input.session_id,
+        thread_id: input.thread_id,
         task_id: input.task_id,
     });
     return automationRunToScheduleRun(run);
@@ -2390,7 +2386,7 @@ export function createSchedule(input) {
         timezone: TIMEZONE,
         status: 'ACTIVE',
         next_run: nextRun,
-        session_mode: input.session ?? 'isolated',
+        thread_mode: input.thread ?? 'isolated',
     });
     const state = getAutomationState(automation.id);
     if (!state) {
@@ -2633,7 +2629,7 @@ export function updateSchedule(id, updates) {
             ? { status: updates.status === 'active' ? 'ACTIVE' : 'PAUSED' }
             : {}),
         next_run: derivedNextRun,
-        ...(updates.session !== undefined ? { session_mode: updates.session } : {}),
+        ...(updates.thread !== undefined ? { thread_mode: updates.thread } : {}),
     });
     if (!automation)
         return undefined;
@@ -2807,47 +2803,47 @@ export function getAllRegisteredProjects() {
     return result;
 }
 // ═══════════════════════════════════════════════════════════════
-// Chat metadata (lightweight — stored in session.json)
+// Chat metadata (lightweight — stored in thread.json)
 // ═══════════════════════════════════════════════════════════════
 export function storeChatMetadata(chatJid, timestamp, name, channel, _isGroup) {
     // For the filesystem approach, chat metadata is implicitly part of
-    // the session. We ensure the session exists.
+    // the thread. We ensure the thread exists.
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return;
-    ensureSession({
+    ensureThread({
         agent_id: resolved.agentId,
-        session_id: resolved.sessionId,
+        thread_id: resolved.threadId,
         channel: channel || 'unknown',
         source_ref: chatJid,
         agent_name: name,
     });
 }
 export function updateChatName(chatJid, name) {
-    // Chat metadata is stored in session.json — update the agent name
+    // Chat metadata is stored in thread.json — update the agent name
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return;
-    const jsonPath = sessionJsonPath(resolved.agentId, resolved.sessionId);
-    const session = readJson(jsonPath);
-    if (session) {
-        session.name = name;
-        session.space_id = session.space_id || DEFAULT_SPACE_ID;
-        session.updated_at = new Date().toISOString();
-        writeJson(jsonPath, session);
+    const jsonPath = threadJsonPath(resolved.agentId, resolved.threadId);
+    const thread = readJson(jsonPath);
+    if (thread) {
+        thread.name = name;
+        thread.space_id = thread.space_id || DEFAULT_SPACE_ID;
+        thread.updated_at = new Date().toISOString();
+        writeJson(jsonPath, thread);
     }
 }
 export function getAllChats() {
-    // Reconstruct from sessions
+    // Reconstruct from threads
     const chats = [];
     for (const agentId of listDirs(AGENTS_DIR)) {
-        const sessions = getSessionsForAgent(agentId);
-        for (const session of sessions) {
+        const threads = getThreadsForAgent(agentId);
+        for (const thread of threads) {
             chats.push({
-                jid: session.source_ref || `web:${agentId}:${session.session_id}`,
+                jid: thread.source_ref || `web:${agentId}:${thread.thread_id}`,
                 name: agentId,
-                last_message_time: session.updated_at,
-                channel: session.channel,
+                last_message_time: thread.updated_at,
+                channel: thread.channel,
                 is_group: 0,
             });
         }
@@ -2861,56 +2857,56 @@ export function setLastGroupSync() {
     setRouterState('__group_sync__', new Date().toISOString());
 }
 // ═══════════════════════════════════════════════════════════════
-// Interaction events (JSONL per session)
+// Interaction events (JSONL per thread)
 // ═══════════════════════════════════════════════════════════════
 export function storeInteractionEvent(event) {
     const resolved = resolveFromChatJid(event.chat_jid);
     if (!resolved)
         return;
-    const eventsPath = path.join(sessionDir(resolved.agentId, resolved.sessionId), 'interaction-events.jsonl');
+    const eventsPath = path.join(threadDir(resolved.agentId, resolved.threadId), 'interaction-events.jsonl');
     appendJsonl(eventsPath, event);
 }
 export function getRecentInteractionEvents(chatJid, limit = 20) {
     const resolved = resolveFromChatJid(chatJid);
     if (!resolved)
         return [];
-    const eventsPath = path.join(resolveSessionDir(resolved.agentId, resolved.sessionId), 'interaction-events.jsonl');
+    const eventsPath = path.join(resolveThreadDir(resolved.agentId, resolved.threadId), 'interaction-events.jsonl');
     return readJsonlTail(eventsPath, limit);
 }
-export function getSessionInteractionEvents(agentId, sessionId, limit = 20) {
-    const eventsPath = path.join(resolveSessionDir(agentId, sessionId), 'interaction-events.jsonl');
+export function getThreadInteractionEvents(agentId, threadId, limit = 20) {
+    const eventsPath = path.join(resolveThreadDir(agentId, threadId), 'interaction-events.jsonl');
     return limit > 0
         ? readJsonlTail(eventsPath, limit)
         : readJsonl(eventsPath);
 }
-export function storeSessionUiEvent(agentId, sessionId, event) {
-    const taskEventPath = taskUiEventsPath(sessionId, event.task_id);
+export function storeThreadUiEvent(agentId, threadId, event) {
+    const taskEventPath = taskUiEventsPath(threadId, event.task_id);
     if (taskEventPath) {
-        writeTaskMetadata(agentId, sessionId, event.task_id);
+        writeTaskMetadata(agentId, threadId, event.task_id);
         appendJsonl(taskEventPath, event);
-        touchSessionActivity(agentId, sessionId, event.timestamp);
+        touchThreadActivity(agentId, threadId, event.timestamp);
         return;
     }
-    const eventsPath = path.join(sessionDir(agentId, sessionId), 'events.jsonl');
+    const eventsPath = path.join(threadDir(agentId, threadId), 'events.jsonl');
     appendJsonl(eventsPath, event);
-    touchSessionActivity(agentId, sessionId, event.timestamp);
+    touchThreadActivity(agentId, threadId, event.timestamp);
 }
-export function getSessionUiEvents(agentId, sessionId, limit = 200) {
+export function getThreadUiEvents(agentId, threadId, limit = 200) {
     const boundedLimit = limit > 0 ? limit : SESSION_UI_EVENT_RECOVERY_LIMIT;
-    const baseDir = resolveSessionDir(agentId, sessionId);
+    const baseDir = resolveThreadDir(agentId, threadId);
     const eventsPath = path.join(baseDir, 'events.jsonl');
-    const taskEvents = listTaskUiEventsForSession(agentId, sessionId, boundedLimit);
+    const taskEvents = listTaskUiEventsForThread(agentId, threadId, boundedLimit);
     if (!fs.existsSync(eventsPath) && taskEvents.length > 0) {
         return taskEvents
             .sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')))
             .slice(-boundedLimit);
     }
-    const sessionEvents = readJsonlTail(eventsPath, boundedLimit);
-    return [...sessionEvents, ...taskEvents]
+    const threadEvents = readJsonlTail(eventsPath, boundedLimit);
+    return [...threadEvents, ...taskEvents]
         .sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')))
         .slice(-boundedLimit);
 }
-export function getSessionUiEventsForTaskIds(agentId, sessionId, taskIds) {
+export function getThreadUiEventsForTaskIds(agentId, threadId, taskIds) {
     const wanted = new Set(Array.from(taskIds)
         .map((taskId) => String(taskId || '').trim())
         .filter(Boolean));
@@ -2919,7 +2915,7 @@ export function getSessionUiEventsForTaskIds(agentId, sessionId, taskIds) {
     const taskScopedEvents = [];
     const missingTaskIds = new Set();
     for (const taskId of wanted) {
-        const taskEventsPathValue = taskUiEventsPath(sessionId, taskId);
+        const taskEventsPathValue = taskUiEventsPath(threadId, taskId);
         if (taskEventsPathValue && fs.existsSync(taskEventsPathValue)) {
             const taskEvents = readJsonlTail(taskEventsPathValue, TASK_UI_EVENT_HISTORY_LIMIT);
             taskScopedEvents.push(...taskEvents);
@@ -2931,16 +2927,16 @@ export function getSessionUiEventsForTaskIds(agentId, sessionId, taskIds) {
     if (missingTaskIds.size === 0) {
         return taskScopedEvents.sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
     }
-    const eventsPath = path.join(resolveSessionDir(agentId, sessionId), 'events.jsonl');
+    const eventsPath = path.join(resolveThreadDir(agentId, threadId), 'events.jsonl');
     const tasksWithStart = new Set();
-    const sessionEvents = readJsonlTailMatchingUntil(eventsPath, (event) => typeof event.task_id === 'string' && missingTaskIds.has(event.task_id), (event) => {
+    const threadEvents = readJsonlTailMatchingUntil(eventsPath, (event) => typeof event.task_id === 'string' && missingTaskIds.has(event.task_id), (event) => {
         if (event.chunk?.type !== 'start' || typeof event.task_id !== 'string') {
             return false;
         }
         tasksWithStart.add(event.task_id);
         return tasksWithStart.size >= missingTaskIds.size;
     });
-    return [...taskScopedEvents, ...sessionEvents].sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
+    return [...taskScopedEvents, ...threadEvents].sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
 }
 // Test-only exports for deterministic helper validation.
 export const __testOnly = {