dr-claw 1.1.3 → 1.1.4

package/server/gemini-cli.js

@@ -12,6 +12,8 @@ import { buildTempAttachmentFilename, toPortableAtPath } from './utils/imageAtta
 import { splitLegacyGeminiThoughtContent } from '../shared/geminiThoughtParser.js';
 import { classifyError } from '../shared/errorClassifier.js';
 import { buildGeminiThinkingConfig } from '../shared/geminiThinkingSupport.js';
+import { buildMemoryBlock } from './utils/memoryPrompt.js';
+import { expandSkillCommand } from './utils/skillExpander.js';
 
 // Use cross-spawn on Windows for better command execution
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
@@ -606,13 +608,22 @@ export async function spawnGemini(command, options = {}, ws) {
     }
 
     if (command && command.trim()) {
+      // Expand /skill-name slash commands into full SKILL.md instructions
+      // so the Gemini model receives actionable procedures.
+      const expandedCommand = await expandSkillCommand(command.trim(), workingDir);
+
       const effectiveAttachments = attachments || images;
-      const attachmentResult = await handleGeminiAttachments(command, effectiveAttachments, workingDir);
+      const attachmentResult = await handleGeminiAttachments(expandedCommand, effectiveAttachments, workingDir);
       tempFilePaths = attachmentResult.tempFilePaths;
       if (attachmentResult.tempDir) {
         tempDirs.push(attachmentResult.tempDir);
       }
-      const effectivePrompt = `${attachmentResult.modifiedCommand}`;
+      // Memory is prepended to the user prompt because Gemini CLI uses --prompt flag
+      // and does not expose a separate system instruction API.
+      const memoryBlock = options.userId ? buildMemoryBlock(options.userId) : '';
+      const effectivePrompt = memoryBlock
+        ? `${memoryBlock}\n\n${attachmentResult.modifiedCommand}`
+        : `${attachmentResult.modifiedCommand}`;
       args.push('--prompt', effectivePrompt);
 
       // Keep Gemini CLI in yolo mode internally and enforce policy in our own approval hook.

package/server/index.js

@@ -44,12 +44,13 @@ import mime from 'mime-types';
 
 import { getProjects, getTrashedProjects, getSessions, getSessionMessages, renameProject, renameSession, deleteSession, deleteProject, restoreProject, deleteTrashedProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache } from './projects.js';
 import { getProjectTokenUsageSummary } from './project-token-usage.js';
-import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getClaudeSDKSessionStartTime, getActiveClaudeSDKSessions, resolveToolApproval, getContextWindowForModel } from './claude-sdk.js';
+import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getClaudeSDKSessionStartTime, getActiveClaudeSDKSessions, resolveToolApproval } from './claude-sdk.js';
 import { spawnCursor, abortCursorSession, isCursorSessionActive, getCursorSessionStartTime, getActiveCursorSessions } from './cursor-cli.js';
 import { queryCodex, abortCodexSession, isCodexSessionActive, getCodexSessionStartTime, getActiveCodexSessions } from './openai-codex.js';
 import { spawnGemini, abortGeminiSession, isGeminiSessionActive, getGeminiSessionStartTime, getActiveGeminiSessions } from './gemini-cli.js';
 import { queryOpenRouter, abortOpenRouterSession, isOpenRouterSessionActive, getOpenRouterSessionStartTime, getActiveOpenRouterSessions } from './openrouter.js';
 import { queryLocalGPU, abortLocalGPUSession, isLocalGPUSessionActive, getLocalGPUSessionStartTime, getActiveLocalGPUSessions } from './local-gpu.js';
+import { spawnNanoClaudeCode, abortNanoClaudeCodeSession, isNanoClaudeCodeSessionActive, getNanoClaudeCodeSessionStartTime, getActiveNanoClaudeCodeSessions } from './nano-claude-code.js';
 import gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
@@ -57,6 +58,7 @@ import cursorRoutes from './routes/cursor.js';
 import taskmasterRoutes from './routes/taskmaster.js';
 import mcpUtilsRoutes from './routes/mcp-utils.js';
 import commandsRoutes from './routes/commands.js';
+import claudeBtwRoutes from './routes/claude-btw.js';
 import settingsRoutes from './routes/settings.js';
 import agentRoutes from './routes/agent.js';
 import projectsRoutes, { WORKSPACES_ROOT, getWorkspacesRoot, validateWorkspacePath } from './routes/projects.js';
