@jlongo78/agent-spaces 0.9.7 → 0.9.8

package/.next/standalone/src/app/api/network/sessions/route.ts

@@ -2,6 +2,7 @@ import { NextRequest } from 'next/server';
 import { getPro } from '@/lib/pro';
 import { ensureInitialized } from '@/lib/db/init';
 import { getSessions, getWorkspacesForSession } from '@/lib/db/queries';
+import { withUser } from '@/lib/auth';
 
 const notAvailable = () =>
   Response.json({ error: 'Requires @spaces/pro' }, { status: 404 });
@@ -10,8 +11,9 @@ export async function GET(req: NextRequest) {
   const pro = getPro();
   if (!pro) return notAvailable();
 
+  let keyRecord;
   try {
-    pro.network.requireNetworkAuth(req);
+    keyRecord = pro.network.requireNetworkAuth(req);
   } catch (e: any) {
     if (e.name === 'NetworkAuthError') {
       return Response.json({ error: e.message }, { status: 401 });
@@ -19,25 +21,30 @@ export async function GET(req: NextRequest) {
     throw e;
   }
 
-  await ensureInitialized();
+  const keyUser = keyRecord?.username;
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
 
-  const { searchParams } = req.nextUrl;
-  const params = {
-    projectId: searchParams.get('projectId') || undefined,
-    projectPath: searchParams.get('projectPath') || undefined,
-    search: searchParams.get('search') || undefined,
-    sortBy: searchParams.get('sortBy') || 'modified',
-    sortDir: searchParams.get('sortDir') || 'DESC',
-    offset: parseInt(searchParams.get('offset') || '0', 10),
-    limit: parseInt(searchParams.get('limit') || '50', 10),
-  };
+  return withUser(keyUser, async () => {
+    await ensureInitialized();
 
-  const result = getSessions(params);
+    const { searchParams } = req.nextUrl;
+    const params = {
+      projectId: searchParams.get('projectId') || undefined,
+      projectPath: searchParams.get('projectPath') || undefined,
+      search: searchParams.get('search') || undefined,
+      sortBy: searchParams.get('sortBy') || 'modified',
+      sortDir: searchParams.get('sortDir') || 'DESC',
+      offset: parseInt(searchParams.get('offset') || '0', 10),
+      limit: parseInt(searchParams.get('limit') || '50', 10),
+    };
 
-  const sessions = result.sessions.map(s => ({
-    ...s,
-    workspaces: getWorkspacesForSession(s.id),
-  }));
+    const result = getSessions(params);
 
-  return Response.json({ sessions, total: result.total });
+    const sessions = result.sessions.map(s => ({
+      ...s,
+      workspaces: getWorkspacesForSession(s.id),
+    }));
+
+    return Response.json({ sessions, total: result.total });
+  });
 }

package/.next/standalone/src/app/api/network/workspaces/[id]/route.ts

@@ -21,16 +21,15 @@ export async function GET(req: NextRequest, { params }: { params: Promise<{ id:
     throw e;
   }
 
-  const { id } = await params;
   const keyUser = keyRecord?.username;
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
 
-  const handler = async () => {
+  const { id } = await params;
+  return withUser(keyUser, async () => {
     await ensureInitialized();
     const panes = getPanesByWorkspace(parseInt(id, 10));
     return Response.json({ panes });
-  };
-
-  return keyUser ? withUser(keyUser, handler) : handler();
+  });
 }
 
 export async function PUT(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
@@ -45,11 +44,16 @@ export async function PUT(req: NextRequest, { params }: { params: Promise<{ id:
   }
   if (keyRecord?.permissions !== 'admin') return Response.json({ error: 'Admin permission required' }, { status: 403 });
 
+  const keyUser = keyRecord?.username;
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
+
   const { id } = await params;
-  await ensureInitialized();
-  const body = await req.json();
-  updateWorkspace(parseInt(id, 10), body);
-  return Response.json({ success: true });
+  return withUser(keyUser, async () => {
+    await ensureInitialized();
+    const body = await req.json();
+    updateWorkspace(parseInt(id, 10), body);
+    return Response.json({ success: true });
+  });
 }
 
 export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
@@ -64,8 +68,13 @@ export async function DELETE(req: NextRequest, { params }: { params: Promise<{ i
   }
   if (keyRecord?.permissions !== 'admin') return Response.json({ error: 'Admin permission required' }, { status: 403 });
 
+  const keyUser = keyRecord?.username;
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
+
   const { id } = await params;
-  await ensureInitialized();
-  deleteWorkspaceFull(parseInt(id, 10));
-  return Response.json({ success: true });
+  return withUser(keyUser, async () => {
+    await ensureInitialized();
+    deleteWorkspaceFull(parseInt(id, 10));
+    return Response.json({ success: true });
+  });
 }

package/.next/standalone/src/app/api/network/workspaces/route.ts

@@ -3,6 +3,7 @@ import { getPro } from '@/lib/pro';
 import { ensureInitialized } from '@/lib/db/init';
 import { getDb } from '@/lib/db/schema';
 import { createWorkspace } from '@/lib/db/queries';
+import { withUser } from '@/lib/auth';
 
 const notAvailable = () =>
   Response.json({ error: 'Requires @spaces/pro' }, { status: 404 });
@@ -23,16 +24,12 @@ export async function GET(req: NextRequest) {
 
   // Scope to the API key's user so remote access sees their workspaces, not the server admin's
   const keyUser = keyRecord?.username;
-  if (keyUser) {
-    const { withUser } = await import('@/lib/auth');
-    return withUser(keyUser, async () => {
-      await ensureInitialized();
-      return buildWorkspaceResponse();
-    });
-  }
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
 
-  await ensureInitialized();
-  return buildWorkspaceResponse();
+  return withUser(keyUser, async () => {
+    await ensureInitialized();
+    return buildWorkspaceResponse();
+  });
 }
 
 export async function POST(req: NextRequest) {
@@ -50,12 +47,17 @@ export async function POST(req: NextRequest) {
     return Response.json({ error: 'Admin permission required' }, { status: 403 });
   }
 
-  await ensureInitialized();
-  const body = await req.json();
-  if (!body.name) return Response.json({ error: 'name is required' }, { status: 400 });
+  const keyUser = keyRecord?.username;
+  if (!keyUser) return Response.json({ error: 'API key missing user binding' }, { status: 401 });
+
+  return withUser(keyUser, async () => {
+    await ensureInitialized();
+    const body = await req.json();
+    if (!body.name) return Response.json({ error: 'name is required' }, { status: 400 });
 
-  const workspace = createWorkspace(body.name, body.description, body.color);
-  return Response.json(workspace);
+    const workspace = createWorkspace(body.name, body.description, body.color);
+    return Response.json(workspace);
+  });
 }
 
 function buildWorkspaceResponse() {

package/.next/standalone/src/app/api/whisper/config/route.ts

@@ -1,27 +1,35 @@
 import { NextResponse } from 'next/server';
-import { readCortexConfig } from '@/lib/cortex/config';
-import { getUserPaths } from '@/lib/config';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 
 export const dynamic = 'force-dynamic';
 
 /**
  * GET /api/whisper/config — returns Groq/OpenAI key + endpoint for direct browser calls.
- * Checks cortex config first (user settings), then falls back to env vars.
+ * Reads config.json directly (bypasses cortex addon to avoid stale require cache).
+ * Falls back to env vars.
  */
 export async function GET() {
-  // Try cortex config first (user-configured keys in settings)
   let configGroq = '';
   let configOpenai = '';
+
+  // Read config.json directly instead of going through cortex addon
   try {
-    const { configPath } = getUserPaths('admin');
-    const cortexCfg = readCortexConfig(configPath);
-    configGroq = cortexCfg.groq_api_key || '';
-    configOpenai = cortexCfg.openai_api_key || '';
+    const configPath = path.join(os.homedir(), '.spaces', 'config.json');
+    if (fs.existsSync(configPath)) {
+      const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      const cortex = raw.cortex || {};
+      configGroq = cortex.groq_api_key || '';
+      configOpenai = cortex.openai_api_key || '';
+    }
   } catch {}
 
   const groqKey = configGroq || process.env.GROQ_API_KEY;
   const openaiKey = configOpenai || process.env.OPENAI_API_KEY;
 
+  console.log(`[Whisper Config] configGroq=${configGroq ? configGroq.slice(0, 8) + '...' : 'EMPTY'} configOpenai=${configOpenai ? configOpenai.slice(0, 8) + '...' : 'EMPTY'} envGroq=${process.env.GROQ_API_KEY ? 'SET' : 'UNSET'} envOpenai=${process.env.OPENAI_API_KEY ? 'SET' : 'UNSET'} → returning ${groqKey ? 'GROQ' : openaiKey ? 'OPENAI' : 'NONE'}`);
+
   if (groqKey) {
     return NextResponse.json({
       apiKey: groqKey,

package/.next/standalone/src/app/api/wizard/chart/route.ts

@@ -0,0 +1,129 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAuthUser, withUser } from '@/lib/auth';
+import { getUserPaths } from '@/lib/config';
+
+export const dynamic = 'force-dynamic';
+
+const SYSTEM_PROMPT = `You are a data visualization assistant. Your job: help the user design a chart from their data through conversation. Ask 1-2 questions at a time. Converge toward a concrete chart spec.
+
+Supported chart types:
+- bar: Vertical or horizontal bar chart
+- line: Line chart with optional area fill
+- pie: Pie or donut chart
+- scatter: Scatter plot with optional trend line
+- heatmap: Color-coded grid/matrix
+- table: Formatted data table with highlights
+
+After each exchange, output an updated chart spec as a JSON block.
+
+For SINGLE-SERIES data (bar, pie, scatter, simple line), use this format:
+
+\`\`\`json
+{
+  "chart": { "title": "...", "type": "bar", "xAxis": "...", "yAxis": "...", "color": "#6366f1" },
+  "data": [
+    { "label": "Q1", "value": 100 },
+    { "label": "Q2", "value": 150 }
+  ],
+  "options": { "showLegend": true, "stacked": false, "fillArea": false },
+  "summary": "One-line description"
+}
+\`\`\`
+
+For MULTI-SERIES data (multiple lines, grouped comparison), use this format:
+
+\`\`\`json
+{
+  "chart": { "title": "...", "type": "line", "xAxis": "...", "yAxis": "...", "color": "#6366f1" },
+  "data": [],
+  "labels": ["Jan", "Feb", "Mar"],
+  "series": [
+    { "name": "East", "color": "#6366f1", "values": [100, 120, 140] },
+    { "name": "West", "color": "#22c55e", "values": [80, 95, 110] }
+  ],
+  "options": { "showLegend": true, "stacked": false, "fillArea": false },
+  "summary": "One-line description"
+}
+\`\`\`
+
+Available series colors: #6366f1, #22c55e, #f59e0b, #ef4444, #3b82f6, #ec4899, #14b8a6, #a855f7, #f97316
+
+Guidelines:
+- Ask about: what data they have, what story they want to tell, audience, preferred chart type
+- Suggest chart types based on the data shape (categorical → bar/pie, time series → line, correlation → scatter)
+- Use multi-series format when the user asks for multiple lines, regions, categories, or comparisons
+- Generate sample data if the user describes their data verbally
+- Keep it simple — one chart at a time
+- When the spec looks solid, suggest the user review it`;
+
+export async function POST(request: NextRequest) {
+  const user = getAuthUser(request);
+  return withUser(user, async () => {
+    const { configPath } = getUserPaths(user);
+    let config: any = {};
+    try {
+      const { readCortexConfig } = await import('@/lib/cortex/config');
+      config = readCortexConfig(configPath);
+    } catch {}
+
+    const anthropicKey = config.anthropic_api_key || process.env.ANTHROPIC_API_KEY;
+    if (!anthropicKey) {
+      return NextResponse.json(
+        { error: 'No API key configured. Add your Anthropic key in Settings > Cortex.' },
+        { status: 400 }
+      );
+    }
+
+    const body = await request.json();
+    const { messages, currentSpec } = body;
+
+    const apiMessages = messages.map((m: any) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    let systemPrompt = SYSTEM_PROMPT;
+    if (currentSpec) {
+      systemPrompt += `\n\nCurrent chart spec:\n\`\`\`json\n${JSON.stringify(currentSpec, null, 2)}\n\`\`\``;
+    }
+
+    try {
+      const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': anthropicKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+          model: 'claude-haiku-4-5-20251001',
+          max_tokens: 2048,
+          system: systemPrompt,
+          messages: apiMessages,
+        }),
+        signal: AbortSignal.timeout(30000),
+      });
+
+      if (!res.ok) {
+        return NextResponse.json({ error: `API error: ${res.status}` }, { status: 502 });
+      }
+
+      const data = await res.json();
+      const reply = data.content?.[0]?.text || '';
+
+      // Extract JSON spec from reply
+      let spec = currentSpec;
+      const jsonMatch = reply.match(/```json\s*([\s\S]*?)```/);
+      if (jsonMatch) {
+        try {
+          spec = JSON.parse(jsonMatch[1]);
+        } catch { /* keep current spec */ }
+      }
+
+      const cleanReply = reply.replace(/```json[\s\S]*?```/g, '').trim();
+      return NextResponse.json({ reply: cleanReply, spec });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  });
+}

package/.next/standalone/src/components/cortex/benchmark-tab.tsx

@@ -310,6 +310,7 @@ function RunLauncher({ onRunComplete }: { onRunComplete: () => void }) {
   const [selectedCategories, setSelectedCategories] = useState<string[]>([]);
   const [customModel, setCustomModel] = useState('claude-haiku-4-5');
   const [noJudge, setNoJudge] = useState(false);
+  const [concurrency, setConcurrency] = useState(1);
   const [showCustom, setShowCustom] = useState(false);
 
   const isRunning = status?.running === true;
@@ -333,6 +334,7 @@ function RunLauncher({ onRunComplete }: { onRunComplete: () => void }) {
       categories: selectedCategories.length > 0 ? selectedCategories.join(',') : undefined,
       noJudge,
       model: customModel,
+      concurrency,
     });
   }
 
@@ -470,6 +472,18 @@ function RunLauncher({ onRunComplete }: { onRunComplete: () => void }) {
                   </select>
                 </div>
 
+                <div>
+                  <div className="text-[10px] text-gray-600 uppercase tracking-wider mb-1">Concurrency</div>
+                  <input
+                    type="number"
+                    min={1}
+                    max={5}
+                    value={concurrency}
+                    onChange={e => setConcurrency(Math.min(5, Math.max(1, parseInt(e.target.value) || 1)))}
+                    className="w-16 px-2.5 py-1 text-xs bg-white/5 border border-white/10 rounded-md text-gray-300 focus:outline-none focus:border-purple-500/50"
+                  />
+                </div>
+
                 <div className="flex items-center gap-2 mt-4">
                   <input
                     id="no-judge"

package/.next/standalone/src/components/terminal/terminal-pane.tsx

@@ -225,17 +225,33 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
       resolve();
     }));
 
-    // Ctrl-C copies selection; Ctrl-V: return false WITHOUT preventDefault so browser
-    // fires its paste event naturally — xterm's paste handler picks it up via onData.
+    // Ctrl-C: when there's a selection, copy it to clipboard then clear selection.
+    // We return false to stop xterm sending ^C (SIGINT), and manually write to clipboard
+    // since xterm's selection isn't in the browser's native Selection API.
+    // Ctrl-V: return false WITHOUT preventDefault so browser fires its native paste event
+    // which xterm's paste handler picks up via onData.
     term.attachCustomKeyEventHandler((ev: KeyboardEvent) => {
       if (ev.type !== 'keydown') return true;
       if (ev.ctrlKey && ev.key === 'c' && term.hasSelection()) {
-        navigator.clipboard?.writeText(term.getSelection());
+        const text = term.getSelection();
+        if (text && navigator.clipboard?.writeText) {
+          navigator.clipboard.writeText(text).catch(() => {
+            // Fallback: create a temporary textarea to copy
+            const ta = document.createElement('textarea');
+            ta.value = text;
+            ta.style.position = 'fixed';
+            ta.style.opacity = '0';
+            document.body.appendChild(ta);
+            ta.select();
+            document.execCommand('copy');
+            document.body.removeChild(ta);
+          });
+        }
         term.clearSelection();
         return false;
       }
       if (ev.ctrlKey && ev.key === 'v') {
-        return false; // stop xterm from sending \x16; browser paste event fires naturally
+        return false;
       }
       return true;
     });
@@ -415,9 +431,22 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
   };
 
   // ─── Quest toolbar: send keystrokes to terminal ───
+  // Debug helper: always logs to console; writes to xterm only when enabled via
+  // localStorage.setItem('spaces-voice-debug', '1')
+  const debugVoice = (msg: string) => {
+    console.log('[Voice]', msg);
+    try {
+      if (localStorage.getItem('spaces-voice-debug') && xtermRef.current) {
+        xtermRef.current.write(`\r\n\x1b[93m[Voice] ${msg}\x1b[0m\r\n`);
+      }
+    } catch {}
+  };
+
   const sendKey = (key: string) => {
     if (wsRef.current?.readyState === WebSocket.OPEN) {
       wsRef.current.send(JSON.stringify({ type: 'data', data: key }));
+    } else {
+      debugVoice(`sendKey failed: WebSocket state=${wsRef.current?.readyState}`);
     }
   };
 
@@ -427,6 +456,8 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
     if (wsRef.current?.readyState === WebSocket.OPEN) {
       const bracketed = `\x1b[200~${text}\x1b[201~`;
       wsRef.current.send(JSON.stringify({ type: 'data', data: bracketed }));
+    } else {
+      debugVoice(`sendPaste failed: WebSocket state=${wsRef.current?.readyState}`);
     }
   };
 
@@ -475,6 +506,7 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
           let text = '';
           if (cfg?.apiKey) {
             // Direct call to Groq/OpenAI — skip server proxy for speed
+            console.log('[Voice] Transcribing via', cfg.backend || 'direct');
             const form = new FormData();
             form.append('file', blob, 'audio.webm');
             form.append('model', cfg.model);
@@ -488,21 +520,29 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
             if (res.ok) {
               const data = await res.json();
               text = data.text || '';
+            } else {
+              console.error('[Voice] API error:', res.status, await res.text().catch(() => ''));
             }
           } else {
             // Fallback to server proxy
+            console.log('[Voice] Transcribing via server proxy, cfg:', cfg);
             const form = new FormData();
             form.append('audio', blob, 'dictation.webm');
             const res = await fetch('/api/whisper', { method: 'POST', body: form });
             if (res.ok) {
               const data = await res.json();
               text = data.text || '';
+            } else {
+              console.error('[Voice] Server proxy error:', res.status, await res.text().catch(() => ''));
             }
           }
+          console.log('[Voice] Result:', JSON.stringify(text));
           if (text.trim()) {
             setQuestInput(prev => prev ? `${prev} ${text.trim()}` : text.trim());
           }
-        } catch {}
+        } catch (err) {
+          console.error('[Voice] Exception:', err);
+        }
         setQuestMicStatus('off');
       };
 
