agentgui 1.0.701 → 1.0.703

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.701",
+  "version": "1.0.703",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/static/js/client.js

@@ -730,23 +730,18 @@ class AgentGUIClient {
 
       switch (data.type) {
         case 'streaming_start':
-          window.syncDebugger?.logEvent('streaming_start', data);
           this.handleStreamingStart(data).catch(e => console.error('handleStreamingStart error:', e));
           break;
         case 'streaming_resumed':
-          window.syncDebugger?.logEvent('streaming_resumed', data);
           this.handleStreamingResumed(data).catch(e => console.error('handleStreamingResumed error:', e));
           break;
         case 'streaming_progress':
-          window.syncDebugger?.logEvent('streaming_progress', { sessionId: data.sessionId });
           this.handleStreamingProgress(data);
           break;
         case 'streaming_complete':
-          window.syncDebugger?.logEvent('streaming_complete', data);
           this.handleStreamingComplete(data);
           break;
         case 'streaming_error':
-          window.syncDebugger?.logEvent('streaming_error', data);
           this.handleStreamingError(data);
           break;
         case 'conversation_created':
@@ -756,11 +751,9 @@ class AgentGUIClient {
           this.handleAllConversationsDeleted(data);
           break;
         case 'message_created':
-          window.syncDebugger?.logEvent('message_created', data);
           this.handleMessageCreated(data);
           break;
         case 'conversation_updated':
-          window.syncDebugger?.logEvent('conversation_updated', data);
           this.handleConversationUpdated(data);
           break;
         case 'queue_status':

package/acp-queries.js

@@ -1,182 +0,0 @@
-import { randomUUID } from 'crypto';
-const gid = (p) => `${p}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-const uuid = () => randomUUID();
-const iso = (t) => new Date(t).toISOString();
-const j = (o) => JSON.stringify(o);
-const jp = (s) => { try { return JSON.parse(s); } catch { return {}; } };
-
-export function createACPQueries(db, prep) {
-  return {
-    createThread(metadata = {}) {
-      const id = uuid(), now = Date.now();
-      prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)').run(id, 'unknown', null, now, now, 'idle', j(metadata));
-      return { thread_id: id, created_at: iso(now), updated_at: iso(now), metadata, status: 'idle' };
-    },
-    getThread(tid) {
-      const r = prep('SELECT * FROM conversations WHERE id = ?').get(tid);
-      if (!r) return null;
-      return { thread_id: r.id, created_at: iso(r.created_at), updated_at: iso(r.updated_at), metadata: jp(r.metadata), status: r.status || 'idle' };
-    },
-    patchThread(tid, upd) {
-      const t = this.getThread(tid);
-      if (!t) throw new Error('Thread not found');
-      const now = Date.now(), meta = upd.metadata !== undefined ? upd.metadata : t.metadata, stat = upd.status !== undefined ? upd.status : t.status;
-      prep('UPDATE conversations SET metadata = ?, status = ?, updated_at = ? WHERE id = ?').run(j(meta), stat, now, tid);
-      return { thread_id: tid, created_at: t.created_at, updated_at: iso(now), metadata: meta, status: stat };
-    },
-    deleteThread(tid) {
-      const pr = prep('SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ? AND status = ?').get(tid, 'pending');
-      if (pr && pr.count > 0) throw new Error('Cannot delete thread with pending runs');
-      db.transaction(() => {
-        prep('DELETE FROM thread_states WHERE thread_id = ?').run(tid);
-        prep('DELETE FROM checkpoints WHERE thread_id = ?').run(tid);
-        prep('DELETE FROM run_metadata WHERE thread_id = ?').run(tid);
-        prep('DELETE FROM sessions WHERE conversationId = ?').run(tid);
-        prep('DELETE FROM messages WHERE conversationId = ?').run(tid);
-        prep('DELETE FROM chunks WHERE conversationId = ?').run(tid);
-        prep('DELETE FROM events WHERE conversationId = ?').run(tid);
-        prep('DELETE FROM conversations WHERE id = ?').run(tid);
-      })();
-      return true;
-    },
-    saveThreadState(tid, cid, sd) {
-      const id = gid('state'), now = Date.now();
-      prep('INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at) VALUES (?, ?, ?, ?, ?)').run(id, tid, cid, j(sd), now);
-      return { id, thread_id: tid, checkpoint_id: cid, created_at: iso(now) };
-    },
-    getThreadState(tid, cid = null) {
-      const r = cid ? prep('SELECT * FROM thread_states WHERE thread_id = ? AND checkpoint_id = ? ORDER BY created_at DESC LIMIT 1').get(tid, cid) : prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT 1').get(tid);
-      if (!r) return null;
-      const sd = jp(r.state_data);
-      return { checkpoint: { checkpoint_id: r.checkpoint_id }, values: sd.values || {}, messages: sd.messages || [], metadata: sd.metadata || {} };
-    },
-    getThreadHistory(tid, lim = 50, off = 0) {
-      const tot = prep('SELECT COUNT(*) as count FROM thread_states WHERE thread_id = ?').get(tid).count;
-      const rows = prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?').all(tid, lim, off);
-      const states = rows.map(r => { const sd = jp(r.state_data); return { checkpoint: { checkpoint_id: r.checkpoint_id }, values: sd.values || {}, messages: sd.messages || [], metadata: sd.metadata || {} }; });
-      return { states, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
-    },
-    copyThread(stid) {
-      const st = this.getThread(stid);
-      if (!st) throw new Error('Source thread not found');
-      const ntid = uuid(), now = Date.now();
-      db.transaction(() => {
-        prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata, workingDirectory) SELECT ?, agentId, title || \' (copy)\', ?, ?, status, metadata, workingDirectory FROM conversations WHERE id = ?').run(ntid, now, now, stid);
-        const cps = prep('SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence ASC').all(stid);
-        cps.forEach(cp => prep('INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at) VALUES (?, ?, ?, ?, ?)').run(uuid(), ntid, cp.checkpoint_name, cp.sequence, now));
-        const sts = prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at ASC').all(stid);
-        sts.forEach(s => prep('INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at) VALUES (?, ?, ?, ?, ?)').run(gid('state'), ntid, s.checkpoint_id, s.state_data, now));
-        const msgs = prep('SELECT * FROM messages WHERE conversationId = ? ORDER BY created_at ASC').all(stid);
-        msgs.forEach(m => prep('INSERT INTO messages (id, conversationId, role, content, created_at) VALUES (?, ?, ?, ?, ?)').run(gid('msg'), ntid, m.role, m.content, now));
-      })();
-      return this.getThread(ntid);
-    },
-    createCheckpoint(tid, name = null) {
-      const id = uuid(), now = Date.now();
-      const ms = prep('SELECT MAX(sequence) as max FROM checkpoints WHERE thread_id = ?').get(tid);
-      const seq = (ms?.max ?? -1) + 1;
-      prep('INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at) VALUES (?, ?, ?, ?, ?)').run(id, tid, name, seq, now);
-      return { checkpoint_id: id, thread_id: tid, checkpoint_name: name, sequence: seq, created_at: iso(now) };
-    },
-    getCheckpoint(cid) {
-      const r = prep('SELECT * FROM checkpoints WHERE id = ?').get(cid);
-      if (!r) return null;
-      return { checkpoint_id: r.id, thread_id: r.thread_id, checkpoint_name: r.checkpoint_name, sequence: r.sequence, created_at: iso(r.created_at) };
-    },
-    listCheckpoints(tid, lim = 50, off = 0) {
-      const tot = prep('SELECT COUNT(*) as count FROM checkpoints WHERE thread_id = ?').get(tid).count;
-      const rows = prep('SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence DESC LIMIT ? OFFSET ?').all(tid, lim, off);
-      const cps = rows.map(r => ({ checkpoint_id: r.id, thread_id: r.thread_id, checkpoint_name: r.checkpoint_name, sequence: r.sequence, created_at: iso(r.created_at) }));
-      return { checkpoints: cps, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
-    },
-    createRun(aid, tid = null, inp = null, cfg = null, wh = null) {
-      const rid = uuid(), now = Date.now(), mid = gid('runmeta');
-      let atid = tid;
-      if (!tid) {
-        atid = uuid();
-        prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)').run(atid, aid, 'Stateless Run', now, now, 'idle', '{"stateless":true}');
-      }
-      prep('INSERT INTO sessions (id, conversationId, status, started_at, completed_at, response, error) VALUES (?, ?, ?, ?, ?, ?, ?)').run(rid, atid, 'pending', now, null, null, null);
-      prep('INSERT INTO run_metadata (id, run_id, thread_id, agent_id, status, input, config, webhook_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').run(mid, rid, tid, aid, 'pending', inp ? j(inp) : null, cfg ? j(cfg) : null, wh, now, now);
-      return { run_id: rid, thread_id: tid, agent_id: aid, status: 'pending', created_at: iso(now), updated_at: iso(now) };
-    },
-    getRun(rid) {
-      const r = prep('SELECT * FROM run_metadata WHERE run_id = ?').get(rid);
-      if (!r) return null;
-      return { run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
-    },
-    updateRunStatus(rid, stat) {
-      const now = Date.now();
-      prep('UPDATE run_metadata SET status = ?, updated_at = ? WHERE run_id = ?').run(stat, now, rid);
-      prep('UPDATE sessions SET status = ? WHERE id = ?').run(stat, rid);
-      return this.getRun(rid);
-    },
-    cancelRun(rid) {
-      const r = this.getRun(rid);
-      if (!r) throw new Error('Run not found');
-      if (['success', 'error', 'cancelled'].includes(r.status)) throw new Error('Run already completed or cancelled');
-      return this.updateRunStatus(rid, 'cancelled');
-    },
-    deleteRun(rid) {
-      db.transaction(() => {
-        prep('DELETE FROM chunks WHERE sessionId = ?').run(rid);
-        prep('DELETE FROM events WHERE sessionId = ?').run(rid);
-        prep('DELETE FROM run_metadata WHERE run_id = ?').run(rid);
-        prep('DELETE FROM sessions WHERE id = ?').run(rid);
-      })();
-      return true;
-    },
-    getThreadRuns(tid, lim = 50, off = 0) {
-      const tot = prep('SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ?').get(tid).count;
-      const rows = prep('SELECT * FROM run_metadata WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?').all(tid, lim, off);
-      const runs = rows.map(r => ({ run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) }));
-      return { runs, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
-    },
-    searchThreads(flt = {}) {
-      const { metadata, status, dateRange, limit = 50, offset = 0 } = flt;
-      let wh = "status != 'deleted'", prm = [];
-      if (status) { wh += ' AND status = ?'; prm.push(status); }
-      if (dateRange?.start) { wh += ' AND created_at >= ?'; prm.push(new Date(dateRange.start).getTime()); }
-      if (dateRange?.end) { wh += ' AND created_at <= ?'; prm.push(new Date(dateRange.end).getTime()); }
-      if (metadata) { for (const [k, v] of Object.entries(metadata)) { wh += ' AND metadata LIKE ?'; prm.push(`%"${k}":"${v}"%`); } }
-      const tot = prep(`SELECT COUNT(*) as count FROM conversations WHERE ${wh}`).get(...prm).count;
-      const rows = prep(`SELECT * FROM conversations WHERE ${wh} ORDER BY updated_at DESC LIMIT ? OFFSET ?`).all(...prm, limit, offset);
-      const ths = rows.map(r => ({ thread_id: r.id, created_at: iso(r.created_at), updated_at: iso(r.updated_at), metadata: jp(r.metadata), status: r.status || 'idle' }));
-      return { threads: ths, total: tot, limit, offset, hasMore: offset + limit < tot };
-    },
-    searchAgents(agents, flt = {}) {
-      const { name, version, capabilities, limit = 50, offset = 0 } = flt;
-      let results = agents;
-      if (name) {
-        const n = name.toLowerCase();
-        results = results.filter(a => a.name.toLowerCase().includes(n) || a.id.toLowerCase().includes(n));
-      }
-      if (capabilities) {
-        results = results.filter(a => {
-          const desc = this.getAgentDescriptor ? this.getAgentDescriptor(a.id) : null;
-          if (!desc) return false;
-          const caps = desc.specs?.capabilities || {};
-          if (capabilities.streaming !== undefined && !caps.streaming) return false;
-          if (capabilities.threads !== undefined && caps.threads !== capabilities.threads) return false;
-          if (capabilities.interrupts !== undefined && caps.interrupts !== capabilities.interrupts) return false;
-          return true;
-        });
-      }
-      const total = results.length;
-      const paginated = results.slice(offset, offset + limit);
-      const agents_list = paginated.map(a => ({ agent_id: a.id, name: a.name, version: version || '1.0.0', path: a.path }));
-      return { agents: agents_list, total, limit, offset, hasMore: offset + limit < total };
-    },
-    searchRuns(flt = {}) {
-      const { agent_id, thread_id, status, limit = 50, offset = 0 } = flt;
-      let wh = '1=1', prm = [];
-      if (agent_id) { wh += ' AND agent_id = ?'; prm.push(agent_id); }
-      if (thread_id) { wh += ' AND thread_id = ?'; prm.push(thread_id); }
-      if (status) { wh += ' AND status = ?'; prm.push(status); }
-      const tot = prep(`SELECT COUNT(*) as count FROM run_metadata WHERE ${wh}`).get(...prm).count;
-      const rows = prep(`SELECT * FROM run_metadata WHERE ${wh} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...prm, limit, offset);
-      const runs = rows.map(r => ({ run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) }));
-      return { runs, total: tot, limit, offset, hasMore: offset + limit < tot };
-    }
-  };
-}

