@agent-link/agent 0.1.208 → 0.1.210

package/dist/connection.js

@@ -3,7 +3,7 @@ import os from 'os';
 import path from 'path';
 import { createRequire } from 'module';
 import { loadRuntimeState, saveRuntimeState, getBrainDataDir, getConversationPermission, setConversationPermission, clearConversationPermission, getOrCreateE2EKey, encodeBase64Url } from './config.js';
-import { handleListDirectory, handleReadFile, handleChangeWorkDir, handleUpdateFile, handleCreateFile, handleCreateDirectory, handleDeleteFile, handleUploadFile, handleUploadFileChunk, handleDownloadFile, handleDownloadChunkAck } from './directory-handlers.js';
+import { handleListDirectory, handleReadFile, handleChangeWorkDir, handleUpdateFile, handleCreateFile, handleCreateDirectory, handleDeleteFile, handleUploadFile, handleUploadFileChunk, handleDownloadFile, handleDownloadChunkAck, validateWorkDir } from './directory-handlers.js';
 import { handleGitStatus, handleGitDiff, handleGitStage, handleGitUnstage, handleGitDiscard, handleGitCommit, handleGitWorktreeList, handleGitStash, handleGitPull, handleGitPush, handleGitDeleteFile, resolveToRepoRoot } from './git-handlers.js';
 import { handleCreateTeam, handleDissolveTeam, handleListTeams, handleGetTeam, handleGetTeamAgentHistory, handleDeleteTeam, handleRenameTeam } from './team-handlers.js';
 import { handleCreateLoop, handleUpdateLoop, handleDeleteLoop, handleListLoops, handleGetLoop, handleRunLoop, handleCancelLoopExecution, handleListLoopExecutions, handleGetLoopExecutionMessages, handleQueryLoopStatus } from './loop-handlers.js';
@@ -20,7 +20,7 @@ import { createTerminalManager } from './terminal.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 import { handleChat as claudeHandleChat, addSendFn, abort as abortClaude, abortAll as abortAllClaude, cancelExecution as claudeCancelExecution, handleBtwQuestion, getConversation, getConversations, clearSessionId, evictByClaudeSessionId, rebindConversation, addOutputObserver, removeOutputObserver, addCloseObserver, removeCloseObserver, setOutputObserver, clearOutputObserver, setCloseObserver, clearCloseObserver, getPendingQuestions, getPendingToolPermissions, addOnSessionStarted, getBackend, AgentRuntime } from './runtime.js';
-import { listAllRecentSessions, getSessionCacheStats } from './history.js';
+import { listAllRecentSessions, getSessionCacheStats, findSessionProjectPath } from './history.js';
 import { searchSessions } from './search-sessions.js';
 import { listMemoryFiles, updateMemoryFile, deleteMemoryFile } from './memory.js';
 import { decodeKey, parseMessage, encryptAndSend, e2eEncrypt, e2eDecrypt, isE2EEncrypted } from './encryption.js';
@@ -34,6 +34,25 @@ const RECONNECT_BASE_DELAY = 1000;
 const RECONNECT_MAX_DELAY = 10_000;
 const HEARTBEAT_INTERVAL = 45_000; // Send ping every 45s (staggered from server's 30s)
 const HEARTBEAT_TIMEOUT = 15_000; // Max wait for pong before declaring dead