@@ -556,8 +596,14 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
     try {
       // Fetch config once, cache for subsequent cycles
       if (!questWhisperCfgRef.current) {
+        debugVoice('Fetching whisper config...');
         const cfgRes = await fetch('/api/whisper/config');
-        if (cfgRes.ok) questWhisperCfgRef.current = await cfgRes.json();
+        if (cfgRes.ok) {
+          questWhisperCfgRef.current = await cfgRes.json();
+          debugVoice(`Config: backend=${questWhisperCfgRef.current?.backend || 'none'} hasKey=${!!questWhisperCfgRef.current?.apiKey}`);
+        } else {
+          debugVoice(`Config fetch failed: ${cfgRes.status} ${await cfgRes.text().catch(() => '')}`);
+        }
       }
       if (!questImmersiveRef.current) return;
 
@@ -588,6 +634,7 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
 
         // No speech — restart or clean up
         if (!hasSpeech || chunks.length === 0) {
+          debugVoice(`No speech detected (hasSpeech=${hasSpeech} chunks=${chunks.length}) — restarting`);
           questDrainingRef.current = false;
           if (questImmersiveRef.current) setTimeout(startImmersiveCycle, 300);
           else setQuestMicStatus('off');
@@ -595,13 +642,15 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
         }
 
         const blob = new Blob(chunks, { type: 'audio/webm' });
-        if (blob.size < 500) { setTimeout(startImmersiveCycle, 300); return; }
+        if (blob.size < 500) { debugVoice(`Blob too small (${blob.size}b) — restarting`); setTimeout(startImmersiveCycle, 300); return; }
 
         setQuestMicStatus('transcribing');
         const cfg = questWhisperCfgRef.current;
+        debugVoice(`Transcribing blob=${blob.size}b hasCfg=${!!cfg} hasKey=${!!cfg?.apiKey}`);
         try {
           let text = '';
           if (cfg?.apiKey) {
+            debugVoice(`Calling ${cfg.backend}: ${cfg.apiUrl}`);
             const form = new FormData();
             form.append('file', blob, 'audio.webm');
             form.append('model', cfg.model);
@@ -612,23 +661,39 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
               headers: { 'Authorization': `Bearer ${cfg.apiKey}` },
               body: form,
             });
-            if (res.ok) text = (await res.json()).text || '';
+            if (res.ok) {
+              text = (await res.json()).text || '';
+              debugVoice(`Transcribed: "${text}"`);
+            } else {
+              const errBody = await res.text().catch(() => '');
+              debugVoice(`API error: ${res.status} ${errBody.slice(0, 200)}`);
+            }
           } else {
+            debugVoice('No API key — using server proxy /api/whisper');
             const form = new FormData();
             form.append('audio', blob, 'dictation.webm');
             const res = await fetch('/api/whisper', { method: 'POST', body: form });
-            if (res.ok) text = (await res.json()).text || '';
+            if (res.ok) {
+              text = (await res.json()).text || '';
+              debugVoice(`Transcribed: "${text}"`);
+            } else {
+              const errBody = await res.text().catch(() => '');
+              debugVoice(`Proxy error: ${res.status} ${errBody.slice(0, 200)}`);
+            }
           }
