agentgui 1.0.238 → 1.0.240

package/database.js

@@ -308,6 +308,11 @@ export const queries = {
     return stmt.all('deleted');
   },
 
+  getConversations() {
+    const stmt = prep('SELECT * FROM conversations WHERE status != ? ORDER BY updated_at DESC');
+    return stmt.all('deleted');
+  },
+
   updateConversation(id, data) {
     const conv = this.getConversation(id);
     if (!conv) return null;
@@ -568,6 +573,28 @@ export const queries = {
     return stmt.all();
   },
 
+  getSessionsByConversation(conversationId, limit = 10, offset = 0) {
+    const stmt = prep(
+      'SELECT * FROM sessions WHERE conversationId = ? ORDER BY started_at DESC LIMIT ? OFFSET ?'
+    );
+    return stmt.all(conversationId, limit, offset);
+  },
+
+  getAllSessions(limit = 100) {
+    const stmt = prep(
+      'SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?'
+    );
+    return stmt.all(limit);
+  },
+
+  deleteSession(id) {
+    const stmt = prep('DELETE FROM sessions WHERE id = ?');
+    const result = stmt.run(id);
+    prep('DELETE FROM chunks WHERE sessionId = ?').run(id);
+    prep('DELETE FROM events WHERE sessionId = ?').run(id);
+    return result.changes || 0;
+  },
+
   createEvent(type, data, conversationId = null, sessionId = null) {
     const id = generateId('evt');
     const now = Date.now();

package/package.json

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

package/server.js

@@ -1217,7 +1217,7 @@ const server = http.createServer(async (req, res) => {
             startTime: Date.now(),
             duration: 0,
             eventCount: 0
-          }
+              }
         };
 
         if (filterType) {
@@ -1231,6 +1231,163 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    const runsMatch = pathOnly.match(/^\/api\/runs$/);
+    if (runsMatch && req.method === 'POST') {
+      let body = '';
+      for await (const chunk of req) { body += chunk; }
+      let parsed = {};
+      try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+      const { input, agentId, webhook } = parsed;
+      if (!input) {
+        sendJSON(req, res, 400, { error: 'Missing input in request body' });
+        return;
+      }
+
+      const resolvedAgentId = agentId || 'claude-code';
+      const resolvedModel = parsed.model || null;
+      const cwd = parsed.workingDirectory || STARTUP_CWD;
+
+      const thread = queries.createConversation(resolvedAgentId, 'Stateless Run', cwd);
+      const session = queries.createSession(thread.id, resolvedAgentId, 'pending');
+      const message = queries.createMessage(thread.id, 'user', typeof input === 'string' ? input : JSON.stringify(input));
+
+      processMessageWithStreaming(thread.id, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
+
+      sendJSON(req, res, 200, {
+        id: session.id,
+        status: 'pending',
+        started_at: session.started_at,
+        agentId: resolvedAgentId
+      });
+      return;
+    }
+
+    const runsSearchMatch = pathOnly.match(/^\/api\/runs\/search$/);
+    if (runsSearchMatch && req.method === 'POST') {
+      const sessions = queries.getAllSessions();
+      const runs = sessions.slice(0, 50).map(s => ({
+        id: s.id,
+        status: s.status,
+        started_at: s.started_at,
+        completed_at: s.completed_at,
+        agentId: s.agentId,
+        input: null,
+        output: null
+      })).reverse();
+      sendJSON(req, res, 200, runs);
+      return;
+    }
+
+    const runByIdMatch = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
+    if (runByIdMatch) {
+      const runId = runByIdMatch[1];
+      const session = queries.getSession(runId);
+      
+      if (!session) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+
+      if (req.method === 'GET') {
+        sendJSON(req, res, 200, {
+          id: session.id,
+          status: session.status,
+          started_at: session.started_at,
+          completed_at: session.completed_at,
+          agentId: session.agentId,
+          input: null,
+          output: null
+        });
+        return;
+      }
+
+      if (req.method === 'DELETE') {
+        queries.deleteSession(runId);
+        sendJSON(req, res, 204, {});
+        return;
+      }
+
+      if (req.method === 'POST') {
+        if (session.status !== 'interrupted') {
+          sendJSON(req, res, 409, { error: 'Can only resume interrupted runs' });
+          return;
+        }
+
+        let body = '';
+        for await (const chunk of req) { body += chunk; }
+        let parsed = {};
+        try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+        const { input } = parsed;
+        if (!input) {
+          sendJSON(req, res, 400, { error: 'Missing input in request body' });
+          return;
+        }
+
+        const conv = queries.getConversation(session.conversationId);
+        const resolvedAgentId = session.agentId || conv?.agentId || 'claude-code';
+        const resolvedModel = conv?.model || null;
+        const cwd = conv?.workingDirectory || STARTUP_CWD;
+
+        queries.updateSession(runId, { status: 'pending' });
+        
+        const message = queries.createMessage(session.conversationId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
+
+        processMessageWithStreaming(session.conversationId, message.id, runId, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
+
+        sendJSON(req, res, 200, {
+          id: session.id,
+          status: 'pending',
+          started_at: session.started_at,
+          agentId: resolvedAgentId
+        });
+        return;
+      }
+    }
+
+    const runCancelMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
+    if (runCancelMatch && req.method === 'POST') {
+      const runId = runCancelMatch[1];
+      const session = queries.getSession(runId);
+      
+      if (!session) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+
+      const conversationId = session.conversationId;
+      const entry = activeExecutions.get(conversationId);
+      
+      if (entry && entry.sessionId === runId) {
+        const { pid } = entry;
+        if (pid) {
+          try {
+            process.kill(-pid, 'SIGKILL');
+          } catch {
+            try {
+              process.kill(pid, 'SIGKILL');
+            } catch (e) {}
+          }
+        }
+      }
+
+      queries.updateSession(runId, { status: 'interrupted', completed_at: Date.now() });
+      queries.setIsStreaming(conversationId, false);
+      activeExecutions.delete(conversationId);
+
+      broadcastSync({
+        type: 'streaming_complete',
+        sessionId: runId,
+        conversationId,
+        interrupted: true,
+        timestamp: Date.now()
+      });
+
+      sendJSON(req, res, 204, {});
+      return;
+    }
+
     const scriptsMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/scripts$/);
     if (scriptsMatch && req.method === 'GET') {
       const conv = queries.getConversation(scriptsMatch[1]);
@@ -1307,11 +1464,227 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    const cancelRunMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/cancel$/);
+    if (cancelRunMatch && req.method === 'POST') {
+      const conversationId = cancelRunMatch[1];
+      const entry = activeExecutions.get(conversationId);
+      
+      if (!entry) {
+        sendJSON(req, res, 404, { error: 'No active execution to cancel' });
+        return;
+      }
+
+      const { pid, sessionId } = entry;
+      
+      if (pid) {
+        try {
+          process.kill(-pid, 'SIGKILL');
+        } catch {
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch (e) {}
+        }
+      }
+
+      if (sessionId) {
+        queries.updateSession(sessionId, { 
+          status: 'interrupted', 
+          completed_at: Date.now() 
+        });
+      }
+
+      queries.setIsStreaming(conversationId, false);
+      activeExecutions.delete(conversationId);
+
+      broadcastSync({
+        type: 'streaming_complete',
+        sessionId,
+        conversationId,
+        interrupted: true,
+        timestamp: Date.now()
+      });
+
+      sendJSON(req, res, 200, { ok: true, cancelled: true, conversationId, sessionId });
+      return;
+    }
+
+    const resumeRunMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/resume$/);
+    if (resumeRunMatch && req.method === 'POST') {
+      const conversationId = resumeRunMatch[1];
+      const conv = queries.getConversation(conversationId);
+      
+      if (!conv) {
+        sendJSON(req, res, 404, { error: 'Conversation not found' });
+        return;
+      }
+
+      const activeEntry = activeExecutions.get(conversationId);
+      if (activeEntry) {
+        sendJSON(req, res, 409, { error: 'Conversation already has an active execution' });
+        return;
+      }
+
+      let body = '';
+      for await (const chunk of req) { body += chunk; }
+      let parsed = {};
+      try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+      const { content, agentId } = parsed;
+      if (!content) {
+        sendJSON(req, res, 400, { error: 'Missing content in request body' });
+        return;
+      }
+
+      const resolvedAgentId = agentId || conv.agentId || 'claude-code';
+      const resolvedModel = parsed.model || conv.model || null;
+      const cwd = conv.workingDirectory || STARTUP_CWD;
+
+      const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
+      
+      const message = queries.createMessage(conversationId, 'user', content);
+
+      processMessageWithStreaming(conversationId, message.id, session.id, content, resolvedAgentId, resolvedModel);
+
+      sendJSON(req, res, 200, { 
+        ok: true, 
+        conversationId, 
+        sessionId: session.id,
+        messageId: message.id,
+        resumed: true 
+      });
+      return;
+    }
+
+    const injectMatch = pathOnly.match(/^\/api\/conversations\/([^/]+)\/inject$/);
+    if (injectMatch && req.method === 'POST') {
+      const conversationId = injectMatch[1];
+      const conv = queries.getConversation(conversationId);
+      
+      if (!conv) {
+        sendJSON(req, res, 404, { error: 'Conversation not found' });
+        return;
+      }
+
+      let body = '';
+      for await (const chunk of req) { body += chunk; }
+      let parsed = {};
+      try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+      const { content, eager } = parsed;
+      if (!content) {
+        sendJSON(req, res, 400, { error: 'Missing content in request body' });
+        return;
+      }
+
+      const entry = activeExecutions.get(conversationId);
+      
+      if (entry && eager) {
+        sendJSON(req, res, 409, { error: 'Cannot eagerly inject while execution is running - message queued' });
+        return;
+      }
+
+      const message = queries.createMessage(conversationId, 'user', '[INJECTED] ' + content);
+
+      if (!entry) {
+        const resolvedAgentId = conv.agentId || 'claude-code';
+        const resolvedModel = conv.model || null;
+        const cwd = conv.workingDirectory || STARTUP_CWD;
+        const session = queries.createSession(conversationId, resolvedAgentId, 'pending');
+        processMessageWithStreaming(conversationId, message.id, session.id, message.content, resolvedAgentId, resolvedModel);
+      }
+
+      sendJSON(req, res, 200, { ok: true, injected: true, conversationId, messageId: message.id });
+      return;
+    }
+
     if (pathOnly === '/api/agents' && req.method === 'GET') {
             sendJSON(req, res, 200, { agents: discoveredAgents });
       return;
     }
 
+    const agentsSearchMatch = pathOnly.match(/^\/api\/agents\/search$/);
+    if (agentsSearchMatch && req.method === 'POST') {
+      let body = '';
+      for await (const chunk of req) { body += chunk; }
+      let parsed = {};
+      try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+      const { query } = parsed;
+      let results = discoveredAgents;
+
+      if (query) {
+        const q = query.toLowerCase();
+        results = discoveredAgents.filter(a => 
+          a.name.toLowerCase().includes(q) || 
+          a.id.toLowerCase().includes(q) ||
+          (a.description && a.description.toLowerCase().includes(q))
+        );
+      }
+
+      const agents = results.map(a => ({
+        id: a.id,
+        name: a.name,
+        description: a.description || '',
+        icon: a.icon || null,
+        status: 'available'
+      }));
+
+      sendJSON(req, res, 200, agents);
+      return;
+    }
+
+    const agentByIdMatch = pathOnly.match(/^\/api\/agents\/([^/]+)$/);
+    if (agentByIdMatch && req.method === 'GET') {
+      const agentId = agentByIdMatch[1];
+      const agent = discoveredAgents.find(a => a.id === agentId);
+      
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+
+      sendJSON(req, res, 200, {
+        id: agent.id,
+        name: agent.name,
+        description: agent.description || '',
+        icon: agent.icon || null,
+        status: 'available'
+      });
+      return;
+    }
+
+    const agentDescriptorMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/descriptor$/);
+    if (agentDescriptorMatch && req.method === 'GET') {
+      const agentId = agentDescriptorMatch[1];
+      const agent = discoveredAgents.find(a => a.id === agentId);
+      
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+
+      sendJSON(req, res, 200, {
+        agentId: agent.id,
+        agentName: agent.name,
+        protocol: agent.protocol || 'direct',
+        capabilities: {
+          streaming: true,
+          cancel: true,
+          resume: agent.protocol === 'direct',
+          stateful: true
+        },
+        inputSchema: {
+          type: 'object',
+          properties: {
+            content: { type: 'string', description: 'The prompt to send to the agent' }
+          },
+          required: ['content']
+        },
+        stateFormat: 'opaque'
+      });
+      return;
+    }
+
     const modelsMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/models$/);
     if (modelsMatch && req.method === 'GET') {
       const agentId = modelsMatch[1];
@@ -1584,6 +1957,336 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    const threadsMatch = pathOnly.match(/^\/api\/threads$/);
+    if (threadsMatch && req.method === 'POST') {
+      let body = '';
+      for await (const chunk of req) { body += chunk; }
+      let parsed = {};
+      try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+      const thread = queries.createConversation(parsed.agentId || 'claude-code', parsed.title || 'New Thread', parsed.workingDirectory || STARTUP_CWD);
+      sendJSON(req, res, 200, { 
+        id: thread.id, 
+        agentId: thread.agentId, 
+        title: thread.title,
+        created_at: thread.created_at,
+        status: thread.status,
+        state: null
+      });
+      return;
+    }
+
+    const threadsSearchMatch = pathOnly.match(/^\/api\/threads\/search$/);
+    if (threadsSearchMatch && req.method === 'POST') {
+      const conversations = queries.getConversations();
+      const threads = conversations.map(c => ({
+        id: c.id,
+        agentId: c.agentId,
+        title: c.title,
+        created_at: c.created_at,
+        updated_at: c.updated_at,
+        status: c.status,
+        state: null
+      }));
+      sendJSON(req, res, 200, threads);
+      return;
+    }
+
+    const threadByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)$/);
+    if (threadByIdMatch) {
+      const threadId = threadByIdMatch[1];
+      const conv = queries.getConversation(threadId);
+      
+      if (!conv) {
+        sendJSON(req, res, 404, { error: 'Thread not found' });
+        return;
+      }
+
+      if (req.method === 'GET') {
+        sendJSON(req, res, 200, {
+          id: conv.id,
+          agentId: conv.agentId,
+          title: conv.title,
+          created_at: conv.created_at,
+          updated_at: conv.updated_at,
+          status: conv.status,
+          state: null
+        });
+        return;
+      }
+
+      if (req.method === 'DELETE') {
+        const activeEntry = activeExecutions.get(threadId);
+        if (activeEntry) {
+          sendJSON(req, res, 409, { error: 'Thread has an active run, cannot delete' });
+          return;
+        }
+        queries.deleteConversation(threadId);
+        sendJSON(req, res, 204, {});
+        return;
+      }
+
+      if (req.method === 'PATCH') {
+        let body = '';
+        for await (const chunk of req) { body += chunk; }
+        let parsed = {};
+        try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+        const updates = {};
+        if (parsed.title !== undefined) updates.title = parsed.title;
+        if (parsed.state !== undefined) updates.state = parsed.state;
+        
+        if (Object.keys(updates).length > 0) {
+          queries.updateConversation(threadId, updates);
+        }
+        
+        const updated = queries.getConversation(threadId);
+        sendJSON(req, res, 200, {
+          id: updated.id,
+          agentId: updated.agentId,
+          title: updated.title,
+          created_at: updated.created_at,
+          updated_at: updated.updated_at,
+          status: updated.status,
+          state: updated.state
+        });
+        return;
+      }
+    }
+
+    const threadHistoryMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/history$/);
+    if (threadHistoryMatch && req.method === 'GET') {
+      const threadId = threadHistoryMatch[1];
+      const conv = queries.getConversation(threadId);
+      
+      if (!conv) {
+        sendJSON(req, res, 404, { error: 'Thread not found' });
+        return;
+      }
+
+      const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
+      const sessions = queries.getSessionsByConversation(threadId, limit);
+      
+      const history = sessions.map(s => ({
+        checkpoint: s.id,
+        state: null,
+        created_at: s.started_at,
+        runId: s.id,
+        status: s.status
+      })).reverse();
+
+      sendJSON(req, res, 200, history);
+      return;
+    }
+
+    const threadCopyMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/copy$/);
+    if (threadCopyMatch && req.method === 'POST') {
+      const threadId = threadCopyMatch[1];
+      const original = queries.getConversation(threadId);
+      
+      if (!original) {
+        sendJSON(req, res, 404, { error: 'Thread not found' });
+        return;
+      }
+
+      const newThread = queries.createConversation(original.agentId, original.title + ' (copy)', original.workingDirectory);
+
+      const messages = queries.getMessages(threadId, 1000, 0);
+      for (const msg of messages) {
+        queries.createMessage(newThread.id, msg.role, msg.content);
+      }
+
+      sendJSON(req, res, 200, {
+        id: newThread.id,
+        agentId: newThread.agentId,
+        title: newThread.title,
+        created_at: newThread.created_at,
+        status: newThread.status,
+        state: null
+      });
+      return;
+    }
+
+    const threadRunsMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs$/);
+    if (threadRunsMatch) {
+      const threadId = threadRunsMatch[1];
+      const conv = queries.getConversation(threadId);
+      
+      if (!conv) {
+        sendJSON(req, res, 404, { error: 'Thread not found' });
+        return;
+      }
+
+      if (req.method === 'GET') {
+        const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
+        const offset = parseInt(new URL(req.url, 'http://localhost').searchParams.get('offset') || '0', 10);
+        const sessions = queries.getSessionsByConversation(threadId, limit, offset);
+        
+        const runs = sessions.map(s => ({
+          id: s.id,
+          threadId: s.conversationId,
+          status: s.status,
+          started_at: s.started_at,
+          completed_at: s.completed_at,
+          agentId: s.agentId,
+          input: null,
+          output: null
+        }));
+
+        sendJSON(req, res, 200, runs);
+        return;
+      }
+
+      if (req.method === 'POST') {
+        const activeEntry = activeExecutions.get(threadId);
+        if (activeEntry) {
+          sendJSON(req, res, 409, { error: 'Thread already has an active run' });
+          return;
+        }
+
+        let body = '';
+        for await (const chunk of req) { body += chunk; }
+        let parsed = {};
+        try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+        const { input, agentId, webhook } = parsed;
+        if (!input) {
+          sendJSON(req, res, 400, { error: 'Missing input in request body' });
+          return;
+        }
+
+        const resolvedAgentId = agentId || conv.agentId || 'claude-code';
+        const resolvedModel = parsed.model || conv.model || null;
+        const cwd = conv.workingDirectory || STARTUP_CWD;
+
+        const session = queries.createSession(threadId, resolvedAgentId, 'pending');
+        const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
+
+        processMessageWithStreaming(threadId, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
+
+        sendJSON(req, res, 200, {
+          id: session.id,
+          threadId: threadId,
+          status: 'pending',
+          started_at: session.started_at,
+          agentId: resolvedAgentId
+        });
+        return;
+      }
+    }
+
+    const threadRunByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)$/);
+    if (threadRunByIdMatch) {
+      const threadId = threadRunByIdMatch[1];
+      const runId = threadRunByIdMatch[2];
+      const session = queries.getSession(runId);
+      
+      if (!session || session.conversationId !== threadId) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+
+      if (req.method === 'GET') {
+        sendJSON(req, res, 200, {
+          id: session.id,
+          threadId: session.conversationId,
+          status: session.status,
+          started_at: session.started_at,
+          completed_at: session.completed_at,
+          agentId: session.agentId,
+          input: null,
+          output: null
+        });
+        return;
+      }
+
+      if (req.method === 'DELETE') {
+        queries.deleteSession(runId);
+        sendJSON(req, res, 204, {});
+        return;
+      }
+
+      if (req.method === 'POST') {
+        if (session.status !== 'interrupted') {
+          sendJSON(req, res, 409, { error: 'Can only resume interrupted runs' });
+          return;
+        }
+
+        let body = '';
+        for await (const chunk of req) { body += chunk; }
+        let parsed = {};
+        try { parsed = body ? JSON.parse(body) : {}; } catch {}
+
+        const { input } = parsed;
+        if (!input) {
+          sendJSON(req, res, 400, { error: 'Missing input in request body' });
+          return;
+        }
+
+        const conv = queries.getConversation(threadId);
+        const resolvedAgentId = session.agentId || conv.agentId || 'claude-code';
+        const resolvedModel = conv?.model || null;
+        const cwd = conv?.workingDirectory || STARTUP_CWD;
+
+        queries.updateSession(runId, { status: 'pending' });
+        
+        const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
+
+        processMessageWithStreaming(threadId, message.id, runId, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
+
+        sendJSON(req, res, 200, {
+          id: session.id,
+          threadId: threadId,
+          status: 'pending',
+          started_at: session.started_at,
+          agentId: resolvedAgentId
+        });
+        return;
+      }
+    }
+
+    const threadRunCancelMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/);
+    if (threadRunCancelMatch && req.method === 'POST') {
+      const threadId = threadRunCancelMatch[1];
+      const runId = threadRunCancelMatch[2];
+      const session = queries.getSession(runId);
+      
+      if (!session || session.conversationId !== threadId) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+
+      const entry = activeExecutions.get(threadId);
+      
+      if (entry && entry.sessionId === runId) {
+        const { pid } = entry;
+        if (pid) {
+          try {
+            process.kill(-pid, 'SIGKILL');
+          } catch {
+            try {
+              process.kill(pid, 'SIGKILL');
+            } catch (e) {}
+          }
+        }
+      }
+
+      queries.updateSession(runId, { status: 'interrupted', completed_at: Date.now() });
+      queries.setIsStreaming(threadId, false);
+      activeExecutions.delete(threadId);
+
+      broadcastSync({
+        type: 'streaming_complete',
+        sessionId: runId,
+        conversationId: threadId,
+        interrupted: true,
+        timestamp: Date.now()
+      });
+
+      sendJSON(req, res, 204, {});
+      return;
+    }
+
     if (pathOnly === '/api/stt' && req.method === 'POST') {
       try {
         const chunks = [];
@@ -1716,6 +2419,30 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/speech-status' && req.method === 'POST') {
+      const body = await parseBody(req);
+      if (body.forceDownload) {
+        modelDownloadState.complete = false;
+        modelDownloadState.downloading = false;
+        modelDownloadState.error = null;
+        ensureModelsDownloaded().then(ok => {
+          broadcastSync({
+            type: 'model_download_progress',
+            progress: { done: true, complete: ok, error: ok ? null : 'Download failed' }
+          });
+        }).catch(err => {
+          broadcastSync({
+            type: 'model_download_progress',
+            progress: { done: true, error: err.message }
+          });
+        });
+        sendJSON(req, res, 200, { ok: true, message: 'Starting model download' });
+        return;
+      }
+      sendJSON(req, res, 400, { error: 'Unknown request' });
+      return;
+    }
+
     if (pathOnly === '/api/clone' && req.method === 'POST') {
       const body = await parseBody(req);
       const repo = (body.repo || '').trim();
@@ -1773,10 +2500,12 @@ const server = http.createServer(async (req, res) => {
         const remoteUrl = result.trim();
         const statusResult = execSync('git status --porcelain', { encoding: 'utf-8', cwd: STARTUP_CWD });
         const hasChanges = statusResult.trim().length > 0;
+        const unpushedResult = execSync('git rev-list --count --not --remotes 2>/dev/null', { encoding: 'utf-8', cwd: STARTUP_CWD });
+        const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
         const ownsRemote = !remoteUrl.includes('github.com/') || remoteUrl.includes(process.env.GITHUB_USER || '');
-        sendJSON(req, res, 200, { ownsRemote, hasChanges, remoteUrl });
+        sendJSON(req, res, 200, { ownsRemote, hasChanges, hasUnpushed, remoteUrl });
       } catch {
-        sendJSON(req, res, 200, { ownsRemote: false, hasChanges: false, remoteUrl: '' });
+        sendJSON(req, res, 200, { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' });
       }
       return;
     }

package/static/index.html

@@ -38,6 +38,16 @@
       --sidebar-width: 300px;
       --header-height: 52px;
       --msg-max-width: 100%;
+      --block-color-0: #8b5cf6;
+      --block-color-1: #ec4899;
+      --block-color-2: #14b8a6;
+      --block-color-3: #f97316;
+      --block-color-4: #06b6d4;
+      --block-color-5: #84cc16;
+      --block-color-6: #a855f7;
+      --block-color-7: #f43f5e;
+      --block-color-8: #22c55e;
+      --block-color-9: #eab308;
     }
 
     html.dark {
@@ -46,6 +56,16 @@
       --color-text-primary: #f9fafb;
       --color-text-secondary: #d1d5db;
       --color-border: #374151;
+      --block-color-0: #a78bfa;
+      --block-color-1: #f472b6;
+      --block-color-2: #2dd4bf;
+      --block-color-3: #fb923c;
+      --block-color-4: #22d3ee;
+      --block-color-5: #a3e635;
+      --block-color-6: #c084fc;
+      --block-color-7: #fb7185;
+      --block-color-8: #4ade80;
+      --block-color-9: #facc15;
     }
 
     html, body {
@@ -878,6 +898,45 @@
 
     .send-btn svg { width: 18px; height: 18px; }
 
+    .stop-btn {
+      display: none;
+      align-items: center;
+      justify-content: center;
+      width: 40px;
+      height: 40px;
+      background-color: #dc2626;
+      color: white;
+      border: none;
+      border-radius: 0.5rem;
+      cursor: pointer;
+      flex-shrink: 0;
+      transition: background-color 0.15s;
+    }
+
+    .stop-btn:hover:not(:disabled) { background-color: #b91c1c; }
+    .stop-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+    .stop-btn.visible { display: flex; }
+
+    .inject-btn {
+      display: none;
+      align-items: center;
+      justify-content: center;
+      width: 40px;
+      height: 40px;
+      background-color: #f59e0b;
+      color: white;
+      border: none;
+      border-radius: 0.5rem;
+      cursor: pointer;
+      flex-shrink: 0;
+      transition: background-color 0.15s;
+      margin-right: 0.25rem;
+    }
+
+    .inject-btn:hover:not(:disabled) { background-color: #d97706; }
+    .inject-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+    .inject-btn.visible { display: flex; }
+
     /* ===== OVERLAY for mobile sidebar ===== */
     .sidebar-overlay {
       display: none;
@@ -1275,7 +1334,6 @@
     .streaming-blocks { contain: content; }
     .sidebar-list { contain: strict; content-visibility: auto; }
     .message { contain: layout style; content-visibility: auto; contain-intrinsic-size: auto 80px; }
-    #output-scroll { will-change: transform; }
 
     .voice-block .voice-result-stats {
       font-size: 0.8rem;
@@ -2489,6 +2547,16 @@
             aria-label="Message input"
             rows="1"
           ></textarea>
+          <button class="inject-btn" id="injectBtn" title="Inject instructions into running agent" aria-label="Inject instructions">
+            <svg viewBox="0 0 24 24" fill="currentColor" width="18" height="18">
+              <path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z"/>
+            </svg>
+          </button>
+          <button class="stop-btn" id="stopBtn" title="Stop running agent (emergency)" aria-label="Stop agent">
+            <svg viewBox="0 0 24 24" fill="currentColor" width="18" height="18">
+              <path d="M6 6h12v12H6z"/>
+            </svg>
+          </button>
           <button class="send-btn" data-send-button title="Send message (Ctrl+Enter)" aria-label="Send message">
             <svg viewBox="0 0 24 24" fill="currentColor">
               <path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z"/>

package/static/js/client.js

@@ -110,6 +110,9 @@ class AgentGUIClient {
       await this.loadAgents();
       await this.loadConversations();
 
+      // Check speech model status
+      await this.checkSpeechStatus();
+
       // Enable controls for initial interaction
       this.enableControls();
 
@@ -344,6 +347,43 @@ class AgentGUIClient {
       this.ui.sendButton.addEventListener('click', () => this.startExecution());
     }
 
+    this.ui.stopButton = document.getElementById('stopBtn');
+    this.ui.injectButton = document.getElementById('injectBtn');
+
+    if (this.ui.stopButton) {
+      this.ui.stopButton.addEventListener('click', async () => {
+        if (!this.state.currentConversation) return;
+        try {
+          const resp = await fetch(`${window.__BASE_URL}/api/conversations/${this.state.currentConversation.id}/cancel`, {
+            method: 'POST'
+          });
+          const data = await resp.json();
+          console.log('Stop response:', data);
+        } catch (err) {
+          console.error('Failed to stop:', err);
+        }
+      });
+    }
+
+    if (this.ui.injectButton) {
+      this.ui.injectButton.addEventListener('click', async () => {
+        if (!this.state.currentConversation) return;
+        const instructions = prompt('Enter instructions to inject into the running agent:');
+        if (!instructions) return;
+        try {
+          const resp = await fetch(`${window.__BASE_URL}/api/conversations/${this.state.currentConversation.id}/inject`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ content: instructions })
+          });
+          const data = await resp.json();
+          console.log('Inject response:', data);
+        } catch (err) {
+          console.error('Failed to inject:', err);
+        }
+      });
+    }
+
     if (this.ui.messageInput) {
       this.ui.messageInput.addEventListener('keydown', (e) => {
         if (e.key === 'Enter' && e.ctrlKey) {
@@ -468,6 +508,11 @@ class AgentGUIClient {
       this._serverProcessingEstimate = 0.7 * this._serverProcessingEstimate + 0.3 * serverTime;
     }
 
+    // Show stop and inject buttons when streaming starts
+    if (this.ui.stopButton) this.ui.stopButton.classList.add('visible');
+    if (this.ui.injectButton) this.ui.injectButton.classList.add('visible');
+    if (this.ui.sendButton) this.ui.sendButton.style.display = 'none';
+
     // If this streaming event is for a different conversation than what we are viewing,
     // just track the state but do not modify the DOM or start polling
     if (this.state.currentConversation?.id !== data.conversationId) {
@@ -720,6 +765,11 @@ class AgentGUIClient {
     console.error('Streaming error:', data);
     this._clearThinkingCountdown();
 
+    // Hide stop and inject buttons on error
+    if (this.ui.stopButton) this.ui.stopButton.classList.remove('visible');
+    if (this.ui.injectButton) this.ui.injectButton.classList.remove('visible');
+    if (this.ui.sendButton) this.ui.sendButton.style.display = '';
+
     const conversationId = data.conversationId || this.state.currentSession?.conversationId;
 
     // If this event is for a conversation we are NOT currently viewing, just track state
@@ -752,6 +802,11 @@ class AgentGUIClient {
     console.log('Streaming completed:', data);
     this._clearThinkingCountdown();
 
+    // Hide stop and inject buttons when streaming completes
+    if (this.ui.stopButton) this.ui.stopButton.classList.remove('visible');
+    if (this.ui.injectButton) this.ui.injectButton.classList.remove('visible');
+    if (this.ui.sendButton) this.ui.sendButton.style.display = '';
+
     const conversationId = data.conversationId || this.state.currentSession?.conversationId;
     if (conversationId) this.invalidateCache(conversationId);
 
@@ -788,28 +843,21 @@ class AgentGUIClient {
     this.enableControls();
     this.emit('streaming:complete', data);
 
-    if (data.agentId && this._isACPAgent(data.agentId)) {
-      this._promptPushIfWeOwnRemote();
-    }
-  }
-
-  _isACPAgent(agentId) {
-    const acpAgents = ['opencode', 'gemini', 'goose', 'openhands', 'augment', 'cline', 'kimi', 'qwen', 'codex', 'mistral', 'kiro', 'fast-agent'];
-    return acpAgents.includes(agentId);
+    this._promptPushIfWeOwnRemote();
   }
 
   async _promptPushIfWeOwnRemote() {
     try {
       const result = await fetch(window.__BASE_URL + '/api/git/check-remote-ownership');
-      const { ownsRemote, hasChanges, remoteUrl } = await result.json();
-      if (ownsRemote && hasChanges) {
-        const shouldPush = confirm('Push changes to remote?');
-        if (shouldPush) {
-          await fetch(window.__BASE_URL + '/api/git/push', { method: 'POST' });
+      const { ownsRemote, hasChanges, hasUnpushed, remoteUrl } = await result.json();
+      if (ownsRemote && (hasChanges || hasUnpushed)) {
+        const conv = this.state.currentConversation;
+        if (conv) {
+          this.streamToConversation(conv.id, 'Push the changes to the remote repository.', conv.agentId);
         }
       }
     } catch (e) {
-      console.warn('Failed to check git remote ownership:', e);
+      console.warn('Auto-push check failed:', e);
     }
   }
 
@@ -1788,6 +1836,23 @@ class AgentGUIClient {
     });
   }
 
+  async checkSpeechStatus() {
+    try {
+      const response = await fetch(window.__BASE_URL + '/api/speech-status');
+      const status = await response.json();
+      if (status.modelsComplete) {
+        this._modelDownloadProgress = { done: true, complete: true };
+        this._modelDownloadInProgress = false;
+      } else if (status.modelsDownloading) {
+        this._modelDownloadProgress = status.modelsProgress || { downloading: true };
+        this._modelDownloadInProgress = true;
+      }
+      this._updateVoiceTabState();
+    } catch (error) {
+      console.error('Failed to check speech status:', error);
+    }
+  }
+
   async loadModelsForAgent(agentId) {
     if (!agentId || !this.ui.modelSelector) return;
     const cached = this._modelCache.get(agentId);
@@ -1938,6 +2003,7 @@ class AgentGUIClient {
       this._modelDownloadInProgress = false;
       console.log('[Models] Download complete');
       this._updateConnectionIndicator(this.wsManager?.latency?.quality || 'unknown');
+      this._updateVoiceTabState();
       return;
     }
     
@@ -1947,6 +2013,16 @@ class AgentGUIClient {
     }
   }
 
+  _updateVoiceTabState() {
+    var voiceBtn = document.querySelector('[data-view="voice"]');
+    if (voiceBtn) {
+      var isReady = this._modelDownloadProgress?.done === true || 
+                    this._modelDownloadProgress?.complete === true;
+      voiceBtn.disabled = !isReady;
+      voiceBtn.title = isReady ? 'Voice' : 'Downloading voice models...';
+    }
+  }
+
   _toggleConnectionTooltip() {
     let tooltip = document.getElementById('connection-tooltip');
     if (tooltip) { tooltip.remove(); return; }

package/static/js/features.js

@@ -188,11 +188,25 @@
     buttons.forEach(function(btn) {
       btn.addEventListener('click', function() {
         var view = btn.dataset.view;
+        if (view === 'voice' && !isVoiceReady()) {
+          showToast('Downloading voice models... please wait', 'info');
+          return;
+        }
         switchView(view);
       });
     });
   }
 
+  function isVoiceReady() {
+    if (window.agentGUIClient && window.agentGUIClient._modelDownloadInProgress === false) {
+      return window.agentGUIClient._modelDownloadProgress?.done === true || 
+             window.agentGUIClient._modelDownloadProgress?.complete === true;
+    }
+    return false;
+  }
+
+  window.__checkVoiceReady = isVoiceReady;
+
   function switchView(view) {
     currentView = view;
     var bar = document.getElementById('viewToggleBar');

package/static/js/streaming-renderer.js

@@ -399,9 +399,25 @@ class StreamingRenderer {
     div.className = 'block-text';
     if (isHtml) div.classList.add('html-content');
     div.innerHTML = html;
+    const colorIndex = this._getUniqueColorIndex(text);
+    div.style.borderLeft = `3px solid var(--block-color-${colorIndex})`;
     return div;
   }
 
+  _getUniqueColorIndex(text) {
+    if (!this._colorIndexMap) {
+      this._colorIndexMap = new Map();
+      this._colorCounter = 0;
+    }
+    let index = this._colorIndexMap.get(text);
+    if (index === undefined) {
+      index = this._colorCounter % 10;
+      this._colorIndexMap.set(text, index);
+      this._colorCounter++;
+    }
+    return index;
+  }
+
   containsHtmlTags(text) {
     const htmlPattern = /<(?:div|table|section|article|ul|ol|dl|nav|header|footer|main|aside|figure|details|summary|h[1-6]|p|blockquote|pre|code|span|strong|em|a|img|br|hr|li|td|tr|th|thead|tbody|tfoot)\b[^>]*>/i;
     return htmlPattern.test(text);

package/static/js/voice.js

@@ -296,7 +296,19 @@
     if (!ttsEnabled) return;
     var clean = text.replace(/<[^>]*>/g, '').trim();
     if (!clean) return;
-    speechQueue.push(clean);
+    var parts = [];
+    if (typeof agentGUIClient !== 'undefined' && agentGUIClient && typeof agentGUIClient.parseMarkdownCodeBlocks === 'function') {
+      parts = agentGUIClient.parseMarkdownCodeBlocks(clean);
+    } else {
+      parts = [{ type: 'text', content: clean }];
+    }
+    parts.forEach(function(part) {
+      if (part.type === 'code') return;
+      var segment = part.content.trim();
+      if (segment) {
+        speechQueue.push(segment);
+      }
+    });
     processQueue();
   }