+/**
+ * Resolve the workDir for an inbound message. If the message carries a
+ * `conversationId` and the runtime has a per-conv workDir mapped for it,
+ * use that; otherwise fall back to the agent-global `state.workDir`.
+ */
+function resolveWorkDir(msg, st, rt) {
+    const convId = msg?.conversationId;
+    if (typeof convId === 'string' && convId && rt) {
+        const perConv = rt.getConversationWorkDir(convId);
+        if (perConv)
+            return perConv;
+    }
+    return st.workDir;
+}
+function tag(sendFn, convId) {
+    if (!convId)
+        return sendFn;
+    return (m) => sendFn({ ...m, conversationId: convId });
+}
 const state = {
     ws: null,
     sessionId: null,
@@ -401,7 +420,19 @@ export function disconnect() {
     return r ? r.shutdown() : Promise.resolve();
 }
 let sendQueue = Promise.resolve();
+/** Test-only override: when set, send() routes through this fn instead of WebSocket. */
+let testSendOverride = null;
+export function _setTestSendOverride(fn) {
+    testSendOverride = fn;
+}
 export function send(msg) {
+    if (testSendOverride) {
+        try {
+            testSendOverride(msg);
+        }
+        catch { /* swallow in tests */ }
+        return;
+    }
     if (state.ws && state.ws.readyState === WebSocket.OPEN) {
         sendQueue = sendQueue.then(async () => {
             if (!state.ws || state.ws.readyState !== WebSocket.OPEN)
@@ -440,7 +471,9 @@ function buildWsUrl(config) {
         name: config.name,
         workDir: state.workDir,
         hostname: os.hostname(),
-        version: pkg.version,
+        // E2E test hook: AGENTLINK_FAKE_VERSION lets tc_75 pin an old version
+        // so the web's MIN_AGENT_VERSION_PER_CONV_WORKDIR gate triggers fallback.
+        version: process.env.AGENTLINK_FAKE_VERSION || pkg.version,
     });
     // On reconnect, send previous sessionId so the URL stays valid
     if (state.sessionId) {
@@ -482,6 +515,21 @@ const BRAIN_SERVER = 'http://localhost:8001';
 // Pending action item IDs: conversationId → actionItemId
 // Used to link a chat's Claude session to an action item for CLI start
 const pendingActionItems = new Map();
+/** Test-only: invoke the dispatch directly. */
+export function _handleServerMessageForTests(msg) {
+    handleServerMessage(msg);
+}
+/** Test-only: read/write the connection-level workDir state. */
+export function _setStateWorkDirForTests(wd) {
+    state.workDir = wd;
+}
+export function _getStateWorkDirForTests() {
+    return state.workDir;
+}
+/** Test-only: install a runtime instance (bypasses connect()). */
+export function _setRuntimeForTests(rt) {
+    runtime = rt;
+}
 function handleServerMessage(msg) {
     console.log(`[AgentLink] ← ${msg.type}`);
     switch (msg.type) {
@@ -552,7 +600,7 @@ function handleServerMessage(msg) {
             const chatDir = explicitWorkDir
                 ?? existingConv?.workDir
                 ?? ((recapId || briefingDate || devopsEntityType || projectName || icmId) ? BRAIN_DATA_DIR : null)
-                ?? state.workDir;
+                ?? resolveWorkDir(msg, state, runtime);
             // Track actionItemId for linking to Claude session on session_started
             if (actionItemId && chatConvId) {
                 pendingActionItems.set(chatConvId, actionItemId);
@@ -573,6 +621,9 @@ function handleServerMessage(msg) {
                 console.warn('[AgentLink] chat received after runtime shutdown — ignoring');
                 break;
             }
+            // Seed per-conv workDir map so subsequent resolveWorkDir calls for this
+            // conversation see the same dir (no eviction — this is the active turn).
+            runtime.setConversationWorkDir(startConvId, chatDir);
             runtime.startTurn(startConvId, {
                 text: msg.prompt,
                 files: msg.files,
@@ -594,12 +645,18 @@ function handleServerMessage(msg) {
             });
             break;
         }
-        case 'list_sessions':
-            handleListSessions().catch((err) => {
+        case 'list_sessions': {
+            const m = msg;
+            const wd = resolveWorkDir(msg, state, runtime);
+            handleListSessions(wd, m.conversationId).catch((err) => {
                 console.error('[AgentLink] handleListSessions failed:', err);
-                send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+                const out = { type: 'sessions_list', sessions: [], workDir: wd };
+                if (m.conversationId)
+                    out.conversationId = m.conversationId;
+                send(out);
             });
             break;
+        }
         case 'list_recent_sessions':
             handleListRecentSessions(msg);
             break;
@@ -609,56 +666,102 @@ function handleServerMessage(msg) {
         case 'cancel_search':
             handleCancelSearch(msg);
             break;
-        case 'list_directory':
-            handleListDirectory(msg, state.workDir, send);
+        case 'list_directory': {
+            const m = msg;
+            handleListDirectory(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'read_file':
-            handleReadFile(msg, state.workDir, send);
+        }
+        case 'read_file': {
+            const m = msg;
+            handleReadFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_read_file':
-            resolveToRepoRoot(msg, state.workDir)
+        }
+        case 'git_read_file': {
+            const m = msg;
+            const tagged = tag(send, m.conversationId);
+            resolveToRepoRoot(m, resolveWorkDir(msg, state, runtime))
                 .then((repoRoot) => {
-                const filePath = msg.filePath;
+                const filePath = m.filePath;
                 // Security: reject absolute paths and .. traversal
                 if (path.isAbsolute(filePath) || filePath.includes('..')) {
-                    send({ type: 'file_content', filePath, error: 'Invalid file path' });
+                    tagged({ type: 'file_content', filePath, error: 'Invalid file path' });
                     return;
                 }
                 const resolved = path.resolve(repoRoot, filePath);
                 if (!resolved.startsWith(repoRoot)) {
-                    send({ type: 'file_content', filePath, error: 'Invalid file path' });
+                    tagged({ type: 'file_content', filePath, error: 'Invalid file path' });
                     return;
                 }
-                handleReadFile({ filePath }, repoRoot, send);
+                handleReadFile({ filePath }, repoRoot, tagged);
             });
             break;
-        case 'update_file':
-            handleUpdateFile(msg, state.workDir, send);
+        }
+        case 'update_file': {
+            const m = msg;
+            handleUpdateFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'create_file':
-            handleCreateFile(msg, state.workDir, send);
+        }
+        case 'create_file': {
+            const m = msg;
+            handleCreateFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'create_directory':
-            handleCreateDirectory(msg, state.workDir, send);
+        }
+        case 'create_directory': {
+            const m = msg;
+            handleCreateDirectory(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'delete_file':
-            handleDeleteFile(msg, state.workDir, send);
+        }
+        case 'delete_file': {
+            const m = msg;
+            handleDeleteFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'upload_file':
-            handleUploadFile(msg, state.workDir, send);
+        }
+        case 'upload_file': {
+            const m = msg;
+            handleUploadFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'upload_file_chunk':
-            handleUploadFileChunk(msg, state.workDir, send);
+        }
+        case 'upload_file_chunk': {
+            const m = msg;
+            handleUploadFileChunk(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'download_file':
-            handleDownloadFile(msg, state.workDir, send);
+        }
+        case 'download_file': {
+            const m = msg;
+            handleDownloadFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'download_chunk_ack':
             handleDownloadChunkAck(msg);
             break;
         case 'change_workdir':
-            handleChangeWorkDir(msg, state, send, handleListSessions);
+            handleChangeWorkDir(msg, state, send, () => {
+                handleListSessions(state.workDir).catch((err) => {
+                    console.error('[AgentLink] handleListSessions failed:', err);
+                    send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+                });
+            });
+            break;
+        case 'set_conversation_workdir': {
+            const m = msg;
+            const convId = m.conversationId;
+            if (typeof convId !== 'string' || !convId) {
+                send({ type: 'error', message: 'set_conversation_workdir requires conversationId' });
+                break;
+            }
+            const v = validateWorkDir(m.workDir);
+            if (!v.ok) {
+                send({ type: 'error', conversationId: convId, message: v.error });
+                break;
+            }
+            runtime?.setConversationWorkDir(convId, v.resolved, { evictSession: true });
+            // Also update the global default so NEW conversations (with a fresh
+            // convId that has no per-conv mapping) inherit the user's latest
+            // directory choice instead of falling back to the agent startup dir.
+            state.workDir = v.resolved;
+            send({ type: 'conversation_workdir_changed', conversationId: convId, workDir: v.resolved });
             break;
+        }
         case 'new_conversation':
             // Backward compat: old web client sends this to reset the single conversation
             abortClaude();
@@ -689,10 +792,18 @@ function handleServerMessage(msg) {
             // making the entire switch dispatch async. .catch() ensures backend
             // rejections don't become unhandled promise rejections.
             (async () => {
-                // Try current workDir first; fall back to BRAIN_DATA_DIR for recap/briefing chat sessions
-                let resolvedWorkDir = state.workDir;
+                // Try current workDir first; fall back to BRAIN_DATA_DIR for recap/briefing chat sessions.
+                // Use resolveWorkDir so per-conv workdir is honored when the web client tags the
+                // resume_conversation message with conversationId (see outboundTag.js).
+                const initialWorkDir = resolveWorkDir(msg, state, runtime);
+                // Deeplink fix: when the web client opens a URL like #/chat/<sessionId>
+                // in a fresh tab, it has no projectPath context, so resolveWorkDir
+                // returns the agent's startup workDir — which may be wrong for this
+                // session. Prefer the authoritative `cwd` recorded in the JSONL itself.
+                const jsonlCwd = await findSessionProjectPath(m.claudeSessionId);
+                let resolvedWorkDir = jsonlCwd || initialWorkDir;
                 let history = runtime
-                    ? await runtime.readHistory(state.workDir, m.claudeSessionId)
+                    ? await runtime.readHistory(resolvedWorkDir, m.claudeSessionId)
                     : [];
                 if (history.length === 0) {
                     const sessionMeta_ = loadSessionMetadata(m.claudeSessionId);
@@ -753,8 +864,13 @@ function handleServerMessage(msg) {
                 // process's own session id).
                 const seedCid = convId ?? 'default';
                 const seedConv = currentConv;
-                if (!seedConv?.turnActive) {
-                    runtime?.ensureConversation(seedCid, {
+                if (!seedConv?.turnActive && runtime) {
+                    // Await so per-conv workDir is set BEFORE we send conversation_resumed.
+                    // The web client re-requests list_sessions immediately after receiving
+                    // conversation_resumed (when workDir changed), and list_sessions uses
+                    // resolveWorkDir which reads from this per-conv map. Without awaiting,
+                    // the map is still empty and resolveWorkDir falls back to startup dir.
+                    await runtime.ensureConversation(seedCid, {
                         workDir: resolvedWorkDir,
                         resumeSessionId: m.claudeSessionId,
                     }).catch(() => { });
@@ -763,6 +879,7 @@ function handleServerMessage(msg) {
                     type: 'conversation_resumed',
                     conversationId: convId,
                     claudeSessionId: m.claudeSessionId,
+                    workDir: resolvedWorkDir,
                     history,
                     isCompacting: isSameSession && (runtime?.isCompacting(convId) ?? false),
                     isProcessing: isSameSession && currentConv?.turnActive === true,
@@ -814,17 +931,23 @@ function handleServerMessage(msg) {
         }
         case 'delete_session': {
             const m = msg;
-            handleDeleteSession(m.sessionId).catch((err) => {
+            handleDeleteSession(m.sessionId, resolveWorkDir(msg, state, runtime), m.conversationId).catch((err) => {
                 console.error('[AgentLink] handleDeleteSession failed:', err);
-                send({ type: 'error', message: 'Session not found or could not be deleted.' });
+                const out = { type: 'error', message: 'Session not found or could not be deleted.' };
+                if (m.conversationId)
+                    out.conversationId = m.conversationId;
+                send(out);
             });
             break;
         }
         case 'rename_session': {
             const m = msg;
-            handleRenameSession(m.sessionId, m.newTitle).catch((err) => {
+            handleRenameSession(m.sessionId, m.newTitle, resolveWorkDir(msg, state, runtime), m.conversationId).catch((err) => {
                 console.error('[AgentLink] handleRenameSession failed:', err);
-                send({ type: 'error', message: 'Session not found or could not be renamed.' });
+                const out = { type: 'error', message: 'Session not found or could not be renamed.' };
+                if (m.conversationId)
+                    out.conversationId = m.conversationId;
+                send(out);
             });
             break;
         }
@@ -865,15 +988,19 @@ function handleServerMessage(msg) {
             });
             break;
         }
-        case 'create_team':
-            handleCreateTeam(msg, state.workDir, send);
+        case 'create_team': {
+            const m = msg;
+            handleCreateTeam(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'dissolve_team':
             handleDissolveTeam();
             break;
-        case 'list_teams':
-            handleListTeams(state.workDir, send);
+        case 'list_teams': {
+            const m = msg;
+            handleListTeams(resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'get_team':
             handleGetTeam(msg, send);
             break;
@@ -887,18 +1014,22 @@ function handleServerMessage(msg) {
             handleRenameTeam(msg, send);
             break;
         // ── Loop (Scheduled Tasks) handlers ────────────────────────────────
-        case 'create_loop':
-            handleCreateLoop(msg, state.workDir, send);
+        case 'create_loop': {
+            const m = msg;
+            handleCreateLoop(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'update_loop':
             handleUpdateLoop(msg, send);
             break;
         case 'delete_loop':
             handleDeleteLoop(msg, send);
             break;
-        case 'list_loops':
-            handleListLoops(msg.showAll ? undefined : state.workDir, send);
+        case 'list_loops': {
+            const m = msg;
+            handleListLoops(m.showAll ? undefined : resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'get_loop':
             handleGetLoop(msg, send);
             break;
@@ -921,25 +1052,26 @@ function handleServerMessage(msg) {
             send({ type: 'pong', ts: msg.ts });
             break;
         case 'list_memory': {
-            const result = listMemoryFiles(state.workDir);
-            send({ type: 'memory_list', memoryDir: result.memoryDir, files: result.files });
+            const m = msg;
+            const result = listMemoryFiles(resolveWorkDir(msg, state, runtime));
+            tag(send, m.conversationId)({ type: 'memory_list', memoryDir: result.memoryDir, files: result.files });
             break;
         }
         case 'update_memory': {
-            const { filename, content } = msg;
-            const result = updateMemoryFile(state.workDir, filename, content);
-            send({ type: 'memory_updated', filename, ...result });
+            const { filename, content, conversationId } = msg;
+            const result = updateMemoryFile(resolveWorkDir(msg, state, runtime), filename, content);
+            tag(send, conversationId)({ type: 'memory_updated', filename, ...result });
             break;
         }
         case 'delete_memory': {
-            const { filename } = msg;
-            const result = deleteMemoryFile(state.workDir, filename);
-            send({ type: 'memory_deleted', filename, ...result });
+            const { filename, conversationId } = msg;
+            const result = deleteMemoryFile(resolveWorkDir(msg, state, runtime), filename);
+            tag(send, conversationId)({ type: 'memory_deleted', filename, ...result });
             break;
         }
         case 'btw_question': {
             const { question, conversationId, claudeSessionId } = msg;
-            handleBtwQuestion(question, conversationId, state.workDir, send, claudeSessionId);
+            handleBtwQuestion(question, conversationId, resolveWorkDir(msg, state, runtime), tag(send, conversationId), claudeSessionId);
             break;
         }
         case 'set_model': {
@@ -963,7 +1095,7 @@ function handleServerMessage(msg) {
             const { enabled, conversationId } = msg;
             console.log(`[AgentLink] set_plan_mode: enabled=${enabled}, conversationId=${conversationId}`);
             const convId = conversationId ?? 'default';
-            const result = runtime?.setPlanMode(convId, enabled, state.workDir) ?? null;
+            const result = runtime?.setPlanMode(convId, enabled, resolveWorkDir(msg, state, runtime)) ?? null;
             if (result?.wasTurnActive) {
                 send({ type: 'execution_cancelled', conversationId });
             }
@@ -974,7 +1106,7 @@ function handleServerMessage(msg) {
             const { mode, conversationId } = msg;
             console.log(`[AgentLink] set_permission_mode: mode=${mode}, conversationId=${conversationId}`);
             const convId = conversationId ?? 'default';
-            const result = runtime?.setPermissionMode(convId, mode, state.workDir) ?? null;
+            const result = runtime?.setPermissionMode(convId, mode, resolveWorkDir(msg, state, runtime)) ?? null;
             if (result?.wasTurnActive) {
                 send({ type: 'execution_cancelled', conversationId });
             }
@@ -1004,46 +1136,68 @@ function handleServerMessage(msg) {
             const { enabled, conversationId } = msg;
             console.log(`[AgentLink] set_brain_mode: enabled=${enabled}, conversationId=${conversationId}`);
             const convId = conversationId ?? 'default';
-            const result = runtime?.setBrainMode(convId, enabled, state.workDir) ?? null;
+            const result = runtime?.setBrainMode(convId, enabled, resolveWorkDir(msg, state, runtime)) ?? null;
             if (result?.wasTurnActive) {
                 send({ type: 'execution_cancelled', conversationId });
             }
             send({ type: 'brain_mode_changed', enabled, conversationId });
             break;
         }
-        case 'git_worktree_list':
-            handleGitWorktreeList(msg, state.workDir, send);
+        case 'git_worktree_list': {
+            const m = msg;
+            handleGitWorktreeList(msg, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_status':
-            handleGitStatus(msg, state.workDir, send);
+        }
+        case 'git_status': {
+            const m = msg;
+            handleGitStatus(msg, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_diff':
-            handleGitDiff(msg, state.workDir, send);
+        }
+        case 'git_diff': {
+            const m = msg;
+            handleGitDiff(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_stage':
-            handleGitStage(msg, state.workDir, send);
+        }
+        case 'git_stage': {
+            const m = msg;
+            handleGitStage(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_unstage':
-            handleGitUnstage(msg, state.workDir, send);
+        }
+        case 'git_unstage': {
+            const m = msg;
+            handleGitUnstage(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_discard':
-            handleGitDiscard(msg, state.workDir, send);
+        }
+        case 'git_discard': {
+            const m = msg;
+            handleGitDiscard(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_commit':
-            handleGitCommit(msg, state.workDir, send);
+        }
+        case 'git_commit': {
+            const m = msg;
+            handleGitCommit(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_stash':
-            handleGitStash(msg, state.workDir, send);
+        }
+        case 'git_stash': {
+            const m = msg;
+            handleGitStash(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_pull':
-            handleGitPull(msg, state.workDir, send);
+        }
+        case 'git_pull': {
+            const m = msg;
+            handleGitPull(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_push':
-            handleGitPush(msg, state.workDir, send);
+        }
+        case 'git_push': {
+            const m = msg;
+            handleGitPush(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
-        case 'git_delete_file':
-            handleGitDeleteFile(msg, state.workDir, send);
+        }
+        case 'git_delete_file': {
+            const m = msg;
+            handleGitDeleteFile(m, resolveWorkDir(msg, state, runtime), tag(send, m.conversationId));
             break;
+        }
         case 'list_recaps':
             handleListRecaps();
             break;
@@ -1139,7 +1293,7 @@ function handleServerMessage(msg) {
         // ── Terminal handlers ──────────────────────────────────────────────
         case 'terminal_open':
             if (terminalManager)
-                terminalManager.open(msg.cols, msg.rows, state.workDir);
+                terminalManager.open(msg.cols, msg.rows, resolveWorkDir(msg, state, runtime));
             break;
         case 'terminal_input':
             if (terminalManager)
@@ -1404,21 +1558,30 @@ async function handleBrainChatDeleteSession(msg) {
         send({ type: 'brainchat_error', message: String(err) });
     }
 }
-async function handleListSessions() {
+async function handleListSessions(resolvedWorkDir, conversationId) {
+    const reply = (m) => {
+        if (conversationId)
+            m.conversationId = conversationId;
+        send(m);
+    };
     try {
         if (!runtime) {
-            send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+            reply({ type: 'sessions_list', sessions: [], workDir: resolvedWorkDir });
             return;
         }
         // PR4-D: runtime.listHistory returns BackendSessionInfo rows; map to the
         // flat wire shape connection.ts has always sent ({sessionId, title, ...}).
-        const rows = await runtime.listHistory(state.workDir);
+        const rows = await runtime.listHistory(resolvedWorkDir);
         const sessions = rows.map(r => ({
             sessionId: r.session.backendSessionId,
             title: r.title,
             customTitle: r.customTitle,
             preview: r.preview,
             lastModified: r.lastModified,
+            // PROJECT PATH: tag each session with the workdir its JSONL lives under,
+            // so the web client can `set_conversation_workdir` before resuming
+            // (otherwise per-conv resume reads the wrong directory). See sidebar.js.
+            projectPath: resolvedWorkDir,
         }));
         const metaMap = loadAllSessionMetadata();
         const enriched = sessions.map(s => ({
@@ -1426,7 +1589,7 @@ async function handleListSessions() {
             ...metaMap.get(s.sessionId),
         }));
         // Always merge recap/briefing/devops chat sessions from BrainData directory — they live under a
-        // different Claude project folder, so listHistory(state.workDir) misses them.
+        // different Claude project folder, so listHistory(resolvedWorkDir) misses them.
         // These sessions should be visible regardless of the current workDir.
         const brainRows = await runtime.listHistory(BRAIN_DATA_DIR);
         const brainSessions = brainRows.map(r => ({
@@ -1435,6 +1598,7 @@ async function handleListSessions() {
             customTitle: r.customTitle,
             preview: r.preview,
             lastModified: r.lastModified,
+            projectPath: BRAIN_DATA_DIR,
         }));
         const existingIds = new Set(enriched.map(s => s.sessionId));
         for (const bs of brainSessions) {
@@ -1446,12 +1610,12 @@ async function handleListSessions() {
             }
         }
         const cs = getSessionCacheStats();
-        console.log(`[AgentLink] → sessions_list (${enriched.length} sessions for ${state.workDir}) cache size=${cs.size} hits=${cs.hits} misses=${cs.misses} stale=${cs.staleMisses} ttlSkips=${cs.ttlSkips} evictions=${cs.evictions}`);
-        send({ type: 'sessions_list', sessions: enriched, workDir: state.workDir });
+        console.log(`[AgentLink] → sessions_list (${enriched.length} sessions for ${resolvedWorkDir}) cache size=${cs.size} hits=${cs.hits} misses=${cs.misses} stale=${cs.staleMisses} ttlSkips=${cs.ttlSkips} evictions=${cs.evictions}`);
+        reply({ type: 'sessions_list', sessions: enriched, workDir: resolvedWorkDir });
     }
     catch (err) {
         console.error(`[AgentLink] listSessions failed:`, err);
-        send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+        reply({ type: 'sessions_list', sessions: [], workDir: resolvedWorkDir });
     }
 }
 async function handleListRecentSessions(msg) {
@@ -1472,9 +1636,11 @@ async function handleListRecentSessions(msg) {
 // echoing the searchId.
 const searchControllers = new Map();
 function handleSearchSessions(msg) {
-    const { searchId, query, limit } = msg;
+    const { searchId, query, limit, conversationId } = msg;
     if (!searchId)
         return;
+    const tagged = tag(send, conversationId);
+    const resolvedWorkDir = resolveWorkDir(msg, state, runtime);
     // Abort any prior in-flight search (only one at a time).
     for (const [id, ctrl] of searchControllers) {
         ctrl.abort();
@@ -1490,11 +1656,11 @@ function handleSearchSessions(msg) {
             return;
         }
         try {
-            const result = searchSessions(state.workDir, query, { limit, signal: controller.signal });
+            const result = searchSessions(resolvedWorkDir, query, { limit, signal: controller.signal });
             if (controller.signal.aborted)
                 return;
             console.log(`[AgentLink] → session_search_results (q="${query}" hits=${result.results.reduce((s, r) => s + r.hits.length, 0)} scanned=${result.scannedFiles} matched=${result.matchedFiles} ${result.durationMs}ms)`);
-            send({
+            tagged({
                 type: 'session_search_results',
                 searchId,
                 ...result,
@@ -1502,7 +1668,7 @@ function handleSearchSessions(msg) {
         }
         catch (err) {
             console.error('[AgentLink] searchSessions failed:', err);
-            send({
+            tagged({
                 type: 'session_search_error',
                 searchId,
                 message: String(err),
@@ -1520,18 +1686,19 @@ function handleCancelSearch(msg) {
         searchControllers.delete(msg.searchId);
     }
 }
-async function handleDeleteSession(sessionId) {
+async function handleDeleteSession(sessionId, resolvedWorkDir, conversationId) {
+    const reply = tag(send, conversationId);
     // Evict any idle conversation holding this session; block if busy
     if (evictByClaudeSessionId(sessionId)) {
-        send({ type: 'error', message: 'Cannot delete a session while it is processing.' });
+        reply({ type: 'error', message: 'Cannot delete a session while it is processing.' });
         return;
     }
     if (!runtime) {
-        send({ type: 'error', message: 'Session not found or could not be deleted.' });
+        reply({ type: 'error', message: 'Session not found or could not be deleted.' });
         return;
     }
     // Try current workDir first; if not found, check if it's a recap/briefing/devops/project session in BrainData
-    let deleted = await runtime.deleteHistorySession(state.workDir, sessionId);
+    let deleted = await runtime.deleteHistorySession(resolvedWorkDir, sessionId);
     if (!deleted) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
@@ -1540,19 +1707,20 @@ async function handleDeleteSession(sessionId) {
     }
     if (deleted) {
         deleteSessionMetadata(sessionId);
-        send({ type: 'session_deleted', sessionId });
+        reply({ type: 'session_deleted', sessionId });
     }
     else {
-        send({ type: 'error', message: 'Session not found or could not be deleted.' });
+        reply({ type: 'error', message: 'Session not found or could not be deleted.' });
     }
 }
-async function handleRenameSession(sessionId, newTitle) {
+async function handleRenameSession(sessionId, newTitle, resolvedWorkDir, conversationId) {
+    const reply = tag(send, conversationId);
     if (!runtime) {
-        send({ type: 'error', message: 'Session not found or could not be renamed.' });
+        reply({ type: 'error', message: 'Session not found or could not be renamed.' });
         return;
     }
     // Try current workDir first; if not found, check if it's a recap/briefing/devops/project session in BrainData
-    let renamed = await runtime.renameHistorySession(state.workDir, sessionId, newTitle);
+    let renamed = await runtime.renameHistorySession(resolvedWorkDir, sessionId, newTitle);
     if (!renamed) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
@@ -1560,25 +1728,25 @@ async function handleRenameSession(sessionId, newTitle) {
         }
     }
     if (renamed) {
-        send({ type: 'session_renamed', sessionId, newTitle });
+        reply({ type: 'session_renamed', sessionId, newTitle });
     }
     else {
         // Session file may not exist on disk yet (e.g. IcM/project chat still streaming first response).
         // Retry once after a short delay; if it still fails, send an error so the UI can recover.
         setTimeout(() => {
             (async () => {
-                const retried = (await runtime.renameHistorySession(state.workDir, sessionId, newTitle))
+                const retried = (await runtime.renameHistorySession(resolvedWorkDir, sessionId, newTitle))
                     || (await runtime.renameHistorySession(BRAIN_DATA_DIR, sessionId, newTitle));
                 if (retried) {
-                    send({ type: 'session_renamed', sessionId, newTitle });
+                    reply({ type: 'session_renamed', sessionId, newTitle });
                 }
                 else {
                     console.warn(`[AgentLink] rename_session: session ${sessionId.slice(0, 8)} not found after retry`);
-                    send({ type: 'error', message: 'Session not found or could not be renamed.' });
+                    reply({ type: 'error', message: 'Session not found or could not be renamed.' });
                 }
             })().catch((err) => {
                 console.error('[AgentLink] rename_session retry failed:', err);
-                send({ type: 'error', message: 'Session not found or could not be renamed.' });
+                reply({ type: 'error', message: 'Session not found or could not be renamed.' });
             });
         }, 1500);
     }