@agent-link/agent 0.1.202 → 0.1.206

package/dist/connection.js

@@ -19,8 +19,9 @@ import { createTunnelHandler } from './tunnel.js';
 import { createTerminalManager } from './terminal.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
-import { handleChat as claudeHandleChat, setSendFn, abort as abortClaude, abortAll as abortAllClaude, cancelExecution as claudeCancelExecution, handleUserAnswer, handleToolPermissionResponse, handleBtwQuestion, getConversation, getConversations, getIsCompacting, clearSessionId, evictByClaudeSessionId, rebindConversation, addOutputObserver, removeOutputObserver, addCloseObserver, removeCloseObserver, setOutputObserver, clearOutputObserver, setCloseObserver, clearCloseObserver, restartConversation, createPlaceholderConversation, getPendingQuestions, getPendingToolPermissions, setModel, setOnSessionStarted } from './claude.js';
-import { listSessions, readSessionMessages, deleteSession, renameSession, listAllRecentSessions, getSessionCacheStats } from './history.js';
+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 { searchSessions } from './search-sessions.js';
 import { listMemoryFiles, updateMemoryFile, deleteMemoryFile } from './memory.js';
 import { decodeKey, parseMessage, encryptAndSend, e2eEncrypt, e2eDecrypt, isE2EEncrypted } from './encryption.js';
 import { setTeamSendFn, setTeamClaudeFns, getActiveTeam, serializeTeam } from './team.js';
@@ -45,6 +46,15 @@ const state = {
     config: null,
     entraToken: null,
 };
+let unsubscribeSend = null;
+let unsubscribeSessionStarted = null;
+/** PR4-B: connection-owned AgentRuntime. Shares the backend with the
+ *  process-wide getBackend() singleton until PR-W1 deletes the singleton. */
+let runtime = null;
+/** Test-only accessor for the active runtime instance. */
+export function _getRuntimeForTests() {
+    return runtime;
+}
 let heartbeatInterval = null;
 let heartbeatTimeout = null;
 // Wire Entra timer module to this connection's state and send fn.
