agentgui 1.0.436 → 1.0.438

package/CLAUDE.md

@@ -17,6 +17,7 @@ Server starts on `http://localhost:3000`, redirects to `/gm/`.
 server.js              HTTP server + WebSocket + all API routes (raw http.createServer)
 database.js            SQLite setup (WAL mode), schema, query functions
 lib/claude-runner.js   Agent framework - spawns CLI processes, parses stream-json output
+lib/acp-manager.js     ACP tool lifecycle - auto-starts opencode/kilo HTTP servers, restart on crash
 lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
 bin/gmgui.cjs          CLI entry point (npx agentgui / bunx agentgui)
 static/index.html      Main HTML shell
@@ -49,6 +50,14 @@ static/templates/                 31 HTML template fragments for event rendering
 - `STARTUP_CWD` - Working directory passed to agents
 - `HOT_RELOAD` - Set to "false" to disable watch mode
 
+## ACP Tool Lifecycle
+
+On startup, agentgui auto-launches bundled ACP tools (opencode, kilo) as HTTP servers:
+- OpenCode: port 18100 (`opencode acp --port 18100`)
+- Kilo: port 18101 (`kilo acp --port 18101`)
+
+Managed by `lib/acp-manager.js`. Features: crash restart with exponential backoff (max 10 in 5min), health checks every 30s via `GET /provider`, clean shutdown on SIGTERM. The `acpPort` field on discovered agents is set automatically once healthy. Models are queried from the running ACP HTTP servers via their `/provider` endpoint.
+
 ## REST API
 
 All routes are prefixed with `BASE_URL` (default `/gm`).
@@ -68,6 +77,7 @@ All routes are prefixed with `BASE_URL` (default `/gm`).
 - `GET /api/sessions/:id/chunks` - Get session chunks (query: since)
 - `GET /api/sessions/:id/execution` - Get execution events (query: limit, offset, filterType)
 - `GET /api/agents` - List discovered agents
+- `GET /api/acp/status` - ACP tool lifecycle status (ports, health, PIDs, restart counts)
 - `GET /api/home` - Get home directory
 - `POST /api/stt` - Speech-to-text (raw audio body)
 - `POST /api/tts` - Text-to-speech (body: text)

package/build-portable.js

@@ -122,6 +122,32 @@ const audioDeps = new Set();
 collectDeps('audio-decode', audioDeps);
 for (const dep of audioDeps) copyPkg(dep);
 
+log('Copying ACP tools (opencode, kilo, gemini) for portable...');
+const acpNativeTools = [
+  { wrapper: 'opencode-ai', platformPrefix: 'opencode-windows-x64' },
+  { wrapper: '@kilocode/cli', platformPrefix: '@kilocode/cli-windows-x64' },
+];
+for (const tool of acpNativeTools) {
+  const wrapperSrc = path.join(nm, tool.wrapper);
+  if (fs.existsSync(wrapperSrc)) copyDir(wrapperSrc, path.join(destNm, tool.wrapper));
+  for (const suffix of ['', '-baseline']) {
+    const platPkg = tool.platformPrefix + suffix;
+    const platSrc = path.join(nm, platPkg);
+    if (fs.existsSync(platSrc)) {
+      copyDir(platSrc, path.join(destNm, platPkg));
+      log(`  ${platPkg} (${Math.round(sizeOf(platSrc) / 1024 / 1024)}MB)`);
+    }
+  }
+}
+const geminiSrc = path.join(nm, '@google', 'gemini-cli');
+if (fs.existsSync(geminiSrc)) {
+  copyDir(geminiSrc, path.join(destNm, '@google', 'gemini-cli'));
+  const geminiDeps = new Set();
+  collectDeps('@google/gemini-cli', geminiDeps);
+  for (const dep of geminiDeps) copyPkg(dep);
+  log(`  gemini-cli + ${geminiDeps.size} deps`);
+}
+
 log('Copying @anthropic-ai/claude-code ripgrep (win32)...');
 const claudeSrc = path.join(nm, '@anthropic-ai', 'claude-code');
 const claudeDest = path.join(destNm, '@anthropic-ai', 'claude-code');
@@ -157,17 +183,8 @@ if (process.env.NO_BUNDLE_MODELS === 'true') {
   }
 }
 