+          debugVoice(`Result: "${text}" ws=${wsRef.current?.readyState} immersive=${questImmersiveRef.current} draining=${questDrainingRef.current}`);
           if (text.trim() && (questImmersiveRef.current || questDrainingRef.current)) {
             if (immersiveAutoSendRef.current) {
-              // Single write: text + Enter in one message (avoids race between split sends)
+              debugVoice(`Sending: "${text.trim()}" + Enter`);
               sendKey(text.trim() + '\r');
             } else {
-              // No auto-send: put text in the input field so user can review/edit
+              debugVoice(`Putting in input: "${text.trim()}"`);
               setQuestInput((prev) => prev ? prev + ' ' + text.trim() : text.trim());
             }
           }
-        } catch {}
+        } catch (err: any) {
+          debugVoice(`Exception: ${err.message || err}`);
+        }
 
         // Loop: restart listening if still immersive, or clean up if draining
         questDrainingRef.current = false;
@@ -736,6 +801,7 @@ export function TerminalPane({ pane, onClose, onUpdate, isMaximized, onToggleMax
       }
       if (finalText.length > lastFinalLength) {
         const newText = finalText.slice(lastFinalLength);
+        console.log('[Voice] recognized:', JSON.stringify(newText.trim()), 'autoSend:', autoSend, 'ws:', wsRef.current?.readyState);
         if (autoSend && immersiveAutoSendRef.current) {
           // Single write: text + Enter in one message (avoids race between split sends)
           sendKey(newText.trim() + '\r');