dr-claw 1.1.2 → 1.1.4

package/server/__tests__/gemini-session-index.test.mjs

@@ -0,0 +1,95 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalDatabasePath = process.env.DATABASE_PATH;
+
+let tempRoot = null;
+
+async function loadTestModules() {
+  vi.resetModules();
+  const projects = await import('../projects.js');
+  const database = await import('../database/db.js');
+  await database.initializeDatabase();
+  return { projects, database };
+}
+
+describe('Gemini API session indexing', () => {
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(os.tmpdir(), 'dr-claw-gemini-index-'));
+    process.env.HOME = tempRoot;
+    process.env.USERPROFILE = tempRoot;
+    process.env.DATABASE_PATH = path.join(tempRoot, 'db', 'auth.db');
+  });
+
+  afterEach(async () => {
+    vi.resetModules();
+
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+
+    if (originalDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = originalDatabasePath;
+
+    if (tempRoot) {
+      await rm(tempRoot, { recursive: true, force: true });
+      tempRoot = null;
+    }
+  });
+
+  it('discovers API-written Gemini sessions from ~/.gemini/sessions', async () => {
+    const { projects } = await loadTestModules();
+    const projectPath = path.join(tempRoot, 'workspace', 'gemini-project');
+    const sessionId = 'gemini-api-session-1';
+    const sessionsDir = path.join(tempRoot, '.gemini', 'sessions');
+    const sessionFile = path.join(sessionsDir, `${sessionId}.jsonl`);
+
+    await mkdir(projectPath, { recursive: true });
+    await mkdir(sessionsDir, { recursive: true });
+    await writeFile(sessionFile, [
+      JSON.stringify({
+        type: 'session_meta',
+        payload: {
+          id: sessionId,
+          cwd: projectPath,
+          timestamp: '2026-04-05T12:00:00.000Z',
+          sessionMode: 'research',
+          title: 'Explore Gemini API flow',
+        },
+        cwd: projectPath,
+        timestamp: '2026-04-05T12:00:00.000Z',
+        title: 'Explore Gemini API flow',
+      }),
+      JSON.stringify({
+        type: 'message',
+        role: 'user',
+        content: 'Explore Gemini API flow',
+        timestamp: '2026-04-05T12:00:01.000Z',
+      }),
+      JSON.stringify({
+        type: 'message',
+        role: 'assistant',
+        content: 'I inspected the repository.',
+        timestamp: '2026-04-05T12:00:02.000Z',
+      }),
+      '',
+    ].join('\n'), 'utf-8');
+
+    const sessions = await projects.getGeminiSessions(projectPath, { limit: 5 });
+
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]).toEqual(expect.objectContaining({
+      id: sessionId,
+      name: 'Explore Gemini API flow',
+      mode: 'research',
+      projectPath,
+      messageCount: 2,
+    }));
+  });
+});