@@ -69,7 +71,6 @@ import computeRoutes from './routes/compute.js';
 import newsRoutes from './routes/news.js';
 import autoResearchRoutes from './routes/auto-research.js';
 import referencesRoutes from './routes/references.js';
-import communityToolsRoutes from './routes/community-tools.js';
 import { initializeDatabase, sessionDb, tagDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { IS_PLATFORM } from './constants/config.js';
@@ -85,13 +86,15 @@ import {
     setRuntimePortSync,
 } from './utils/runtimePorts.js';
 import { buildCodexTokenUsageFromJsonl } from './utils/sessionTokenUsage.js';
+import { getNanoDrClawSessionsRoot } from './nanoSessionPaths.js';
 
 // File system watchers for provider project/session folders
 const PROVIDER_WATCH_PATHS = [
     { provider: 'claude', rootPath: path.join(os.homedir(), '.claude', 'projects') },
     { provider: 'cursor', rootPath: path.join(os.homedir(), '.cursor', 'chats') },
     { provider: 'codex', rootPath: path.join(os.homedir(), '.codex', 'sessions') },
-    { provider: 'gemini', rootPath: path.join(os.homedir(), '.gemini', 'sessions') }
+    { provider: 'gemini', rootPath: path.join(os.homedir(), '.gemini', 'sessions') },
+    { provider: 'nano', rootPath: getNanoDrClawSessionsRoot() },
 ];
 const WATCHER_IGNORED_PATTERNS = [
     '**/node_modules/**',
@@ -131,6 +134,11 @@ function shouldProcessProjectsWatcherEvent(eventType, filePath, provider) {
         );
     }
 
+    if (provider === 'nano') {
+        const base = path.basename(String(filePath || '').replace(/\\/g, '/')).toLowerCase();
+        return base.endsWith('.json') && base.startsWith('drclaw-nano-');
+    }
+
     return true;
 }
 
