@agent-link/agent 0.1.214 → 0.1.215

package/dist/connection.js

@@ -19,8 +19,8 @@ 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, 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 { handleChat as claudeHandleChat, addSendFn, 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, addOnSessionStarted } from './runtime.js';
+import { listSessions, readSessionMessages, deleteSession, renameSession, 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';
@@ -48,13 +48,6 @@ const state = {
 };
 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.
@@ -78,14 +71,6 @@ 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);
@@ -392,13 +377,6 @@ 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) {
@@ -519,7 +497,7 @@ function handleServerMessage(msg) {
             const projectName = msg.projectName;
             const icmId = msg.icmId;
             const actionItemId = msg.actionItemId;
-            const explicitWorkDir = msg.workDir;
+            const chatWorkDir = existingConv?.workDir || state.workDir;
             const effectiveBrainMode = !!isBrainMode;
             console.log(`[AgentLink] chat: conversationId=${chatConvId}, existingConv.planMode=${existingConv?.planMode}, brainMode=${effectiveBrainMode}`);
             const chatOptions = {
@@ -549,56 +527,19 @@ function handleServerMessage(msg) {
             if (icmId) {
                 chatOptions.icmId = String(icmId);
             }
-            const chatDir = explicitWorkDir
-                ?? existingConv?.workDir
-                ?? ((recapId || briefingDate || devopsEntityType || projectName || icmId) ? BRAIN_DATA_DIR : null)
-                ?? state.workDir;
+            const chatDir = (recapId || briefingDate || devopsEntityType || projectName || icmId) ? BRAIN_DATA_DIR : (existingConv?.workDir || state.workDir);
             // Track actionItemId for linking to Claude session on session_started
             if (actionItemId && chatConvId) {
                 pendingActionItems.set(chatConvId, actionItemId);
             }
-            // 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);
-            });
+            claudeHandleChat(chatConvId, msg.prompt, chatDir, chatOptions, msg.files);
             break;
         }
-        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);
-            });
+        case 'cancel_execution':
+            claudeCancelExecution(msg.conversationId);
             break;
-        }
         case 'list_sessions':
-            handleListSessions().catch((err) => {
-                console.error('[AgentLink] handleListSessions failed:', err);
-                send({ type: 'sessions_list', sessions: [], workDir: state.workDir });
-            });
+            handleListSessions();
             break;
         case 'list_recent_sessions':
             handleListRecentSessions(msg);
@@ -663,10 +604,6 @@ 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': {
@@ -684,148 +621,93 @@ function handleServerMessage(msg) {
                 // (handles page refresh where web client generates a new UUID)
                 rebindConversation(m.claudeSessionId, convId);
             }
-            // 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 resolvedWorkDir = state.workDir;
-                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)
-                            : [];
-                        if (history.length > 0)
-                            resolvedWorkDir = BRAIN_DATA_DIR;
-                    }
-                }
-                // 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)
-                        : [];
-                    if (history.length > 0)
-                        resolvedWorkDir = os.homedir();
+            // 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);
                 }
-                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: resolvedWorkDir, resumeSessionId: m.claudeSessionId }).catch(() => { });
-                    }
-                    // Remember the cwd the JSONL was found in so follow-up chats resume
-                    // in the same directory (Claude refuses --resume across cwds).
-                    currentConv.workDir = resolvedWorkDir;
+            }
+            // 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 = readSessionMessages(os.homedir(), 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 });
                 }
-                // Always seed the runtime's convToSession map with the resumed session id
-                // so the next `chat` for this conversation resumes the right Claude session
-                // instead of spawning a fresh one. The web client only sends `resumeSessionId`
-                // on the `resume_conversation` message — follow-up `chat` messages don't
-                // re-send it, so the agent must remember it. Without this, ClaudeBackend's
-                // ensureSession returns a `pending:` placeholder and startTurn drops the
-                // resume id, causing each new message to start a new Claude session.
-                // Skipped when there's already an active turn (would race with the live
-                // process's own session id).
-                const seedCid = convId ?? 'default';
-                const seedConv = currentConv;
-                if (!seedConv?.turnActive) {
-                    runtime?.ensureConversation(seedCid, {
-                        workDir: resolvedWorkDir,
-                        resumeSessionId: m.claudeSessionId,
-                    }).catch(() => { });
+            }
+            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,
+                ...(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,
+                    });
                 }