package/server/__tests__/project-sync-dedup.test.mjs

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, rm } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalDatabasePath = process.env.DATABASE_PATH;
+
+let tempRoot = null;
+
+async function loadTestModules() {
+  vi.resetModules();
+  const database = await import('../database/db.js');
+  await database.initializeDatabase();
+  const projects = await import('../projects.js');
+  return { projects, database };
+}
+
+/** Create a test user and return its numeric id */
+function createTestUser(database, username = 'testuser') {
+  const user = database.userDb.createUser(username, 'hash');
+  return user.id;
+}
+
+describe('project sync and dedup (PR #89)', () => {
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(os.tmpdir(), 'dr-claw-project-dedup-'));
+    process.env.HOME = tempRoot;
+    process.env.USERPROFILE = tempRoot;
+    process.env.DATABASE_PATH = path.join(tempRoot, 'db', 'auth.db');
+  });
+
+  afterEach(async () => {
+    vi.resetModules();
+
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+
+    if (originalDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = originalDatabasePath;
+
+    if (tempRoot) {
+      await rm(tempRoot, { recursive: true, force: true });
+      tempRoot = null;
+    }
+  });
+
+  describe('getProjectByPath', () => {
+    it('returns unowned project when queried with a userId', async () => {
+      const { database } = await loadTestModules();
+      const testPath = '/tmp/test-project-alpha';
+
+      database.projectDb.upsertProject('proj-alpha', null, 'Alpha', testPath, 0, null, null);
+
+      const result = database.projectDb.getProjectByPath(testPath, 1);
+      expect(result).not.toBeNull();
+      expect(result.id).toBe('proj-alpha');
+      expect(result.user_id).toBeNull();
+    });
+
+    it('prefers same-user record over unowned when both exist', async () => {
+      const { database } = await loadTestModules();
+      const userId = createTestUser(database);
+      const testPath = '/tmp/test-project-beta';
+
+      // Insert unowned record first
+      database.projectDb.upsertProject('proj-beta-unowned', null, 'Beta Unowned', testPath, 0, null, null);
+      // Insert user-owned record (different ID to allow both rows)
+      database.projectDb.upsertProject('proj-beta-user1', userId, 'Beta User1', testPath, 0, null, null);
+
+      const result = database.projectDb.getProjectByPath(testPath, userId);
+      expect(result).not.toBeNull();
+      expect(result.id).toBe('proj-beta-user1');
+      expect(result.user_id).toBe(userId);
+    });
+
+    it('returns user-owned project when queried with userId=null', async () => {
+      const { database } = await loadTestModules();
+      const userId = createTestUser(database);
+      const testPath = '/tmp/test-project-gamma';
+
+      database.projectDb.upsertProject('proj-gamma', userId, 'Gamma', testPath, 0, null, null);
+
+      const result = database.projectDb.getProjectByPath(testPath, null);
+      expect(result).not.toBeNull();
+      expect(result.id).toBe('proj-gamma');
+      expect(result.user_id).toBe(userId);
+    });
+  });
+
+  describe('addProjectManually — preserves existing values', () => {
+    it('preserves is_starred and metadata when project already exists', async () => {
+      const { database, projects } = await loadTestModules();
+
+      // Create a real directory for addProjectManually's fs.access check
+      const projectDir = path.join(tempRoot, 'my-project');
+      await mkdir(projectDir, { recursive: true });
+
+      const encodedId = projects.encodeProjectPath(projectDir);
+      const customMetadata = { customKey: 'customValue', provider: 'claude' };
+
+      // Seed the DB with a starred project that has metadata
+      database.projectDb.upsertProject(
+        encodedId, null, 'My Project', projectDir,
+        1, '2026-01-01T00:00:00.000Z', customMetadata,
+      );
+
+      // Now call addProjectManually — should NOT wipe is_starred or metadata
+      const result = await projects.addProjectManually(projectDir, null, null);
+
+      expect(result.alreadyExists).toBe(true);
+
+      // Verify DB state
+      const dbRow = database.projectDb.getProjectByPath(projectDir, null);
+      expect(dbRow.is_starred).toBe(1);
+      expect(dbRow.metadata.customKey).toBe('customValue');
+      expect(dbRow.metadata.provider).toBe('claude');
+      expect(dbRow.metadata.manuallyAdded).toBe(true);
+    });
+
+    it('does not create duplicate when same path exists with different ID', async () => {
+      const { database, projects } = await loadTestModules();
+
+      const projectDir = path.join(tempRoot, 'dup-project');
+      await mkdir(projectDir, { recursive: true });
+
+      // Insert with a "legacy" ID that differs from encodeProjectPath output
+      const legacyId = 'legacy-encoded-dup-project';
+      database.projectDb.upsertProject(
+        legacyId, null, 'Dup Project', projectDir,
+        0, null, null,
+      );
+
+      // addProjectManually will compute a different ID via encodeProjectPath
+      const result = await projects.addProjectManually(projectDir, null, null);
+      expect(result.alreadyExists).toBe(true);
+
+      // Should still be only one record for this path
+      const all = database.projectDb.getAllProjects(null);
+      const matching = all.filter(p => p.path === projectDir);
+      expect(matching.length).toBe(1);
+    });
+  });
+
+  describe('bootstrap throttle', () => {
+    it('does not re-scan legacy sources within 60 seconds', async () => {
+      const { projects, database } = await loadTestModules();
+
+      // Set up minimal directory structure so getProjects doesn't error
+      await mkdir(path.join(tempRoot, 'dr-claw'), { recursive: true });
+      await mkdir(path.join(tempRoot, '.claude', 'projects'), { recursive: true });
+
+      // Spy on bootstrapProjectsIndexFromLegacySources via upsertProject call count
+      const upsertSpy = vi.spyOn(database.projectDb, 'upsertProject');
+
+      await projects.getProjects(null);
+      const callsAfterFirst = upsertSpy.mock.calls.length;
+
+      // Second call within 60s — bootstrap should be skipped
+      await projects.getProjects(null);
+      const callsAfterSecond = upsertSpy.mock.calls.length;
+
+      // No additional upsertProject calls from bootstrap on second run
+      expect(callsAfterSecond).toBe(callsAfterFirst);
+
+      upsertSpy.mockRestore();
+    });
+  });
+});