-fs.writeFileSync(path.join(out, 'README.txt'), [
-  '# AgentGUI Portable',
-  '',
-  'No installation required. Double-click agentgui.exe to start.',
-  '',
-  'Web interface: http://localhost:3000/gm/',
-  '',
-  'Data is stored in the data/ folder next to the executable.',
-  '',
-  'Requirements: None - fully self-contained.',
-].join('\n'));
+fs.writeFileSync(path.join(out, 'README.txt'),
+  '# AgentGUI Portable\n\nDouble-click agentgui.exe to start.\nWeb interface: http://localhost:3000/gm/\nData stored in data/ folder. Fully self-contained.\n');
 
 const totalMB = Math.round(sizeOf(out) / 1024 / 1024);
 log(`Build complete! Total: ${totalMB}MB  Output: ${out}`);

package/lib/acp-manager.js

@@ -0,0 +1,179 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..');
+const isWindows = os.platform() === 'win32';
+
+const ACP_TOOLS = [
+  { id: 'opencode', cmd: 'opencode', args: ['acp'], port: 18100, npxPkg: 'opencode-ai' },
+  { id: 'kilo', cmd: 'kilo', args: ['acp'], port: 18101, npxPkg: '@kilocode/cli' },
+];
+
+const MAX_RESTARTS = 10;
+const RESTART_WINDOW_MS = 300000;
+const HEALTH_INTERVAL_MS = 30000;
+const STARTUP_GRACE_MS = 5000;
+const processes = new Map();
+let healthTimer = null;
+let shuttingDown = false;
+
+function log(msg) { console.log('[ACP] ' + msg); }
+
+function resolveBinary(cmd) {
+  const ext = isWindows ? '.cmd' : '';
+  const localBin = path.join(projectRoot, 'node_modules', '.bin', cmd + ext);
+  if (fs.existsSync(localBin)) return localBin;
+  return cmd;
+}
+
+function startProcess(tool) {
+  if (shuttingDown) return null;
+  const bin = resolveBinary(tool.cmd);
+  const args = [...tool.args, '--port', String(tool.port)];
+  const opts = { stdio: ['pipe', 'pipe', 'pipe'], cwd: process.cwd() };
+  if (isWindows) opts.shell = true;
+
+  let proc;
+  try { proc = spawn(bin, args, opts); }
+  catch (err) { log(tool.id + ' spawn failed: ' + err.message); return null; }
+
+  const entry = {
+    id: tool.id, port: tool.port, process: proc, pid: proc.pid,
+    startedAt: Date.now(), restarts: [], healthy: false, lastHealthCheck: 0,
+  };
+
+  proc.stdout.on('data', () => {});
+  proc.stderr.on('data', (d) => {
+    const t = d.toString().trim();
+    if (t) log(tool.id + ': ' + t.substring(0, 200));
+  });
+  proc.stdout.on('error', () => {});
+  proc.stderr.on('error', () => {});
+  proc.on('error', (err) => { log(tool.id + ' error: ' + err.message); entry.healthy = false; });
+
+  proc.on('close', (code) => {
+    entry.healthy = false;
+    if (shuttingDown) return;
+    log(tool.id + ' exited code ' + code);
+    scheduleRestart(tool, entry.restarts);
+  });
+
+  processes.set(tool.id, entry);
+  log(tool.id + ' started port ' + tool.port + ' pid ' + proc.pid);
+  setTimeout(() => checkHealth(tool.id), STARTUP_GRACE_MS);
+  return entry;
+}
+
+function scheduleRestart(tool, prevRestarts = []) {
+  if (shuttingDown) return;
+  const now = Date.now();
+  const recent = prevRestarts.filter(t => now - t < RESTART_WINDOW_MS);
+  if (recent.length >= MAX_RESTARTS) {
+    log(tool.id + ' exceeded restart limit, giving up');
+    processes.delete(tool.id);
+    return;
+  }
+  const delay = Math.min(1000 * Math.pow(2, recent.length), 30000);
+  log(tool.id + ' restarting in ' + delay + 'ms');
+  setTimeout(() => {
+    if (shuttingDown) return;
+    const entry = startProcess(tool);
+    if (entry) entry.restarts = [...recent, Date.now()];
+  }, delay);
+}
+
+async function checkHealth(toolId) {
+  const entry = processes.get(toolId);
+  if (!entry || shuttingDown) return;
+  try {
+    const res = await fetch('http://127.0.0.1:' + entry.port + '/provider', {
+      signal: AbortSignal.timeout(3000), headers: { 'Accept': 'application/json' }
+    });
+    entry.healthy = res.ok;
+  } catch (_) { entry.healthy = false; }
+  entry.lastHealthCheck = Date.now();
+}
+
+export async function startAll() {
+  log('starting ACP tools...');
+  for (const tool of ACP_TOOLS) {
+    const bin = resolveBinary(tool.cmd);
+    if (bin === tool.cmd && !fs.existsSync(bin)) {
+      log(tool.id + ' not found, skipping');
+      continue;
+    }
+    startProcess(tool);
+  }
+  healthTimer = setInterval(() => {
+    for (const [id] of processes) checkHealth(id);
+  }, HEALTH_INTERVAL_MS);
+}
+
+export async function stopAll() {
+  shuttingDown = true;
+  if (healthTimer) { clearInterval(healthTimer); healthTimer = null; }
+  const kills = [];
+  for (const [id, entry] of processes) {
+    log('stopping ' + id + ' pid ' + entry.pid);
+    kills.push(new Promise(resolve => {
+      const t = setTimeout(() => { try { entry.process.kill('SIGKILL'); } catch (_) {} resolve(); }, 5000);
+      entry.process.on('close', () => { clearTimeout(t); resolve(); });
+      try { entry.process.kill('SIGTERM'); } catch (_) {}
+    }));
+  }
+  await Promise.all(kills);
+  processes.clear();
+  log('all stopped');
+}
+
+export function getStatus() {
+  return Array.from(processes.values()).map(e => ({
+    id: e.id, port: e.port, pid: e.pid, healthy: e.healthy,
+    uptime: Date.now() - e.startedAt, restartCount: e.restarts.length,
+  }));
+}
+
+export function getPort(agentId) {
+  const e = processes.get(agentId);
+  return e?.healthy ? e.port : null;
+}
+
+export function getRunningPorts() {
+  const ports = {};
+  for (const [id, e] of processes) if (e.healthy) ports[id] = e.port;
+  return ports;
+}
+
+export async function restart(agentId) {
+  const tool = ACP_TOOLS.find(t => t.id === agentId);
+  if (!tool) return false;
+  const entry = processes.get(agentId);
+  if (entry) { try { entry.process.kill('SIGTERM'); } catch (_) {} processes.delete(agentId); }
+  startProcess(tool);
+  return true;
+}
+
+export async function queryModels(agentId) {
+  const entry = processes.get(agentId);
+  if (!entry?.healthy) return [];
+  try {
+    const res = await fetch('http://127.0.0.1:' + entry.port + '/provider', {
+      signal: AbortSignal.timeout(5000), headers: { 'Accept': 'application/json' }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const models = [];
+    for (const prov of (data.all || [])) {
+      for (const m of Object.values(prov.models || {})) {
+        models.push({ id: m.id, label: m.name || m.id, provider: prov.name || prov.id });
+      }
+    }
+    return models;
+  } catch (_) { return []; }
+}
+
+export const ACP_TOOL_CONFIGS = ACP_TOOLS;

package/lib/ws-handlers-session.js

@@ -68,71 +68,6 @@ async function acpFetch(port, pth, body = null) {
   return res.json();
 }
 
-function getApiKey(name) {
-  const envMap = {
-    anthropic: 'ANTHROPIC_API_KEY',
-    google: 'GOOGLE_GENAI_API_KEY',
-    openai: 'OPENAI_API_KEY'
-  };
-  if (process.env[envMap[name]]) return process.env[envMap[name]];
-  const configPaths = {
-    anthropic: [
-      path.join(os.homedir(), '.claude.json'),
-      path.join(os.homedir(), '.anthropic.json')
-    ],
-    google: [
-      path.join(os.homedir(), '.gemini.json'),
-      path.join(os.homedir(), '.config', 'gemini', 'credentials.json')
-    ],
-    openai: [
-      path.join(os.homedir(), '.openai.json')
-    ]
-  };
-  for (const p of (configPaths[name] || [])) {
-    const data = readJson(p);
-    if (data) {
-      const key = data.api_key || data.apiKey || data.github_token;
-      if (key) return key;
-    }
-  }
-  return null;
-}
-
-async function fetchModelsFromAPI(agentId) {
-  if (agentId === 'claude-code') {
-    const apiKey = getApiKey('anthropic');
-    if (!apiKey) return null;
-    try {
-      const res = await fetch('https://api.anthropic.com/v1/models', {
-        headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
-        signal: AbortSignal.timeout(8000)
-      });
-      if (!res.ok) return null;
-      const data = await res.json();
-      const items = (data.data || []).filter(m => m.id && m.id.startsWith('claude-'));
-      if (items.length === 0) return null;
-      return items.map(m => ({ id: m.id, label: m.display_name || m.id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) }));
-    } catch { return null; }
-  }
-  if (agentId === 'gemini') {
-    const apiKey = getApiKey('google');
-    if (!apiKey) return null;
-    try {
-      const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`, {
-        signal: AbortSignal.timeout(8000)
-      });
-      if (!res.ok) return null;
-      const data = await res.json();
-      const items = (data.models || []).filter(m => m.name && m.name.includes('gemini'));
-      if (items.length === 0) return null;
-      return items.map(m => {
-        const id = m.name.replace(/^models\//, '');
-        return { id, label: id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) };
-      });
-    } catch { return null; }
-  }
-  return null;
-}
 
 export function register(router, deps) {
   const { db, discoveredAgents, modelCache,
@@ -194,69 +129,29 @@ export function register(router, deps) {
     return d;
   });
 
-  router.handle('agent.models', async (p) => {
-    const cached = modelCache.get(p.id);
-    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
-    const agent = discoveredAgents.find(x => x.id === p.id);
-    if (agent?.protocol === 'acp' && agent.acpPort) {
-      const port = agent.acpPort;
-      try {
-        const data = await acpFetch(port, '/v1/models');
-        const models = (data?.data || data?.models || []).map(m => ({
-          id: m.id || m.model_id,
-          label: m.name || m.display_name || m.id || m.model_id
-        })).filter(m => m.id);
-        if (models.length > 0) { modelCache.set(p.id, { models, ts: Date.now() }); return { models }; }
-      } catch (_) {}
-      try {
-        const data = await acpFetch(port, '/agents/search', {});
-        const list = Array.isArray(data) ? data : (data?.agents || []);
-        const allModels = new Map();
-        for (const a of list) {
-          const agentId = a.agent_id || a.id;
-          const name = a.metadata?.ref?.name || a.name || agentId;
-          if (agentId && name) allModels.set(agentId, name);
-          for (const m of (a.metadata?.models || a.specs?.models || [])) {
-            const id = m.id || m;
-            if (id) allModels.set(id, m.name || m.label || id);
-          }
-          try {
-            const desc = await acpFetch(port, `/agents/${agentId}/descriptor`);
-            const enumVals = desc?.specs?.config?.properties?.model?.enum || desc?.specs?.input?.properties?.model?.enum || [];
-            for (const v of enumVals) allModels.set(v, v);
-          } catch (_) {}
-        }
-        if (allModels.size > 0) {
-          const models = Array.from(allModels.entries()).map(([id, label]) => ({ id, label }));
-          modelCache.set(p.id, { models, ts: Date.now() });
-          return { models };
-        }
-      } catch (_) {}
-    }
-    const acpAgents = discoveredAgents.filter(x => x.protocol === 'acp' && x.acpPort);
-    for (const acpAgent of acpAgents) {
-      const port = acpAgent.acpPort;
-      try {
-        const desc = await acpFetch(port, `/agents/${p.id}/descriptor`);
-        if (desc) {
-          const enumVals = desc?.specs?.config?.properties?.model?.enum || desc?.specs?.input?.properties?.model?.enum || [];
-          if (enumVals.length > 0) {
-            const models = enumVals.map(v => ({ id: v, label: v }));
-            modelCache.set(p.id, { models, ts: Date.now() });
-            return { models };
-          }
-          const name = desc?.metadata?.ref?.name;
-          if (name) { const models = [{ id: p.id, label: name }]; modelCache.set(p.id, { models, ts: Date.now() }); return { models }; }
-        }
-      } catch (_) {}
-    }
-    const apiModels = await fetchModelsFromAPI(p.id);
-    if (apiModels && apiModels.length > 0) {
-      modelCache.set(p.id, { models: apiModels, ts: Date.now() });
-      return { models: apiModels };
-    }
-    return { models: [] };
-  });
+  router.handle('agent.models', async (p) => {
+    const cached = modelCache.get(p.id);
+    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
+    let models = [];
+    if (p.id === 'claude-code') {
+      models = [
+        { id: 'claude-haiku', label: 'Haiku' },
+        { id: 'claude-sonnet', label: 'Sonnet' },
+        { id: 'claude-opus', label: 'Opus' }
+      ];
+    } else {
+      const agent = discoveredAgents.find(x => x.id === p.id);
+      if (agent?.protocol === 'acp' && agent.acpPort) {
+        try {
+          const data = await acpFetch(agent.acpPort, '/models');
+          const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
+          models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
+        } catch (_) {}
+      }
+    }
+    if (models.length > 0) modelCache.set(p.id, { models, ts: Date.now() });
+    return { models };
+  });
 
   router.handle('agent.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.436",
+  "version": "1.0.438",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",
@@ -33,7 +33,7 @@
     "fsbrowse": "^0.2.18",
     "google-auth-library": "^10.5.0",
     "onnxruntime-node": "1.21.0",
-    "opencode-ai": "latest",
+    "opencode-ai": "^1.2.15",
     "puppeteer-core": "^24.37.5",
     "webtalk": "^1.0.31",
     "ws": "^8.14.2"

package/server.js

@@ -22,6 +22,7 @@ import { register as registerConvHandlers } from './lib/ws-handlers-conv.js';
 import { register as registerSessionHandlers } from './lib/ws-handlers-session.js';
 import { register as registerRunHandlers } from './lib/ws-handlers-run.js';
 import { register as registerUtilHandlers } from './lib/ws-handlers-util.js';
+import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, queryModels as queryACPModels } from './lib/acp-manager.js';
 
 
 process.on('uncaughtException', (err, origin) => {
@@ -411,22 +412,13 @@ function discoverAgents() {
 
 // Function to discover agents from external ACP servers
 async function discoverExternalACPServers() {
-  // Default ACP servers to query (excluding local server to prevent recursion)
-  const acpServers = [
-    'http://localhost:8080',         // Common default ACP port
-  ];
-  
   const externalAgents = [];
-  for (const serverUrl of acpServers) {
+  for (const agent of discoveredAgents.filter(a => a.protocol === 'acp' && a.acpPort)) {
     try {
-      console.log(`Querying ACP agents from: ${serverUrl}`);
-      const agents = await queryACPServerAgents(serverUrl);
+      const agents = await queryACPServerAgents(`http://localhost:${agent.acpPort}`);
       externalAgents.push(...agents);
-    } catch (error) {
-      console.error(`Failed to query ${serverUrl}:`, error.message);
-    }
+    } catch (_) {}
   }
-  
   return externalAgents;
 }
 