@@ -68,6 +78,14 @@ export function connect(config) {
     state.workDir = config.dir;
     state.config = config;
     state.shouldReconnect = true;
+    // PR4-B: construct the connection-owned runtime. Pass getBackend() (NOT
+    // createBackend()) so this runtime and the still-existing module singleton
+    // share one ClaudeBackend instance — otherwise the addSendFn /
+    // addOnSessionStarted re-exports below and the runtime would each register
+    // on different backend instances and fan out events twice. PR-W1 deletes
+    // getBackend(); at that point the runtime owns the backend exclusively.
+    runtime = new AgentRuntime(getBackend());
+    runtime.start();
     // Initialize E2E encryption key
     const ignoreConfig = !!process.env.AGENTLINK_NO_STATE;
     state.e2eKey = getOrCreateE2EKey(ignoreConfig);
@@ -77,10 +95,24 @@ export function connect(config) {
         state.sessionId = prev.sessionId;
         console.log(`[AgentLink] Restoring session: ${prev.sessionId}`);
     }
-    // Wire up the Claude module to send messages through our WebSocket
-    setSendFn(send);
+    // Wire up the Claude module to send messages through our WebSocket.
+    // Use additive subscribers so the ClaudeBackend adapter (PR3+) can coexist;
+    // capture unsubscribes so disconnect() can detach without leaks.
+    if (unsubscribeSend) {
+        try {
+            unsubscribeSend();
+        }
+        catch { /* ignore */ }
+    }
+    unsubscribeSend = addSendFn(send);
     // Wire up action item session linkage
-    setOnSessionStarted(checkPendingActionItem);
+    if (unsubscribeSessionStarted) {
+        try {
+            unsubscribeSessionStarted();
+        }
+        catch { /* ignore */ }
+    }
+    unsubscribeSessionStarted = addOnSessionStarted(checkPendingActionItem);
     // Initialize the tunnel handler for port proxy
     tunnelHandler = createTunnelHandler(send);
     // Initialize the terminal manager for web terminal
@@ -338,6 +370,20 @@ export function disconnect() {
     stopEntraRetryTimer();
     cancelEntraRefresh();
     abortAllClaude();
+    if (unsubscribeSend) {
+        try {
+            unsubscribeSend();
+        }
+        catch { /* ignore */ }
+        unsubscribeSend = null;
+    }
+    if (unsubscribeSessionStarted) {
+        try {
+            unsubscribeSessionStarted();
+        }
+        catch { /* ignore */ }
+        unsubscribeSessionStarted = null;
+    }
     if (tunnelHandler)
         tunnelHandler.cleanup();
     if (terminalManager)
@@ -346,6 +392,13 @@ export function disconnect() {
         state.ws.close();
         state.ws = null;
     }
+    // PR4-B: tear down the connection-owned runtime. Awaited here so any future
+    // backend (e.g. Codex) can do real async cleanup; the SIGINT/SIGTERM path
+    // in index.ts uses shutdownSyncBestEffort() instead because it
+    // process.exit(0)s immediately and cannot await.
+    const r = runtime;
+    runtime = null;
+    return r ? r.shutdown() : Promise.resolve();
 }
 let sendQueue = Promise.resolve();
 export function send(msg) {
@@ -404,6 +457,9 @@ function buildWsUrl(config) {
     if (config.entra) {
         params.set('entra', '1');
     }
+    // Forward selected backend so the server can route accordingly. Default
+    // 'claude' makes this a no-op for existing servers that ignore the param.
+    params.set('backendType', config.agent ?? 'claude');
     return `${base}/?${params}`;
 }
 function scheduleReconnect(config) {
@@ -498,18 +554,58 @@ function handleServerMessage(msg) {
             if (actionItemId && chatConvId) {
                 pendingActionItems.set(chatConvId, actionItemId);
             }
-            claudeHandleChat(chatConvId, msg.prompt, chatDir, chatOptions, msg.files);
+            // PR4-B: route through AgentRuntime. ClaudeBackend forwards `metadata`
+            // (brainMode/recapId/briefingDate/devops*/projectName/icmId) as
+            // HandleChatOptions to claude.handleChat. .catch() so any rejection
+            // from ensureSession/backend.startTurn is logged rather than becoming
+            // an unhandled rejection (Codex review #1, high). handleServerMessage
+            // is sync, so we can't await; the caller in ws.on('message') has its
+            // own try/catch but it would miss async rejections from this call.
+            // Use 'default' as the conv key when missing — matches claude.ts's
+            // DEFAULT_CONVERSATION_ID so the runtime map and backend's internal
+            // map agree. Empty string would create a divergent mapping (Copilot
+            // round 1).
+            const startConvId = chatConvId ?? 'default';
+            if (!runtime) {
+                console.warn('[AgentLink] chat received after runtime shutdown — ignoring');
+                break;
+            }
+            runtime.startTurn(startConvId, {
+                text: msg.prompt,
+                files: msg.files,
+                metadata: chatOptions,
+            }, { workDir: chatDir, resumeSessionId: chatOptions.resumeSessionId }).catch((err) => {
+                console.error('[AgentLink] runtime.startTurn failed:', err.message);
+            });
             break;
         }
-        case 'cancel_execution':
-            claudeCancelExecution(msg.conversationId);
+        case 'cancel_execution': {
+            const cancelConvId = msg.conversationId;
+            // 'default' default matches claude.ts (Copilot round 1).
+            if (!runtime) {
+                console.warn('[AgentLink] cancel received after runtime shutdown — ignoring');
+                break;
+            }
+            runtime.interruptTurn(cancelConvId ?? 'default').catch((err) => {
+                console.error('[AgentLink] runtime.interruptTurn failed:', err.message);
+            });
             break;
+        }
         case 'list_sessions':
-            handleListSessions();
+            handleListSessions().catch((err) => {
+                console.error('[AgentLink] handleListSessions failed:', err);
+                send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+            });
             break;
         case 'list_recent_sessions':
             handleListRecentSessions(msg);
             break;
+        case 'search_sessions':
+            handleSearchSessions(msg);
+            break;
+        case 'cancel_search':
+            handleCancelSearch(msg);
+            break;
         case 'list_directory':
             handleListDirectory(msg, state.workDir, send);
             break;
@@ -564,6 +660,10 @@ function handleServerMessage(msg) {
             // Backward compat: old web client sends this to reset the single conversation
             abortClaude();
             clearSessionId('default');
+            // Evict the runtime's cached ref so the next chat re-ensures (otherwise
+            // ClaudeBackend would compute resumeSessionId from the stale ref and
+            // resume the just-cleared session). Copilot round 3 fix.
+            runtime?.evictConversation('default');
             console.log('[AgentLink] New conversation — session cleared');
             break;
         case 'resume_conversation': {
@@ -581,85 +681,123 @@ function handleServerMessage(msg) {
                 // (handles page refresh where web client generates a new UUID)
                 rebindConversation(m.claudeSessionId, convId);
             }
-            // Try current workDir first; fall back to BRAIN_DATA_DIR for recap/briefing chat sessions
-            let history = readSessionMessages(state.workDir, m.claudeSessionId);
-            if (history.length === 0) {
-                const sessionMeta_ = loadSessionMetadata(m.claudeSessionId);
-                if (sessionMeta_.recapId || sessionMeta_.briefingDate || sessionMeta_.devopsEntityType || sessionMeta_.projectName || sessionMeta_.icmId) {
-                    history = readSessionMessages(BRAIN_DATA_DIR, m.claudeSessionId);
+            // History reads went async in PR4-D (runtime.readHistory is async).
+            // Wrap the rest of the handler in an async IIFE so we can await without
+            // 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 history = runtime
+                    ? await runtime.readHistory(state.workDir, m.claudeSessionId)
+                    : [];
+                if (history.length === 0) {
+                    const sessionMeta_ = loadSessionMetadata(m.claudeSessionId);
+                    if (sessionMeta_.recapId || sessionMeta_.briefingDate || sessionMeta_.devopsEntityType || sessionMeta_.projectName || sessionMeta_.icmId) {
+                        history = runtime
+                            ? await runtime.readHistory(BRAIN_DATA_DIR, m.claudeSessionId)
+                            : [];
+                    }
                 }
-            }
-            console.log(`[AgentLink] → conversation_resumed (${history.length} messages, session ${m.claudeSessionId.slice(0, 8)})`);
-            // Include live status so the web client can restore compacting/processing state
-            // In multi-session mode, look up by conversationId; in single-session mode, use default
-            const currentConv = convId ? getConversation(convId) : getConversation();
-            const isSameSession = currentConv?.claudeSessionId === m.claudeSessionId
-                || currentConv?.lastClaudeSessionId === m.claudeSessionId;
-            // Restore persisted permission mode (falls back to 'normal' if not found)
-            const persistedPermission = getConversationPermission(m.claudeSessionId) || 'normal';
-            if (currentConv) {
-                const currentMode = currentConv.permissionMode ?? (currentConv.planMode ? 'plan' : 'normal');
-                const persistedMode = persistedPermission;
-                const modeChanged = currentMode !== persistedMode;
-                currentConv.planMode = persistedMode === 'plan';
-                currentConv.permissionMode = persistedMode;
-                // Only restart when the persisted mode differs from what's running,
-                // and never interrupt an active turn.
-                if (modeChanged && currentConv.child && !currentConv.turnActive) {
-                    restartConversation(convId, { planMode: currentConv.planMode, permissionMode: currentConv.permissionMode });
+                // Fallback for BrainCore-spawned action-item sessions: try user home directory.
+                // Action-item Claude sessions are spawned by BrainCore with cwd=$HOME and have
+                // no AgentLink session-metadata sidecar, so neither lookup above finds them.
+                if (history.length === 0) {
+                    history = runtime
+                        ? await runtime.readHistory(os.homedir(), m.claudeSessionId)
+                        : [];
                 }
-            }
-            send({
-                type: 'conversation_resumed',
-                conversationId: convId,
-                claudeSessionId: m.claudeSessionId,
-                history,
-                isCompacting: isSameSession && (convId ? getIsCompacting(convId) : getIsCompacting()),
-                isProcessing: isSameSession && currentConv?.turnActive === true,
-                planMode: persistedPermission === 'plan',
-                permissionMode: persistedPermission,
-            });
-            // Re-deliver any pending AskUserQuestion requests so the refreshed web client
-            // can display the question card and allow the user to answer.
-            if (convId && isSameSession) {
-                const pending = getPendingQuestions(convId);
-                for (const pq of pending) {
-                    send({
-                        type: 'ask_user_question',
-                        conversationId: convId,
-                        requestId: pq.requestId,
-                        questions: pq.questions,
-                    });
+                console.log(`[AgentLink] → conversation_resumed (${history.length} messages, session ${m.claudeSessionId.slice(0, 8)})`);
+                // Include live status so the web client can restore compacting/processing state
+                // In multi-session mode, look up by conversationId; in single-session mode, use default
+                const currentConv = convId ? getConversation(convId) : getConversation();
+                const isSameSession = currentConv?.claudeSessionId === m.claudeSessionId
+                    || currentConv?.lastClaudeSessionId === m.claudeSessionId;
+                // Restore persisted permission mode (falls back to 'normal' if not found)
+                const persistedPermission = getConversationPermission(m.claudeSessionId) || 'normal';
+                if (currentConv) {
+                    const currentMode = currentConv.permissionMode ?? (currentConv.planMode ? 'plan' : 'normal');
+                    const persistedMode = persistedPermission;
+                    const modeChanged = currentMode !== persistedMode;
+                    currentConv.planMode = persistedMode === 'plan';
+                    currentConv.permissionMode = persistedMode;
+                    // Only restart when the persisted mode differs from what's running,
+                    // and never interrupt an active turn.
+                    if (modeChanged && currentConv.child && !currentConv.turnActive) {
+                        const cid = convId ?? 'default';
+                        runtime?.restartConversation(cid, { planMode: currentConv.planMode, permissionMode: currentConv.permissionMode });
+                        // Re-seed runtime mapping with the resumed session id so the next
+                        // chat resumes m.claudeSessionId rather than starting fresh after
+                        // restartConversation evicts the cache. (Codex review round 1.)
+                        runtime?.ensureConversation(cid, { workDir: state.workDir, resumeSessionId: m.claudeSessionId }).catch(() => { });
+                    }
                 }
-                // Re-deliver pending tool permission requests (same pattern as ask_user_question)
-                const pendingPerms = getPendingToolPermissions(convId);
-                for (const pp of pendingPerms) {
-                    send({
-                        type: 'tool_permission_request',
-                        conversationId: convId,
-                        requestId: pp.requestId,
-                        toolName: pp.toolName,
-                        displayName: pp.displayName,
-                        input: pp.input,
-                        decisionReason: pp.decisionReason,
-                    });
+                send({
+                    type: 'conversation_resumed',
+                    conversationId: convId,
+                    claudeSessionId: m.claudeSessionId,
+                    history,
+                    isCompacting: isSameSession && (runtime?.isCompacting(convId) ?? false),
+                    isProcessing: isSameSession && currentConv?.turnActive === true,
+                    planMode: persistedPermission === 'plan',
+                    permissionMode: persistedPermission,
+                    ...(typeof m.scrollToMessageIdx === 'number' ? { scrollToMessageIdx: m.scrollToMessageIdx } : {}),
+                    ...(m.searchQuery ? { searchQuery: m.searchQuery } : {}),
+                });
+                // Re-deliver any pending AskUserQuestion requests so the refreshed web client
+                // can display the question card and allow the user to answer.
+                if (convId && isSameSession) {
+                    const pending = getPendingQuestions(convId);
+                    for (const pq of pending) {
+                        send({
+                            type: 'ask_user_question',
+                            conversationId: convId,
+                            requestId: pq.requestId,
+                            questions: pq.questions,
+                        });
+                    }
+                    // Re-deliver pending tool permission requests (same pattern as ask_user_question)
+                    const pendingPerms = getPendingToolPermissions(convId);
+                    for (const pp of pendingPerms) {
+                        send({
+                            type: 'tool_permission_request',
+                            conversationId: convId,
+                            requestId: pp.requestId,
+                            toolName: pp.toolName,
+                            displayName: pp.displayName,
+                            input: pp.input,
+                            decisionReason: pp.decisionReason,
+                        });
+                    }
                 }
-            }
+            })().catch((err) => {
+                console.error('[AgentLink] resume_conversation failed:', err);
+                send({ type: 'error', message: 'Failed to resume conversation.' });
+            });
             break;
         }
         case 'ask_user_answer': {
             const m = msg;
-            handleUserAnswer(m.requestId, m.answers);
+            if (!runtime) {
+                console.warn('[AgentLink] ask_user_answer received after runtime shutdown — ignoring');
+                break;
+            }
+            runtime.answerUserInput(m.requestId, m.answers);
             break;
         }
         case 'delete_session': {
             const m = msg;
-            handleDeleteSession(m.sessionId);
+            handleDeleteSession(m.sessionId).catch((err) => {
+                console.error('[AgentLink] handleDeleteSession failed:', err);
+                send({ type: 'error', message: 'Session not found or could not be deleted.' });
+            });
             break;
         }
         case 'rename_session': {
             const m = msg;
-            handleRenameSession(m.sessionId, m.newTitle);
+            handleRenameSession(m.sessionId, m.newTitle).catch((err) => {
+                console.error('[AgentLink] handleRenameSession failed:', err);
+                send({ type: 'error', message: 'Session not found or could not be renamed.' });
+            });
             break;
         }
         case 'query_active_conversations': {
@@ -670,7 +808,7 @@ function handleServerMessage(msg) {
                         conversationId: convId,
                         claudeSessionId: conv.claudeSessionId,
                         isProcessing: true,
-                        isCompacting: getIsCompacting(convId),
+                        isCompacting: runtime?.isCompacting(convId) ?? false,
                     });
                 }
                 else if (conv.claudeSessionId) {
@@ -784,11 +922,11 @@ function handleServerMessage(msg) {
                 break;
             }
             console.log(`[AgentLink] set_model: model=${model}, conversationId=${conversationId}`);
-            setModel(conversationId, model);
+            runtime?.setModel(conversationId ?? null, model);
             // Kill current Claude process so next message spawns with new --model flag
             const conv = getConversation(conversationId);
             if (conv) {
-                restartConversation(conversationId);
+                runtime?.restartConversation(conversationId ?? 'default');
             }
             send({ type: 'model_changed', model, conversationId });
             break;
@@ -796,17 +934,10 @@ function handleServerMessage(msg) {
         case 'set_plan_mode': {
             const { enabled, conversationId } = msg;
             console.log(`[AgentLink] set_plan_mode: enabled=${enabled}, conversationId=${conversationId}`);
-            const conv = getConversation(conversationId);
-            if (conv) {
-                // Restart with new mode
-                const result = restartConversation(conversationId, { planMode: enabled });
-                if (result.wasTurnActive) {
-                    send({ type: 'execution_cancelled', conversationId });
-                }
-            }
-            else {
-                // No conversation yet — create placeholder
-                createPlaceholderConversation(conversationId, { planMode: enabled });
+            const convId = conversationId ?? 'default';
+            const result = runtime?.setPlanMode(convId, enabled, state.workDir) ?? null;
+            if (result?.wasTurnActive) {
+                send({ type: 'execution_cancelled', conversationId });
             }
             send({ type: 'plan_mode_changed', enabled, conversationId });
             break;
@@ -814,22 +945,10 @@ function handleServerMessage(msg) {
         case 'set_permission_mode': {
             const { mode, conversationId } = msg;
             console.log(`[AgentLink] set_permission_mode: mode=${mode}, conversationId=${conversationId}`);
-            const planMode = mode === 'plan';
-            const conv = getConversation(conversationId);
-            if (conv) {
-                const result = restartConversation(conversationId, {
-                    planMode,
-                    permissionMode: mode,
-                });
-                if (result.wasTurnActive) {
-                    send({ type: 'execution_cancelled', conversationId });
-                }
-            }
-            else {
-                createPlaceholderConversation(conversationId, {
-                    planMode,
-                    permissionMode: mode,
-                });
+            const convId = conversationId ?? 'default';
+            const result = runtime?.setPermissionMode(convId, mode, state.workDir) ?? null;
+            if (result?.wasTurnActive) {
+                send({ type: 'execution_cancelled', conversationId });
             }
             send({ type: 'permission_mode_changed', mode, conversationId });
             // Persist permission mode for this conversation's session
@@ -846,23 +965,20 @@ function handleServerMessage(msg) {
         case 'tool_permission_response': {
             const { requestId, behavior } = msg;
             console.log(`[AgentLink] tool_permission_response: ${behavior} (${requestId})`);
-            handleToolPermissionResponse(requestId, behavior);
+            if (!runtime) {
+                console.warn('[AgentLink] tool_permission_response received after runtime shutdown — ignoring');
+                break;
+            }
+            runtime.answerApproval(requestId, behavior);
             break;
         }
         case 'set_brain_mode': {
             const { enabled, conversationId } = msg;
             console.log(`[AgentLink] set_brain_mode: enabled=${enabled}, conversationId=${conversationId}`);
-            const conv = getConversation(conversationId);
-            if (conv) {
-                // Restart with new brain mode
-                const result = restartConversation(conversationId, { brainMode: enabled });
-                if (result.wasTurnActive) {
-                    send({ type: 'execution_cancelled', conversationId });
-                }
-            }
-            else {
-                // No conversation yet — create placeholder
-                createPlaceholderConversation(conversationId, { brainMode: enabled });
+            const convId = conversationId ?? 'default';
+            const result = runtime?.setBrainMode(convId, enabled, state.workDir) ?? null;
+            if (result?.wasTurnActive) {
+                send({ type: 'execution_cancelled', conversationId });
             }
             send({ type: 'brain_mode_changed', enabled, conversationId });
             break;
@@ -1260,18 +1376,38 @@ async function handleBrainChatDeleteSession(msg) {
         send({ type: 'brainchat_error', message: String(err) });
     }
 }
-function handleListSessions() {
+async function handleListSessions() {
     try {
-        const sessions = listSessions(state.workDir);
+        if (!runtime) {
+            send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
+            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 sessions = rows.map(r => ({
+            sessionId: r.session.backendSessionId,
+            title: r.title,
+            customTitle: r.customTitle,
+            preview: r.preview,
+            lastModified: r.lastModified,
+        }));
         const metaMap = loadAllSessionMetadata();
         const enriched = sessions.map(s => ({
             ...s,
             ...metaMap.get(s.sessionId),
         }));
         // Always merge recap/briefing/devops chat sessions from BrainData directory — they live under a
-        // different Claude project folder, so listSessions(state.workDir) misses them.
+        // different Claude project folder, so listHistory(state.workDir) misses them.
         // These sessions should be visible regardless of the current workDir.
-        const brainSessions = listSessions(BRAIN_DATA_DIR);
+        const brainRows = await runtime.listHistory(BRAIN_DATA_DIR);
+        const brainSessions = brainRows.map(r => ({
+            sessionId: r.session.backendSessionId,
+            title: r.title,
+            customTitle: r.customTitle,
+            preview: r.preview,
+            lastModified: r.lastModified,
+        }));
         const existingIds = new Set(enriched.map(s => s.sessionId));
         for (const bs of brainSessions) {
             if (existingIds.has(bs.sessionId))
@@ -1302,18 +1438,76 @@ async function handleListRecentSessions(msg) {
         send({ type: 'recent_sessions_list', sessions: [] });
     }
 }
-function handleDeleteSession(sessionId) {
+// ── Session content search ───────────────────────────────────────────────
+// Single in-flight search at a time. Newer searches abort older ones; explicit
+// cancel_search messages also abort. The web client filters stale results by
+// echoing the searchId.
+const searchControllers = new Map();
+function handleSearchSessions(msg) {
+    const { searchId, query, limit } = msg;
+    if (!searchId)
+        return;
+    // Abort any prior in-flight search (only one at a time).
+    for (const [id, ctrl] of searchControllers) {
+        ctrl.abort();
+        searchControllers.delete(id);
+    }
+    const controller = new AbortController();
+    searchControllers.set(searchId, controller);
+    // searchSessions is sync but we yield to the event loop so a fast follow-up
+    // cancel_search has a chance to abort before we walk the file system.
+    setImmediate(() => {
+        if (controller.signal.aborted) {
+            searchControllers.delete(searchId);
+            return;
+        }
+        try {
+            const result = searchSessions(state.workDir, 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({
+                type: 'session_search_results',
+                searchId,
+                ...result,
+            });
+        }
+        catch (err) {
+            console.error('[AgentLink] searchSessions failed:', err);
+            send({
+                type: 'session_search_error',
+                searchId,
+                message: String(err),
+            });
+        }
+        finally {
+            searchControllers.delete(searchId);
+        }
+    });
+}
+function handleCancelSearch(msg) {
+    const ctrl = searchControllers.get(msg.searchId);
+    if (ctrl) {
+        ctrl.abort();
+        searchControllers.delete(msg.searchId);
+    }
+}
+async function handleDeleteSession(sessionId) {
     // 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.' });
         return;
     }
+    if (!runtime) {
+        send({ 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 = deleteSession(state.workDir, sessionId);
+    let deleted = await runtime.deleteHistorySession(state.workDir, sessionId);
     if (!deleted) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
-            deleted = deleteSession(BRAIN_DATA_DIR, sessionId);
+            deleted = await runtime.deleteHistorySession(BRAIN_DATA_DIR, sessionId);
         }
     }
     if (deleted) {
@@ -1324,13 +1518,17 @@ function handleDeleteSession(sessionId) {
         send({ type: 'error', message: 'Session not found or could not be deleted.' });
     }
 }
-function handleRenameSession(sessionId, newTitle) {
+async function handleRenameSession(sessionId, newTitle) {
+    if (!runtime) {
+        send({ 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 = renameSession(state.workDir, sessionId, newTitle);
+    let renamed = await runtime.renameHistorySession(state.workDir, sessionId, newTitle);
     if (!renamed) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
-            renamed = renameSession(BRAIN_DATA_DIR, sessionId, newTitle);
+            renamed = await runtime.renameHistorySession(BRAIN_DATA_DIR, sessionId, newTitle);
         }
     }
     if (renamed) {
@@ -1340,15 +1538,20 @@ function handleRenameSession(sessionId, newTitle) {
         // 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(() => {
-            const retried = renameSession(state.workDir, sessionId, newTitle)
-                || renameSession(BRAIN_DATA_DIR, sessionId, newTitle);
-            if (retried) {
-                send({ type: 'session_renamed', sessionId, newTitle });
-            }
-            else {
-                console.warn(`[AgentLink] rename_session: session ${sessionId.slice(0, 8)} not found after retry`);
+            (async () => {
+                const retried = (await runtime.renameHistorySession(state.workDir, sessionId, newTitle))
+                    || (await runtime.renameHistorySession(BRAIN_DATA_DIR, sessionId, newTitle));
+                if (retried) {
+                    send({ 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.' });
+                }
+            })().catch((err) => {
+                console.error('[AgentLink] rename_session retry failed:', err);
                 send({ type: 'error', message: 'Session not found or could not be renamed.' });
-            }
+            });
         }, 1500);
     }
 }