package/static/js/codec.js

@@ -1,2 +0,0 @@
-export function encode(obj) { return msgpackr.pack(obj); }
-export function decode(buf) { return msgpackr.unpack(new Uint8Array(buf instanceof ArrayBuffer ? buf : buf)); }

package/static/js/sync-debug.js

@@ -1,146 +0,0 @@
-/**
- * Sync-to-Display Debug System
- * Comprehensive logging and state validation for sync/render pipeline
- */
-
-class SyncDebugger {
-  constructor() {
-    this.enabled = false;
-    this.eventLog = [];
-    this.maxLogSize = 500;
-    this.stateSnapshots = [];
-    this.processingStack = [];
-    this.startTime = Date.now();
-
-    // Event tracking
-    this.processedEventIds = new Set();
-    this.eventCounts = {};
-
-    // Timing
-    this.timingMarkers = {};
-  }
-
-  enable() {
-    this.enabled = true;
-    console.log('[SyncDebug] Enabled');
-    window.SyncDebugger = this;
-  }
-
-  disable() {
-    this.enabled = false;
-    console.log('[SyncDebug] Disabled');
-  }
-
-  logEvent(type, data) {
-    if (!this.enabled) return;
-
-    const timestamp = Date.now() - this.startTime;
-    const eventId = data?.id || data?.messageId || data?.conversationId || '?';
-
-    // Check for duplicates
-    const isDuplicate = this.processedEventIds.has(eventId) &&
-                        this.eventLog.some(e => e.type === type && e.eventId === eventId);
-
-    const entry = {
-      timestamp,
-      type,
-      eventId,
-      isDuplicate,
-      dataKeys: data ? Object.keys(data) : [],
-      dataSize: JSON.stringify(data || {}).length
-    };
-
-    this.eventLog.push(entry);
-    this.eventCounts[type] = (this.eventCounts[type] || 0) + 1;
-    this.processedEventIds.add(eventId);
-
-    if (this.eventLog.length > this.maxLogSize) {
-      this.eventLog.shift();
-    }
-
-    if (isDuplicate) {
-      console.warn(`[SyncDebug] DUPLICATE EVENT: ${type} - ${eventId}`, entry);
-    } else {
-      console.log(`[SyncDebug] Event: ${type} (${timestamp}ms)`, entry);
-    }
-  }
-
-  logStateChange(name, before, after) {
-    if (!this.enabled) return;
-
-    const timestamp = Date.now() - this.startTime;
-    const snapshot = {
-      timestamp,
-      name,
-      before: JSON.parse(JSON.stringify(before)),
-      after: JSON.parse(JSON.stringify(after)),
-      changed: JSON.stringify(before) !== JSON.stringify(after)
-    };
-
-    this.stateSnapshots.push(snapshot);
-    if (this.stateSnapshots.length > this.maxLogSize) {
-      this.stateSnapshots.shift();
-    }
-
-    if (snapshot.changed) {
-      console.log(`[SyncDebug] State changed: ${name}`, snapshot);
-    }
-  }
-
-  pushOperation(name) {
-    const marker = { name, start: Date.now() };
-    this.processingStack.push(marker);
-    console.log(`[SyncDebug] > ${name}`);
-  }
-
-  popOperation() {
-    const marker = this.processingStack.pop();
-    if (marker) {
-      const duration = Date.now() - marker.start;
-      console.log(`[SyncDebug] < ${marker.name} (${duration}ms)`);
-      if (duration > 100) {
-        console.warn(`[SyncDebug] SLOW: ${marker.name} took ${duration}ms`);
-      }
-    }
-  }
-
-  getReport() {
-    return {
-      totalEvents: this.eventLog.length,
-      eventCounts: this.eventCounts,
-      duplicates: this.eventLog.filter(e => e.isDuplicate).length,
-      stateChanges: this.stateSnapshots.length,
-      uniqueEventIds: this.processedEventIds.size,
-      recentEvents: this.eventLog.slice(-20),
-      recentStateChanges: this.stateSnapshots.slice(-20)
-    };
-  }
-
-  printReport() {
-    const report = this.getReport();
-    console.table(report);
-    console.table(report.recentEvents);
-    console.table(report.recentStateChanges);
-  }
-
-  clearLogs() {
-    this.eventLog = [];
-    this.stateSnapshots = [];
-    this.processedEventIds.clear();
-    this.eventCounts = {};
-    this.processingStack = [];
-    console.log('[SyncDebug] Logs cleared');
-  }
-}
-
-if (window.__DEBUG__) {
-  window.syncDebugger = new SyncDebugger();
-  window.debugSync = {
-    enable: () => window.syncDebugger.enable(),
-    disable: () => window.syncDebugger.disable(),
-    report: () => window.syncDebugger.printReport(),
-    clear: () => window.syncDebugger.clearLogs(),
-    get: () => window.syncDebugger.getReport()
-  };
-  console.log('[SyncDebug] Available. Use: debugSync.enable(), debugSync.report(), debugSync.clear()');
-}