@@ -435,53 +427,40 @@ initializeDescriptors(discoveredAgents);
 
 const modelCache = new Map();
 
-function modelIdToLabel(id) {
-  const base = id.replace(/^claude-/, '').replace(/-\d{8}$/, '');
-  const m = base.match(/^(\w+)-(\d+)(?:-(\d+))?$/);
-  if (m) return `${m[1].charAt(0).toUpperCase() + m[1].slice(1)} ${m[3] ? m[2] + '.' + m[3] : m[2]}`;
-  return base.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
-}
-
 async function getModelsForAgent(agentId) {
   const cached = modelCache.get(agentId);
-  if (cached && Date.now() - cached.timestamp < 3600000) return cached.models;
-  let models = null;
+  if (cached && Date.now() - cached.timestamp < 300000) return cached.models;
+  let models = [];
   if (agentId === 'claude-code') {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey) {
-      try {
-        const res = await fetch('https://api.anthropic.com/v1/models', {
-          headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
-          signal: AbortSignal.timeout(8000)
-        });
-        if (res.ok) {
-          const data = await res.json();
-          const items = (data.data || []).filter(m => m.id && m.id.startsWith('claude-'));
-          if (items.length > 0) models = items.map(m => ({ id: m.id, label: m.display_name || modelIdToLabel(m.id) }));
-        }
-      } catch (_) {}
-    }
-  } else if (agentId === 'gemini') {
-    const apiKey = process.env.GOOGLE_GENAI_API_KEY;
-    if (apiKey) {
-      try {
-        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`, {
-          signal: AbortSignal.timeout(8000)
-        });
-        if (res.ok) {
-          const data = await res.json();
-          const items = (data.models || []).filter(m => m.name && m.name.includes('gemini'));
-          if (items.length > 0) models = items.map(m => {
-            const id = m.name.replace(/^models\//, '');
-            return { id, label: id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) };
-          });
-        }
-      } catch (_) {}
+    models = [
+      { id: 'claude-haiku', label: 'Haiku' },
+      { id: 'claude-sonnet', label: 'Sonnet' },
+      { id: 'claude-opus', label: 'Opus' }
+    ];
+  } else {
+    const agent = discoveredAgents.find(a => a.id === agentId);
+    if (agent?.protocol === 'acp') {
+      const acpPort = getACPPort(agentId) || agent.acpPort;
+      if (acpPort) {
+        try {
+          models = await queryACPModels(agentId);
+          if (!models.length) {
+            const res = await fetch(`http://localhost:${acpPort}/models`, {
+              headers: { 'Content-Type': 'application/json' },
+              signal: AbortSignal.timeout(3000)
+            });
+            if (res.ok) {
+              const data = await res.json();
+              const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
+              models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
+            }
+          }
+        } catch (_) {}
+      }
     }
   }