package/server/__tests__/session-delete.test.mjs

@@ -163,4 +163,156 @@ describe('session deletion fallbacks', () => {
     expect(sessions[0].provider).toBe('codex');
     expect(sessions[0].summary).toContain('Inspect the project state');
   });
+
+
+  it('parses Codex history into session context inputs that survive reload', async () => {
+    const sessionId = 'codex-session-context';
+    const projectRoot = path.join(tempRoot, 'workspace', 'demo');
+    const sessionDir = path.join(tempRoot, '.codex', 'sessions', '2026', '03', '30');
+    const sessionFile = path.join(sessionDir, `rollout-2026-03-30T05-00-00-${sessionId}.jsonl`);
+
+    await mkdir(sessionDir, { recursive: true });
+    await writeFile(sessionFile, [
+      JSON.stringify({
+        timestamp: '2026-03-30T05:18:20.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'function_call',
+          name: 'exec_command',
+          arguments: JSON.stringify({
+            cmd: "sed -n '1,200p' src/components/chat/utils/sessionContextSummary.ts",
+            workdir: projectRoot,
+          }),
+          call_id: 'call-read',
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:18:21.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'function_call_output',
+          call_id: 'call-read',
+          output: 'export const example = true;',
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:18:22.000Z',
+        type: 'event_msg',
+        payload: {
+          type: 'exec_command_end',
+          call_id: 'call-read',
+          cwd: projectRoot,
+          parsed_cmd: [
+            {
+              type: 'read',
+              cmd: "sed -n '1,200p' src/components/chat/utils/sessionContextSummary.ts",
+              path: 'src/components/chat/utils/sessionContextSummary.ts',
+            },
+          ],
+          aggregated_output: 'export const example = true;',
+          exit_code: 0,
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:19:00.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'function_call',
+          name: 'update_plan',
+          arguments: JSON.stringify({
+            plan: [
+              { step: 'Normalize Codex history', status: 'in_progress' },
+              { step: 'Expand session summary', status: 'pending' },
+            ],
+          }),
+          call_id: 'call-plan',
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:20:00.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'custom_tool_call',
+          name: 'apply_patch',
+          input: [
+            '*** Begin Patch',
+            '*** Update File: src/components/chat/utils/sessionContextSummary.ts',
+            '*** Add File: docs/plan.md',
+            '*** End Patch',
+          ].join('\n'),
+          call_id: 'call-patch',
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:20:01.000Z',
+        type: 'event_msg',
+        payload: {
+          type: 'patch_apply_end',
+          call_id: 'call-patch',
+          stdout: 'Success. Updated the following files:\nM src/components/chat/utils/sessionContextSummary.ts\nA docs/plan.md\n',
+          stderr: '',
+          success: true,
+          status: 'completed',
+          changes: {
+            [path.join(projectRoot, 'src/components/chat/utils/sessionContextSummary.ts')]: { type: 'update' },
+            [path.join(projectRoot, 'docs/plan.md')]: { type: 'add' },
+          },
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:21:00.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'web_search_call',
+          status: 'completed',
+          action: {
+            type: 'search',
+            query: 'Codex session context panel',
+            queries: ['Codex session context panel'],
+          },
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:21:30.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'web_search_call',
+          status: 'completed',
+          action: {
+            type: 'open_page',
+            url: 'https://developers.openai.com/api/docs',
+          },
+        },
+      }),
+      JSON.stringify({
+        timestamp: '2026-03-30T05:22:00.000Z',
+        type: 'response_item',
+        payload: {
+          type: 'web_search_call',
+          status: 'completed',
+          action: {
+            type: 'find_in_page',
+            url: 'https://developers.openai.com/api/docs',
+            pattern: 'session',
+          },
+        },
+      }),
+    ].join('\n'));
+
+    const { projects } = await loadTestModules();
+    const { convertSessionMessages } = await import('../../src/components/chat/utils/messageTransforms.ts');
+    const { deriveSessionContextSummary } = await import('../../src/components/chat/utils/sessionContextSummary.ts');
+    const result = await projects.getCodexSessionMessages(sessionId, null, 0);
+    const summary = deriveSessionContextSummary(convertSessionMessages(result.messages), projectRoot);
+
+    expect(summary.contextFiles.some((item) => item.relativePath === 'src/components/chat/utils/sessionContextSummary.ts')).toBe(true);
+    expect(summary.outputFiles.map((item) => item.relativePath).sort()).toEqual([
+      'docs/plan.md',
+      'src/components/chat/utils/sessionContextSummary.ts',
+    ]);
+    expect(summary.tasks.some((item) => item.label === 'Normalize Codex history')).toBe(true);
+    expect(summary.tasks.some((item) => item.label === 'Codex session context panel')).toBe(true);
+    expect(summary.tasks.some((item) => item.label === 'https://developers.openai.com/api/docs')).toBe(true);
+    expect(summary.tasks.some((item) => item.label === 'session')).toBe(true);
+  });
 });