@@ -420,7 +428,14 @@ const wss = new WebSocketServer({
 // Make WebSocket server available to routes
 app.locals.wss = wss;
 
-app.use(cors());
+// Parse VITE_PORT early so CORS reflects the actual frontend port.
+const CORS_VITE_PORT = parsePortNumber(process.env.VITE_PORT, DEFAULT_FRONTEND_PORT);
+app.use(cors({
+  origin: process.env.DR_CLAW_CORS_ORIGINS
+    ? process.env.DR_CLAW_CORS_ORIGINS.split(',').map((o) => o.trim()).filter(Boolean)
+    : [`http://localhost:${getFrontendPortSync(CORS_VITE_PORT)}`, `http://127.0.0.1:${getFrontendPortSync(CORS_VITE_PORT)}`],
+  credentials: true,
+}));
 app.use(express.json({
   limit: '50mb',
   type: (req) => {
@@ -480,6 +495,9 @@ app.use('/api/mcp-utils', authenticateToken, mcpUtilsRoutes);
 // Commands API Routes (protected)
 app.use('/api/commands', authenticateToken, commandsRoutes);
 
+// Claude ephemeral side question (/btw)
+app.use('/api/claude', authenticateToken, claudeBtwRoutes);
+
 // Settings API Routes (protected)
 app.use('/api/settings', authenticateToken, settingsRoutes);
 
@@ -510,9 +528,6 @@ app.use('/api/auto-research', authenticateToken, autoResearchRoutes);
 // References (literature library) API Routes (protected)
 app.use('/api/references', authenticateToken, referencesRoutes);
 
-// Community Tools API Routes (protected)
-app.use('/api/community-tools', authenticateToken, communityToolsRoutes);
-
 // Agent API Routes (uses API key authentication)
 app.use('/api/agent', agentRoutes);
 
@@ -1690,6 +1705,35 @@ function handleChatConnection(ws, request) {
                 queryLocalGPU(data.command, { ...data.options, env: sessionEnv }, writer).catch(error => {
                     console.error('[ERROR] Local GPU query error:', error);
                 });
+            } else if (data.type === 'nano-command') {
+                console.log('[DEBUG] Nano Claude Code message:', data.command || '[Continue/Resume]');
+                console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
+                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
+                console.log('🤖 Model:', data.options?.model || 'default');
+                const commandTelemetryEnabled = data.options?.telemetryEnabled !== false;
+                const sessionId = data.options?.sessionId || data.sessionId;
+
+                if (sessionId && isNanoClaudeCodeSessionActive(sessionId)) {
+                    console.log(`[WARN] Nano Claude Code session ${sessionId} is already active. Ignoring concurrent request.`);
+                    return;
+                }
+
+                enqueueConversationTelemetry(
+                    {
+                        name: 'agent_dialogue_meta',
+                        direction: 'user_to_agent',
+                        provider: 'nano',
+                        sessionId: sessionId || null,
+                        projectPath: data.options?.projectPath || data.options?.cwd || null,
+                        transportType: data.type,
+                    },
+                    { ...telemetryContext, telemetryEnabled: commandTelemetryEnabled },
+                );
+                writer.telemetryContext = { ...telemetryContext, provider: 'nano', telemetryEnabled: commandTelemetryEnabled };
+                writer.setProjectPath(data.options?.projectPath || data.options?.cwd || null);
+                spawnNanoClaudeCode(data.command, { ...data.options, env: sessionEnv }, writer).catch(error => {
+                    console.error('[ERROR] Nano Claude Code error:', error);
+                });
             } else if (data.type === 'cursor-resume') {
                 // Backward compatibility: treat as cursor-command with resume and no prompt
                 console.log('[DEBUG] Cursor resume session (compat):', data.sessionId);
@@ -1723,6 +1767,8 @@ function handleChatConnection(ws, request) {
                     success = abortOpenRouterSession(data.sessionId);
                 } else if (provider === 'local') {
                     success = abortLocalGPUSession(data.sessionId);
+                } else if (provider === 'nano') {
+                    success = abortNanoClaudeCodeSession(data.sessionId);
                 } else {
                     // Use Claude Agents SDK
                     success = await abortClaudeSDKSession(data.sessionId);
@@ -1777,6 +1823,9 @@ function handleChatConnection(ws, request) {
                 } else if (provider === 'local') {
                     isActive = isLocalGPUSessionActive(sessionId);
                     startTime = getLocalGPUSessionStartTime(sessionId);
+                } else if (provider === 'nano') {
+                    isActive = isNanoClaudeCodeSessionActive(sessionId);
+                    startTime = getNanoClaudeCodeSessionStartTime(sessionId);
                 } else {
                     // Use Claude Agents SDK
                     isActive = isClaudeSDKSessionActive(sessionId);
@@ -1797,7 +1846,8 @@ function handleChatConnection(ws, request) {
                     cursor: getActiveCursorSessions(),
                     codex: getActiveCodexSessions(),
                     gemini: getActiveGeminiSessions(),
-                    local: getActiveLocalGPUSessions()
+                    local: getActiveLocalGPUSessions(),
+                    nano: getActiveNanoClaudeCodeSessions()
                 };
 
                 writer.send({
@@ -2805,7 +2855,6 @@ app.get('/api/projects/:projectName/sessions/:sessionId/token-usage', authentica
     let inputTokens = 0;
     let cacheCreationTokens = 0;
     let cacheReadTokens = 0;
-    let outputTokens = 0;
     let modelName = null;
 
     // Find the latest assistant message with usage data (scan from end)
@@ -2821,7 +2870,6 @@ app.get('/api/projects/:projectName/sessions/:sessionId/token-usage', authentica
           inputTokens = usage.input_tokens || 0;
           cacheCreationTokens = usage.cache_creation_input_tokens || 0;
           cacheReadTokens = usage.cache_read_input_tokens || 0;
-          outputTokens = usage.output_tokens || 0;
           modelName = entry.message.model || null;
 
           break; // Stop after finding the latest assistant message
@@ -2832,12 +2880,42 @@ app.get('/api/projects/:projectName/sessions/:sessionId/token-usage', authentica
       }
     }
 
-    // Determine context window from model name (model lookup > env var > default)
-    const contextWindow = getContextWindowForModel(modelName);
+    // Determine context window from model name
+    const MODEL_CONTEXT_WINDOWS = {
+      '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,
+    };
+
+    // Priority: env var override > model-based lookup > default
+    const parsedContextWindow = parseInt(process.env.CONTEXT_WINDOW, 10);
+    let contextWindow;
+    if (Number.isFinite(parsedContextWindow)) {
+      contextWindow = parsedContextWindow;
+    } else if (modelName) {
+      // Try exact match first, then prefix match
+      contextWindow = MODEL_CONTEXT_WINDOWS[modelName];
+      if (!contextWindow) {
+        const prefix = Object.keys(MODEL_CONTEXT_WINDOWS).find(k => modelName.startsWith(k));
+        contextWindow = prefix ? MODEL_CONTEXT_WINDOWS[prefix] : 200000;
+      }
+    } else {
+      contextWindow = 200000;
+    }
 
-    // Calculate total context usage (input + output share the same context window)
-    // This is a per-call snapshot from the latest assistant message, no cross-turn double-counting.
-    const totalUsed = inputTokens + cacheCreationTokens + cacheReadTokens + outputTokens;
+    // Calculate total context usage (excluding output_tokens, as per ccusage)
+    const totalUsed = inputTokens + cacheCreationTokens + cacheReadTokens;
 
     res.json({
       used: totalUsed,
@@ -2846,8 +2924,7 @@ app.get('/api/projects/:projectName/sessions/:sessionId/token-usage', authentica
       breakdown: {
         input: inputTokens,
         cacheCreation: cacheCreationTokens,
-        cacheRead: cacheReadTokens,
-        output: outputTokens
+        cacheRead: cacheReadTokens
       }
     });
   } catch (error) {

package/server/load-env.js

@@ -42,6 +42,18 @@ function resolveDefaultDatabasePath() {
   }
 }
 
+function stripOptionalEnvQuotes(raw) {
+  const v = String(raw).trim();
+  if (v.length >= 2) {
+    const open = v[0];
+    const close = v[v.length - 1];
+    if ((open === '"' && close === '"') || (open === "'" && close === "'")) {
+      return v.slice(1, -1);
+    }
+  }
+  return v;
+}
+
 try {
   const envPath = path.join(__dirname, '../.env');
   const envFile = fs.readFileSync(envPath, 'utf8');
@@ -50,7 +62,7 @@ try {
     if (trimmedLine && !trimmedLine.startsWith('#')) {
       const [key, ...valueParts] = trimmedLine.split('=');
       if (key && valueParts.length > 0 && !process.env[key]) {
-        process.env[key] = valueParts.join('=').trim();
+        process.env[key] = stripOptionalEnvQuotes(valueParts.join('='));
       }
     }
   });

package/server/local-gpu.js

@@ -19,6 +19,7 @@ import { writeProjectTemplates } from './templates/index.js';
 import { classifyError } from '../shared/errorClassifier.js';
 import { applyStageTagsToSession, recordIndexedSession } from './utils/sessionIndex.js';
 import { createRequestId, waitForToolApproval, matchesToolPermission } from './utils/permissions.js';
+import { buildMemoryBlock } from './utils/memoryPrompt.js';
 
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
@@ -763,7 +764,8 @@ export async function queryLocalGPU(command, options = {}, ws) {
       projectName: workingDirectory ? encodeProjectPath(workingDirectory) : undefined,
     });
 
-    const systemContent = customSystemPrompt || await buildSystemPrompt(workingDirectory);
+    const memoryBlock = options.userId ? buildMemoryBlock(options.userId) : '';
+    const systemContent = (customSystemPrompt || await buildSystemPrompt(workingDirectory)) + memoryBlock;
     const messages = [{ role: 'system', content: systemContent }];
 
     if (sessionId) {

package/server/nano-claude-code.js

@@ -0,0 +1,340 @@
+/**
+ * Nano Claude Code provider — spawns the nano-claude-code CLI in stream-json harness mode.
+ * Uses the same WebSocket shapes as Claude (claude-response / claude-complete) for UI reuse.
+ *
+ * Requires a nano-claude-code build that supports:
+ *   --output-format stream-json -p "..." --dangerously-skip-permissions
+ *   --session-file <path.json> and --resume <path.json> for multi-turn persistence (absolute path under ~/.dr-claw/nano-sessions)
+ *   result lines may include nano_session_file (optional)
+ * Install: https://github.com/OpenLAIR/nano-claude-code — pip install from that repo or use the published CLI name on PATH.
+ */
+
+import { spawn } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import crypto from 'crypto';
+import { encodeProjectPath, ensureProjectSkillLinks } from './projects.js';
+import { writeProjectTemplates } from './templates/index.js';
+import { applyStageTagsToSession, recordIndexedSession } from './utils/sessionIndex.js';
+import { ensureNanoDrClawSessionsRoot, resolveNanoSessionAbsPath } from './nanoSessionPaths.js';
+
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+const activeNanoSessions = new Map();
+
+let nanoShutdownHooksInstalled = false;
+
+function installNanoProcessShutdownHooks() {
+  if (nanoShutdownHooksInstalled) {
+    return;
+  }
+  nanoShutdownHooksInstalled = true;
+  const shutdown = () => {
+    for (const { process: childProc } of activeNanoSessions.values()) {
+      try {
+        if (childProc && !childProc.killed) {
+          childProc.kill('SIGTERM');
+        }
+      } catch (_) {
+        // ignore
+      }
+    }
+    activeNanoSessions.clear();
+  };
+  process.on('exit', shutdown);
+  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(sig, shutdown);
+  }
+}
+
+function resolveNanoCommand() {
+  const explicit = String(
+    process.env.NANO_CLAUDE_CODE_COMMAND || ''
+  ).trim();
+  if (explicit) {
+    return explicit;
+  }
+  return 'nano-claude-code';
+}
+
+async function persistNanoSessionMetadata(sessionId, projectPath, sessionMode) {
+  if (!sessionId || !projectPath) return;
+  try {
+    const { sessionDb } = await import('./database/db.js');
+    sessionDb.upsertSession(
+      sessionId,
+      encodeProjectPath(projectPath),
+      'nano',
+      'Nano Claude Code Session',
+      new Date().toISOString(),
+      0,
+      { sessionMode: sessionMode || 'research', projectPath },
+    );
+  } catch (error) {
+    console.warn('[Nano] Failed to persist session metadata:', error.message);
+  }
+}
+
+export async function spawnNanoClaudeCode(command, options = {}, ws) {
+  installNanoProcessShutdownHooks();
+  const {
+    sessionId,
+    projectPath,
+    cwd,
+    model,
+    env,
+    sessionMode,
+    stageTagKeys,
+    stageTagSource = 'task_context',
+  } = options;
+
+  const workingDir = cwd || projectPath || process.cwd();
+
+  try {
+    await writeProjectTemplates(workingDir);
+    await ensureProjectSkillLinks(workingDir);
+  } catch (error) {
+    console.warn('[Nano] Project template setup:', error.message);
+  }
+
+  const streaming = String(
+    process.env.NANO_CLAUDE_CODE_STREAMING || ''
+  ).trim() === '1';
+
+  const isPlaceholderSession =
+    !sessionId ||
+    String(sessionId).startsWith('new-session-');
+
+  const capturedSessionId = isPlaceholderSession ? crypto.randomUUID() : String(sessionId);
+
+  await ensureNanoDrClawSessionsRoot();
+  const sessionAbsPath = resolveNanoSessionAbsPath(capturedSessionId);
+  if (!sessionAbsPath) {
+    const err = 'Invalid Nano Claude Code session id';
+    ws.send({ type: 'claude-error', error: err, sessionId: null });
+    return Promise.reject(new Error(err));
+  }
+
+  if (capturedSessionId && workingDir) {
+    applyStageTagsToSession({
+      sessionId: capturedSessionId,
+      projectPath: workingDir,
+      stageTagKeys,
+      source: stageTagSource,
+    });
+  }
+
+  if (isPlaceholderSession) {
+    recordIndexedSession({
+      sessionId: capturedSessionId,
+      provider: 'nano',
+      projectPath: workingDir,
+      sessionMode: sessionMode || 'research',
+      stageTagKeys,
+      tagSource: stageTagSource,
+    });
+    ws.send({
+      type: 'session-created',
+      sessionId: capturedSessionId,
+      provider: 'nano',
+      mode: sessionMode || 'research',
+      projectName: encodeProjectPath(workingDir),
+    });
+  }
+
+  if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+    ws.setSessionId(capturedSessionId);
+  }
+
+  await persistNanoSessionMetadata(capturedSessionId, workingDir, sessionMode);
+
+  const nanoCmd = resolveNanoCommand();
+  const args = [
+    '--output-format', 'stream-json',
+    '-p', command,
+    '--dangerously-skip-permissions',
+    '--session-file', sessionAbsPath,
+  ];
+  if (!isPlaceholderSession) {
+    args.push('--resume', sessionAbsPath);
+  }
+  if (streaming) {
+    args.push('--streaming');
+  }
+  if (model) {
+    args.push('--model', model);
+  }
+
+  console.log('[Nano] spawn:', nanoCmd, args.join(' '));
+  console.log('[Nano] cwd:', workingDir);
+
+  return new Promise((resolve, reject) => {
+    const child = spawnFunction(nanoCmd, args, {
+      cwd: workingDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...(env || process.env) },
+    });
+
+    activeNanoSessions.set(capturedSessionId, { process: child, startTime: Date.now() });
+
+    const getSessionStartTime = () => activeNanoSessions.get(capturedSessionId)?.startTime;
+
+    let stdoutBuf = '';
+
+    child.stdout.on('data', (data) => {
+      stdoutBuf += data.toString();
+      const lines = stdoutBuf.split('\n');
+      stdoutBuf = lines.pop() || '';
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t) continue;
+        try {
+          const response = JSON.parse(t);
+          switch (response.type) {
+            case 'assistant':
+              if (response.message) {
+                ws.send({
+                  type: 'claude-response',
+                  data: {
+                    type: 'assistant',
+                    message: response.message,
+                    startTime: getSessionStartTime(),
+                  },
+                  sessionId: capturedSessionId,
+                });
+              }
+              break;
+            case 'user':
+              if (response.message) {
+                ws.send({
+                  type: 'claude-response',
+                  data: {
+                    type: 'user',
+                    message: response.message,
+                    startTime: getSessionStartTime(),
+                  },
+                  sessionId: capturedSessionId,
+                });
+              }
+              break;
+            case 'stream_delta':
+              if (response.content && (response.delta_type === 'text' || response.delta_type === 'thinking')) {
+                ws.send({
+                  type: 'claude-response',
+                  data: {
+                    type: 'content_block_delta',
+                    startTime: getSessionStartTime(),
+                    delta: { type: 'text_delta', text: response.content },
+                  },
+                  sessionId: capturedSessionId,
+                });
+              }
+              break;
+            case 'result': {
+              const u = response.usage || {};
+              const input = Number(u.input_tokens) || 0;
+              const output = Number(u.output_tokens) || 0;
+              const cacheCreate = Number(u.cache_creation_input_tokens) || 0;
+              const cacheRead = Number(u.cache_read_input_tokens) || 0;
+              if (input || output || cacheCreate || cacheRead) {
+                const total = parseInt(process.env.CONTEXT_WINDOW || process.env.VITE_CONTEXT_WINDOW || '200000', 10);
+                ws.send({
+                  type: 'token-budget',
+                  data: {
+                    used: input + output + cacheCreate + cacheRead,
+                    total,
+                    breakdown: {
+                      input,
+                      output,
+                      cacheCreation: cacheCreate,
+                      cacheRead,
+                    },
+                  },
+                  sessionId: capturedSessionId,
+                });
+              }
+              break;
+            }
+            default:
+              break;
+          }
+        } catch {
+          console.warn('[Nano] Ignoring non-JSON stdout line:', t.slice(0, 200));
+        }
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      const msg = data.toString().trim();
+      if (!msg) return;
+      console.error('[Nano] stderr:', msg);
+      ws.send({
+        type: 'claude-error',
+        error: msg.slice(0, 2000),
+        sessionId: capturedSessionId,
+      });
+    });
+
+    child.on('close', async (code) => {
+      activeNanoSessions.delete(capturedSessionId);
+      ws.send({
+        type: 'claude-complete',
+        sessionId: capturedSessionId,
+        exitCode: code,
+        isNewSession: isPlaceholderSession && Boolean(command && String(command).trim()),
+      });
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`nano-claude-code exited with code ${code}`));
+      }
+    });
+
+    child.on('error', (error) => {
+      activeNanoSessions.delete(capturedSessionId);
+      ws.send({
+        type: 'claude-error',
+        error: error.message,
+        sessionId: capturedSessionId,
+      });
+      reject(error);
+    });
+  });
+}
+
+export function abortNanoClaudeCodeSession(sessionId) {
+  const sessionData = activeNanoSessions.get(sessionId);
+  if (sessionData?.process) {
+    console.log(`[Nano] Aborting session: ${sessionId}`);
+    sessionData.process.kill('SIGTERM');
+    activeNanoSessions.delete(sessionId);
+    return true;
+  }
+  return false;
+}
+
+export function isNanoClaudeCodeSessionActive(sessionId) {
+  return activeNanoSessions.has(sessionId);
+}
+
+export function getNanoClaudeCodeSessionStartTime(sessionId) {
+  const sessionData = activeNanoSessions.get(sessionId);
+  return sessionData ? sessionData.startTime : null;
+}
+
+export function getActiveNanoClaudeCodeSessions() {
+  return Array.from(activeNanoSessions.keys());
+}
+
+/** Kill all in-flight Nano CLI children (e.g. before process exit). */
+export function killAllNanoClaudeCodeChildren() {
+  for (const { process: childProc } of activeNanoSessions.values()) {
+    try {
+      if (childProc && !childProc.killed) {
+        childProc.kill('SIGTERM');
+      }
+    } catch (_) {
+      // ignore
+    }
+  }
+  activeNanoSessions.clear();
+}