-                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,
-                        });
-                    }
+                // 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;
-            if (!runtime) {
-                console.warn('[AgentLink] ask_user_answer received after runtime shutdown — ignoring');
-                break;
-            }
-            runtime.answerUserInput(m.requestId, m.answers);
+            handleUserAnswer(m.requestId, m.answers);
             break;
         }
         case 'delete_session': {
             const m = msg;
-            handleDeleteSession(m.sessionId).catch((err) => {
-                console.error('[AgentLink] handleDeleteSession failed:', err);
-                send({ type: 'error', message: 'Session not found or could not be deleted.' });
-            });
+            handleDeleteSession(m.sessionId);
             break;
         }
         case 'rename_session': {
             const m = msg;
-            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.' });
-            });
+            handleRenameSession(m.sessionId, m.newTitle);
             break;
         }
         case 'query_active_conversations': {
@@ -836,7 +718,7 @@ function handleServerMessage(msg) {
                         conversationId: convId,
                         claudeSessionId: conv.claudeSessionId,
                         isProcessing: true,
-                        isCompacting: runtime?.isCompacting(convId) ?? false,
+                        isCompacting: getIsCompacting(convId),
                     });
                 }
                 else if (conv.claudeSessionId) {
@@ -950,11 +832,11 @@ function handleServerMessage(msg) {
                 break;
             }
             console.log(`[AgentLink] set_model: model=${model}, conversationId=${conversationId}`);
-            runtime?.setModel(conversationId ?? null, model);
+            setModel(conversationId, model);
             // Kill current Claude process so next message spawns with new --model flag
             const conv = getConversation(conversationId);
             if (conv) {
-                runtime?.restartConversation(conversationId ?? 'default');
+                restartConversation(conversationId);
             }
             send({ type: 'model_changed', model, conversationId });
             break;
@@ -962,10 +844,17 @@ function handleServerMessage(msg) {
         case 'set_plan_mode': {
             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;
-            if (result?.wasTurnActive) {
-                send({ type: 'execution_cancelled', 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 });
             }
             send({ type: 'plan_mode_changed', enabled, conversationId });
             break;
@@ -973,10 +862,22 @@ function handleServerMessage(msg) {
         case 'set_permission_mode': {
             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;
-            if (result?.wasTurnActive) {
-                send({ type: 'execution_cancelled', 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,
+                });
             }
             send({ type: 'permission_mode_changed', mode, conversationId });
             // Persist permission mode for this conversation's session
@@ -993,20 +894,23 @@ function handleServerMessage(msg) {
         case 'tool_permission_response': {
             const { requestId, behavior } = msg;
             console.log(`[AgentLink] tool_permission_response: ${behavior} (${requestId})`);
-            if (!runtime) {
-                console.warn('[AgentLink] tool_permission_response received after runtime shutdown — ignoring');
-                break;
-            }
-            runtime.answerApproval(requestId, behavior);
+            handleToolPermissionResponse(requestId, behavior);
             break;
         }
         case 'set_brain_mode': {
             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;
-            if (result?.wasTurnActive) {
-                send({ type: 'execution_cancelled', 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 });
             }
             send({ type: 'brain_mode_changed', enabled, conversationId });
             break;
@@ -1404,38 +1308,18 @@ async function handleBrainChatDeleteSession(msg) {
         send({ type: 'brainchat_error', message: String(err) });
     }
 }
-async function handleListSessions() {
+function handleListSessions() {
     try {
-        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 sessions = listSessions(state.workDir);
         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 listHistory(state.workDir) misses them.
+        // different Claude project folder, so listSessions(state.workDir) 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 => ({
-            sessionId: r.session.backendSessionId,
-            title: r.title,
-            customTitle: r.customTitle,
-            preview: r.preview,
-            lastModified: r.lastModified,
-        }));
+        const brainSessions = listSessions(BRAIN_DATA_DIR);
         const existingIds = new Set(enriched.map(s => s.sessionId));
         for (const bs of brainSessions) {
             if (existingIds.has(bs.sessionId))
@@ -1520,22 +1404,18 @@ function handleCancelSearch(msg) {
         searchControllers.delete(msg.searchId);
     }
 }
-async function handleDeleteSession(sessionId) {
+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 = await runtime.deleteHistorySession(state.workDir, sessionId);
+    let deleted = deleteSession(state.workDir, sessionId);
     if (!deleted) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
-            deleted = await runtime.deleteHistorySession(BRAIN_DATA_DIR, sessionId);
+            deleted = deleteSession(BRAIN_DATA_DIR, sessionId);
         }
     }
     if (deleted) {
@@ -1546,17 +1426,13 @@ async function handleDeleteSession(sessionId) {
         send({ type: 'error', message: 'Session not found or could not be deleted.' });
     }
 }
-async function handleRenameSession(sessionId, newTitle) {
-    if (!runtime) {
-        send({ type: 'error', message: 'Session not found or could not be renamed.' });
-        return;
-    }
+function handleRenameSession(sessionId, newTitle) {
     // 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 = renameSession(state.workDir, sessionId, newTitle);
     if (!renamed) {
         const meta = loadSessionMetadata(sessionId);
         if (meta.recapId || meta.briefingDate || meta.devopsEntityType || meta.projectName || meta.icmId) {
-            renamed = await runtime.renameHistorySession(BRAIN_DATA_DIR, sessionId, newTitle);
+            renamed = renameSession(BRAIN_DATA_DIR, sessionId, newTitle);
         }
     }
     if (renamed) {
@@ -1566,20 +1442,15 @@ async 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(() => {
-            (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);
+            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`);
                 send({ type: 'error', message: 'Session not found or could not be renamed.' });
-            });
+            }
         }, 1500);
     }
 }