-  const result = models || [];
-  modelCache.set(agentId, { models: result, timestamp: Date.now() });
-  return result;
+  modelCache.set(agentId, { models, timestamp: Date.now() });
+  return models;
 }
 
 const GEMINI_SCOPES = [
@@ -1775,6 +1754,11 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/acp/status' && req.method === 'GET') {
+      sendJSON(req, res, 200, { tools: getACPStatus() });
+      return;
+    }
+
     if (pathOnly === '/api/ws-stats' && req.method === 'GET') {
       const stats = wsOptimizer.getStats();
       sendJSON(req, res, 200, stats);
@@ -3851,7 +3835,7 @@ registerConvHandlers(wsRouter, {
 });
 
 registerSessionHandlers(wsRouter, {
-  db: queries, discoveredAgents, getModelsForAgent, modelCache,
+  db: queries, discoveredAgents, modelCache,
   getAgentDescriptor, activeScripts, broadcastSync,
   startGeminiOAuth, geminiOAuthState: () => geminiOAuthState
 });
@@ -3993,7 +3977,11 @@ if (watch) {
 
 process.on('SIGTERM', () => {
   console.log('[SIGNAL] SIGTERM received - graceful shutdown');
-  wss.close(() => server.close(() => process.exit(0)));
+  stopACPTools().then(() => {
+    wss.close(() => server.close(() => process.exit(0)));
+  }).catch(() => {
+    wss.close(() => server.close(() => process.exit(0)));
+  });
 });
 
 server.on('error', (err) => {
@@ -4196,6 +4184,21 @@ function onServerReady() {
 
   resumeInterruptedStreams().catch(err => console.error('[RESUME] Startup error:', err.message));
 
+  startACPTools().then(() => {
+    setTimeout(() => {
+      const acpStatus = getACPStatus();
+      for (const s of acpStatus) {
+        if (s.healthy) {
+          const agent = discoveredAgents.find(a => a.id === s.id);
+          if (agent) { agent.acpPort = s.port; }
+        }
+      }
+      if (acpStatus.length > 0) {
+        console.log(`[ACP] Tools ready: ${acpStatus.filter(s => s.healthy).map(s => s.id + ':' + s.port).join(', ') || 'none healthy yet'}`);
+      }
+    }, 6000);
+  }).catch(err => console.error('[ACP] Startup error:', err.message));
+
   ensureModelsDownloaded().then(async ok => {
     if (ok) console.log('[MODELS] Speech models ready');
     else console.log('[MODELS] Speech model download failed');