package/test-cli-detection.mjs

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-import { checkCliInstalled, getCliVersion } from './lib/tool-manager.js';
-import { execSync } from 'child_process';
-
-console.log('=== CLI Tool Detection Test ===\n');
-
-const tools = [
-  { pkg: '@anthropic-ai/claude-code', bin: 'claude' },
-  { pkg: 'opencode-ai', bin: 'opencode' },
-  { pkg: '@google/gemini-cli', bin: 'gemini' },
-  { pkg: '@kilocode/cli', bin: 'kilo' },
-  { pkg: '@openai/codex', bin: 'codex' }
-];
-
-tools.forEach(tool => {
-  try {
-    // Direct which check
-    const which = process.platform === 'win32' ? 'where' : 'which';
-    execSync(`${which} ${tool.bin}`, { stdio: 'pipe', timeout: 3000 });
-    const version = execSync(`${tool.bin} --version`, { stdio: 'pipe', timeout: 2000, encoding: 'utf8' }).trim();
-    const match = version.match(/(\d+\.\d+\.\d+)/);
-    console.log(`✓ ${tool.pkg}`);
-    console.log(`  Binary: ${tool.bin} (found)`);
-    console.log(`  Version output: ${version.substring(0, 50)}`);
-    console.log(`  Parsed version: ${match ? match[1] : 'NOT FOUND'}`);
-  } catch (e) {
-    console.log(`✗ ${tool.pkg}`);
-    console.log(`  Binary: ${tool.bin} (not found in PATH)`);
-  }
-  console.log();
-});
-
-console.log('=== Testing Tool Manager Functions ===\n');
-
-// Test with promises
-console.log('Note: Tool manager functions require async context');
-console.log('Use tool-manager directly in server to test full functionality');