package/server/claude-sdk.js

@@ -25,6 +25,7 @@ import { applyStageTagsToSession, recordIndexedSession } from './utils/sessionIn
 import { buildTempAttachmentFilename } from './utils/imageAttachmentFiles.js';
 
 import { createRequestId, waitForToolApproval, resolveToolApproval as resolvePermApproval, matchesToolPermission } from './utils/permissions.js';
+import { buildMemoryBlock } from './utils/memoryPrompt.js';
 
 const activeSessions = new Map();
 const pendingClaudeSessionIndexReconciles = new Map();
@@ -143,10 +144,12 @@ function mapCliOptionsToSDK(options = {}) {
   sdkOptions.model = options.model || CLAUDE_MODELS.DEFAULT;
   console.log(`Using model: ${sdkOptions.model}`);
 
-  // Map system prompt configuration
+  // Map system prompt configuration with optional user memory injection
+  const memoryBlock = options.userId ? buildMemoryBlock(options.userId) : '';
   sdkOptions.systemPrompt = {
     type: 'preset',
-    preset: 'claude_code'  // Required to use CLAUDE.md
+    preset: 'claude_code',  // Required to use CLAUDE.md
+    ...(memoryBlock ? { append: memoryBlock } : {}),
   };
 
   // Map setting sources for CLAUDE.md loading
@@ -220,28 +223,78 @@ function transformMessage(sdkMessage) {
 }
 
 /**
- * Extracts token budget from the last assistant message's usage data.
- * This gives us per-API-call input tokens, which represents the actual
- * context window fill level (not cumulative across the agentic turn).
+ * Returns the context window size for a given model name.
+ * Supports both SDK format ('sonnet', 'opus') and API format ('claude-opus-4-6').
+ * Falls back to CONTEXT_WINDOW env var, then 200000.
+ * @param {string|null} modelName
+ * @returns {number}
+ */
+function getContextWindowForModel(modelName) {
+  const MODEL_CONTEXT_WINDOWS = {
+    // SDK format names
+    'sonnet':              200000,
+    'opus':                200000,
+    'haiku':               200000,
+    'opusplan':            200000,
+    'sonnet[1m]':          1000000,
+    // API format names
+    'claude-opus-4-6':             200000,
+    'claude-opus-4-20250918':      200000,
+    'claude-sonnet-4-6':           200000,
+    'claude-sonnet-4-20250514':    200000,
+    'claude-haiku-4-5':            200000,
+    'claude-haiku-4-5-20251001':   200000,
+    'claude-3-5-sonnet':           200000,
+    'claude-3-5-sonnet-20241022':  200000,
+    'claude-3-5-haiku':            200000,
+    'claude-3-5-haiku-20241022':   200000,
+    'claude-3-opus':               200000,
+    'claude-3-opus-20240229':      200000,
+    'claude-3-sonnet':             200000,
+    'claude-3-haiku':              200000,
+  };
+
+  if (modelName) {
+    // Exact match first
+    const exact = MODEL_CONTEXT_WINDOWS[modelName];
+    if (exact) return exact;
+    // Prefix match (e.g. 'claude-opus-4-6-20260301' matches 'claude-opus-4-6')
+    const prefix = Object.keys(MODEL_CONTEXT_WINDOWS).find(k => modelName.startsWith(k));
+    if (prefix) return MODEL_CONTEXT_WINDOWS[prefix];
+  }
+
+  // Fallback: env var override, then default
+  const envVal = parseInt(process.env.CONTEXT_WINDOW, 10);
+  return Number.isFinite(envVal) ? envVal : 200000;
+}
+
+/**
+ * Extracts token budget from the latest assistant message's usage data.
+ * Returns a snapshot of context window usage for a single API call,
+ * including both input tokens (with cache) and output tokens.
+ * Not cumulative across agentic turns.
  * @param {Object|null} usage - usage object from assistant message (message.usage)
- * @returns {Object|null} Token budget object or null
+ * @param {string|null} modelName - model name for context window lookup
+ * @returns {Object|null} Token budget object { used, total } or null
  */
-function extractTokenBudgetFromUsage(usage) {
+function extractTokenBudgetFromUsage(usage, modelName) {
   if (!usage) {
     return null;
   }
 
   // In Claude API: input_tokens is the non-cached portion.
-  // Total context = input_tokens + cache_read_input_tokens + cache_creation_input_tokens
+  // Total context = input_tokens + cache_read_input_tokens + cache_creation_input_tokens + output_tokens
+  // This is a per-call snapshot — output_tokens here are for THIS response only,
+  // not double-counted with future turns' input_tokens.
   const inputTokens = usage.input_tokens || 0;
   const cacheReadTokens = usage.cache_read_input_tokens || 0;
   const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
-  const totalUsed = inputTokens + cacheReadTokens + cacheCreationTokens;
+  const outputTokens = usage.output_tokens || 0;
+  const totalUsed = inputTokens + cacheReadTokens + cacheCreationTokens + outputTokens;
 
-  // Context window is the model's input limit
-  const contextWindow = parseInt(process.env.CONTEXT_WINDOW) || 200000;
+  const contextWindow = getContextWindowForModel(modelName);
 
-  console.log(`Token calculation: input=${inputTokens}, cacheRead=${cacheReadTokens}, cacheCreation=${cacheCreationTokens}, total=${totalUsed}/${contextWindow}`);
+  console.log(`Token calculation: model=${modelName}, input=${inputTokens}, cacheRead=${cacheReadTokens}, cacheCreation=${cacheCreationTokens}, output=${outputTokens}, total=${totalUsed}/${contextWindow}`);
 
   return {
     used: totalUsed,
@@ -469,6 +522,37 @@ async function queryClaudeSDK(command, options = {}, ws) {
       sdkOptions.mcpServers = mcpServers;
     }
 
+    // Inject compute-tools MCP server if an active compute node is configured
+    try {
+      const { getActiveNode } = await import('./compute-node.js');
+      const activeNode = await getActiveNode();
+      if (activeNode) {
+        const computeMcpPath = new URL('./mcp-compute.js', import.meta.url).pathname;
+        sdkOptions.mcpServers = {
+          ...(sdkOptions.mcpServers || {}),
+          'compute-tools': {
+            command: 'node',
+            args: [computeMcpPath],
+          },
+        };
+        // Append compute node context to system prompt
+        sdkOptions.appendSystemPrompt = [
+          sdkOptions.appendSystemPrompt || '',
+          '\n\n# Active Compute Node',
+          `A remote compute node "${activeNode.name}" (${activeNode.user}@${activeNode.host}) is configured and available.`,
+          `Type: ${activeNode.type === 'slurm' ? 'Slurm HPC cluster' : 'Direct GPU server'}.`,
+          `Work directory: ${activeNode.workDir || '~'}.`,
+          'When the user asks to run training, GPU tasks, or heavy computation, use the compute_* tools (compute_run, compute_sync, compute_slurm_submit, etc.) instead of local Bash.',
+          'Use compute_sync direction="up" to upload project code before running, and compute_run to execute commands remotely.',
+          'Use compute_info first if you need to check what GPU resources are available.',
+        ].join('\n');
+        console.log(`[claude-sdk] Compute MCP server injected for node "${activeNode.name}" (${activeNode.host})`);
+      }
+    } catch (err) {
+      // Compute node not configured or error loading — skip silently
+      console.log('[claude-sdk] No active compute node:', err.message);
+    }
+
     // Handle images - save to temp files and modify prompt
     const imageResult = await handleImages(command, options.images, options.cwd);
     const finalCommand = imageResult.modifiedCommand;
@@ -645,7 +729,7 @@ async function queryClaudeSDK(command, options = {}, ws) {
 
       // Send token budget update when the turn completes
       if (message.type === 'result') {
-        const tokenBudget = extractTokenBudgetFromUsage(lastAssistantUsage);
+        const tokenBudget = extractTokenBudgetFromUsage(lastAssistantUsage, options.model);
         if (tokenBudget) {
           console.log('Token budget from last assistant usage:', tokenBudget);
           ws.send({
@@ -788,6 +872,81 @@ function getActiveClaudeSDKSessions() {
   return getAllSessions();
 }
 
+const BTW_SYSTEM_PROMPT = `You answer a short side question for someone in the middle of a coding session.
+
+Rules:
+- You have NO tools. Do not claim to read files, run commands, or fetch URLs unless that information already appears in the conversation context below.
+- Use the "Conversation context" section plus general programming knowledge. If something is not in the context, say you do not see it there.
+- Be concise.`;
+
+/**
+ * One-shot, tool-free side question (Claude Code /btw-style). Does not resume the main SDK session.
+ */
+async function runClaudeBtw({ question, transcript, cwd, model, signal }) {
+  const safeTranscript =
+    typeof transcript === 'string' && transcript.trim()
+      ? transcript
+      : '(No prior conversation in this session.)';
+  const userBlock = `## Conversation context\n\n${safeTranscript}\n\n---\n\n## Side question\n\n${question}`;
+
+  const sdkOptions = {
+    cwd: cwd || process.cwd(),
+    model: model || CLAUDE_MODELS.DEFAULT,
+    tools: [],
+    allowedTools: [],
+    settingSources: [],
+    systemPrompt: BTW_SYSTEM_PROMPT,
+    permissionMode: 'default',
+  };
+
+  const prevStreamTimeout = process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
+  process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = '120000';
+
+  let answer = '';
+  let lastError = null;
+
+  try {
+    const queryInstance = query({
+      prompt: userBlock,
+      options: sdkOptions,
+    });
+
+    for await (const message of queryInstance) {
+      if (signal?.aborted) {
+        break;
+      }
+      if (message.type === 'result') {
+        if (message.subtype === 'success') {
+          answer = message.result || answer;
+        } else {
+          lastError = Array.isArray(message.errors) ? message.errors.join('\n') : 'Side question failed';
+        }
+      }
+    }
+  } catch (err) {
+    if (signal?.aborted) {
+      return { answer: '' };
+    }
+    throw new Error(err?.message || String(err));
+  } finally {
+    if (prevStreamTimeout !== undefined) {
+      process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = prevStreamTimeout;
+    } else {
+      delete process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
+    }
+  }
+
+  if (signal?.aborted) {
+    return { answer: '' };
+  }
+
+  if (lastError) {
+    throw new Error(lastError);
+  }
+
+  return { answer: answer || '' };
+}
+
 // Export public API
 export {
   queryClaudeSDK,
@@ -795,5 +954,7 @@ export {
   isClaudeSDKSessionActive,
   getClaudeSDKSessionStartTime,
   getActiveClaudeSDKSessions,
-  resolveToolApproval
+  resolveToolApproval,
+  getContextWindowForModel,
+  runClaudeBtw,
 };