package/test-fixes.mjs

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Test script for validating the two fixes:
- * 1. Agent selector visibility in chat view
- * 2. TTS streaming pre-generation
- */
-
-import fs from 'fs';
-import { execSync } from 'child_process';
-
-console.log('=== AgentGUI Fix Validation ===\n');
-
-// Test 1: Verify agent selectors are NOT hidden on desktop
-console.log('Test 1: Agent Selector Visibility');
-console.log('-----------------------------------');
-const html = fs.readFileSync('./static/index.html', 'utf-8');
-const beforeMobileMedia = html.substring(0, html.indexOf('@media (max-width: 480px)'));
-const cliHiddenOnDesktop = beforeMobileMedia.includes('.cli-selector { display: none; }');
-const modelHiddenOnDesktop = beforeMobileMedia.includes('.model-selector { display: none; }');
-
-if (!cliHiddenOnDesktop && !modelHiddenOnDesktop) {
-  console.log('✓ PASS: Agent selectors are NOT hidden by CSS on desktop');
-  console.log('  - CLI selector will be visible when populated');
-  console.log('  - Model selector will be visible when populated');
-} else {
-  console.log('❌ FAIL: Agent selectors are still hidden on desktop');
-  if (cliHiddenOnDesktop) console.log('  - .cli-selector has display:none');
-  if (modelHiddenOnDesktop) console.log('  - .model-selector has display:none');
-}
-
-// Verify selectors are in HTML
-const hasSelectors = html.includes('data-cli-selector') &&
-                     html.includes('data-agent-selector') &&
-                     html.includes('data-model-selector');
-if (hasSelectors) {
-  console.log('✓ PASS: All selector elements are present in HTML');
-} else {
-  console.log('❌ FAIL: Some selector elements are missing');
-}
-
-// Test 2: Verify TTS pre-generation is implemented
-console.log('\nTest 2: TTS Streaming Pre-generation');
-console.log('--------------------------------------');
-const voiceJs = fs.readFileSync('./static/js/voice.js', 'utf-8');
-const hasPreGenerateFunction = voiceJs.includes('function preGenerateTTS(text)');
-const callsPreGenerate = voiceJs.includes('preGenerateTTS(block.text)');
-const usesCache = voiceJs.includes('if (ttsAudioCache.has(cacheKey)) return;');
-const fetchesTTS = voiceJs.match(/fetch\(BASE \+ '\/api\/tts'/g)?.length >= 2; // Should be in both preGenerate and processQueue
-
-if (hasPreGenerateFunction && callsPreGenerate && usesCache && fetchesTTS) {
-  console.log('✓ PASS: TTS pre-generation is fully implemented');
-  console.log('  - preGenerateTTS function exists');
-  console.log('  - Called when assistant text arrives');
-  console.log('  - Uses cache to avoid duplicate generation');
-  console.log('  - Audio generation happens in background');
-} else {
-  console.log('❌ FAIL: TTS pre-generation incomplete');
-  if (!hasPreGenerateFunction) console.log('  - Missing preGenerateTTS function');
-  if (!callsPreGenerate) console.log('  - Not called in handleVoiceBlock');
-  if (!usesCache) console.log('  - Missing cache check');
-}
-
-// Test 3: Check that client.js populates selectors correctly
-console.log('\nTest 3: Selector Population Logic');
-console.log('-----------------------------------');
-const clientJs = fs.readFileSync('./static/js/client.js', 'utf-8');
-const setsDisplay = clientJs.includes("this.ui.cliSelector.style.display = 'inline-block'");
-const populatesOptions = clientJs.includes('.innerHTML = displayAgents');
-
-if (setsDisplay && populatesOptions) {
-  console.log('✓ PASS: Client.js correctly populates and displays selectors');
-  console.log('  - Sets display to inline-block when agents loaded');
-  console.log('  - Populates options from agent list');
-} else {
-  console.log('❌ FAIL: Selector population logic may be broken');
-}
-
-// Summary
-console.log('\n=== SUMMARY ===');
-const allTestsPass = !cliHiddenOnDesktop && !modelHiddenOnDesktop &&
-                     hasSelectors && hasPreGenerateFunction &&
-                     callsPreGenerate && usesCache &&
-                     setsDisplay && populatesOptions;
-
-if (allTestsPass) {
-  console.log('✓ ALL TESTS PASSED\n');
-  console.log('Manual Testing Instructions:');
-  console.log('1. Start server: npm run dev');
-  console.log('2. Open http://localhost:3000/gm/');
-  console.log('3. Check chat input area - you should see:');
-  console.log('   - CLI selector dropdown (e.g., "Claude")');
-  console.log('   - Model selector dropdown (e.g., "Sonnet 4.5")');
-  console.log('   - Microphone button for voice input');
-  console.log('4. Open Voice tab and enable "Auto-speak responses"');
-  console.log('5. Send a message and observe:');
-  console.log('   - Text streams in as agent responds');
-  console.log('   - Voice playback starts immediately after completion (no delay)');
-  console.log('   - Audio was pre-generated during streaming');
-} else {
-  console.log('❌ SOME TESTS FAILED - Review output above\n');
-  process.exit(1);
-}

package/test-thread-steering.mjs

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Thread Steering Test
- * Tests the thread.run.steer endpoint for interrupting and restarting with instruction
- */
-
-import http from 'http';
-
-const BASE_URL = 'http://localhost:3000/gm';
-
-async function request(method, path, body = null) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(path, BASE_URL);
-    const options = {
-      hostname: url.hostname,
-      port: url.port || 3000,
-      path: url.pathname + url.search,
-      method,
-      headers: { 'Content-Type': 'application/json' }
-    };
-
-    const req = http.request(options, (res) => {
-      let data = '';
-      res.on('data', (chunk) => (data += chunk));
-      res.on('end', () => {
-        try {
-          resolve({ status: res.statusCode, data: JSON.parse(data) });
-        } catch (e) {
-          resolve({ status: res.statusCode, data: data || null });
-        }
-      });
-    });
-
-    req.on('error', reject);
-    if (body) req.write(JSON.stringify(body));
-    req.end();
-  });
-}
-
-async function runTests() {
-  console.log('🧪 Thread Steering Tests\n');
-
-  try {
-    // Health check
-    const health = await request('GET', '/api/home');
-    if (health.status !== 200) {
-      console.error('❌ Server not running at', BASE_URL);
-      process.exit(1);
-    }
-
-    console.log('✅ Server is running\n');
-
-    // Test 1: Verify thread.run.steer endpoint exists (check if it's callable)
-    console.log('[TEST 1] Verify thread.run.steer endpoint accepts correct parameters');
-    console.log('  - Creating thread...');
-
-    // Note: We can't fully test thread.run.steer without a running agent,
-    // but we can verify the endpoint structure exists by checking server.js
-    const serverCheck = await request('GET', '/api/agents');
-    if (serverCheck.status === 200) {
-      console.log('  ✅ Agent endpoint accessible');
-      console.log('  ✅ thread.run.steer endpoint should be available via WebSocket\n');
-    }
-
-    console.log('[TEST 2] Thread steering mechanism');
-    console.log('  Implementation verified:');
-    console.log('  - Endpoint: thread.run.steer');
-    console.log('  - Parameters: id (threadId), runId, instruction');
-    console.log('  - Behavior: Cancel run, create new run with instruction');
-    console.log('  - Result: New run executes with steering instruction\n');
-
-    console.log('[TEST 3] Thread steering vs Conversation steering');
-    console.log('  Conversation steering (conv.steer):');
-    console.log('    ✓ Keeps process alive, sends instruction via stdin JSON-RPC');
-    console.log('    ✓ Preserves execution context');
-    console.log('    ✗ Only works with agents that support stdin\n');
-
-    console.log('  Thread steering (thread.run.steer):');
-    console.log('    ✓ Works with any agent type');
-    console.log('    ✓ Simple cancel + resume mechanism');
-    console.log('    ✗ Restarts from beginning (loses context)\n');
-
-    console.log('✅ Thread steering implementation verified');
-    console.log('\nUsage example:');
-    console.log('  const result = await wsClient.rpc("thread.run.steer", {');
-    console.log('    id: threadId,');
-    console.log('    runId: currentRunId,');
-    console.log('    instruction: "new prompt or instruction"');
-    console.log('  });');
-    console.log('  // Returns: { steered: true, cancelled_run, new_run, ... }');
-
-    process.exit(0);
-  } catch (err) {
-    console.error('❌ Test error:', err.message);
-    process.exit(1);
-  }
-}
-
-runTests();