agentgui 1.0.727 → 1.0.729

package/CLAUDE.md

@@ -24,6 +24,7 @@ lib/agent-descriptors.js  Data-driven ACP agent descriptor builder
 lib/acp-sdk-manager.js ACP tool lifecycle - on-demand start opencode/kilo/codex, health checks, idle timeout
 lib/acp-server-machine.js  XState v5 machine per ACP tool: stopped/starting/running/crashed/restarting states
 lib/execution-machine.js   XState v5 machine per conversation: idle/streaming/draining/rate_limited states
+lib/tool-install-machine.js  XState v5 machine per tool: unchecked/checking/idle/installing/installed/updating/needs_update/failed states
 lib/ws-protocol.js     WebSocket RPC router (WsRouter class)
 lib/ws-optimizer.js    Per-client priority queue for WS event batching
 lib/ws-handlers-conv.js  Conversation CRUD, chunks, cancel, steer, inject RPC handlers
@@ -53,28 +54,38 @@ static/js/ui-components.js       UI component helpers
 static/js/syntax-highlighter.js  Code syntax highlighting
 static/js/voice.js               Voice input/output
 static/js/features.js            View toggle, drag-drop upload, model progress indicator
-static/js/tools-manager.js       Tool install/update UI
+static/js/tools-manager.js       Tool install/update UI orchestrator
+static/js/tools-manager-ui.js    Tool card rendering + voice selector helpers (split from tools-manager.js)
 static/js/ws-machine.js          XState v5 WS connection machine: disconnected/connecting/connected/reconnecting
 static/js/conv-machine.js        XState v5 per-conversation UI machine: idle/streaming/queued
+static/js/tool-install-machine.js  XState v5 per-tool UI install machine: idle/installing/installed/updating/needs_update/failed
+static/js/voice-machine.js       XState v5 voice/TTS machine: idle/queued/speaking/disabled (circuit-breaker)
+static/js/conv-list-machine.js   XState v5 conversation list machine: unloaded/loading/loaded/error
+static/js/prompt-machine.js      XState v5 prompt area machine: ready/loading/streaming/queued/disabled
 static/lib/xstate.umd.min.js     XState v5 browser bundle (UMD, served locally from node_modules)
 static/templates/                 31 HTML template fragments for event rendering
 ```
 
 ## XState State Machines
 
-XState v5 machines provide formal state tracking alongside (not replacing) the existing Map-based execution tracking. The machines are authoritative for state validation; the Maps remain as the operational data store.
+XState v5 machines are authoritative for their respective state domains. Ad-hoc Maps/Sets/booleans they replaced have been deleted.
 
 **Server machines** (ESM, `lib/`):
 - `execution-machine.js`: One actor per conversation. States: idle → streaming → draining (queue drain) → streaming → idle. Also rate_limited state. `execMachine.send(convId, event)` API. `conv.get` and `conv.full` WS responses include `executionState` field.
 - `acp-server-machine.js`: One actor per ACP tool (opencode/kilo/codex). States: stopped → starting → running ↔ crashed → restarting. Used by `acp-sdk-manager.js` to track health and drive restart backoff.
+- `tool-install-machine.js`: One actor per tool ID. States: unchecked → checking → idle/installed/needs_update/installing/updating/failed. Replaces `installLocks` Map in `tool-spawner.js`. Events: CHECK_START, IDLE, INSTALLED, NEEDS_UPDATE, INSTALL_START, INSTALL_COMPLETE, UPDATE_START, UPDATE_COMPLETE, FAILED. API: `getOrCreate(toolId)`, `send(toolId, event)`, `isLocked(toolId)`, `getMachineActors()`. Context: version, error, installedAt, lastCheckedAt. `GET /api/debug/machines` returns all snapshots when `DEBUG=1`.
 
 **Client machines** (browser UMD, `static/js/`):
 - `ws-machine.js`: Wraps WebSocketManager. States: disconnected/connecting/connected/reconnecting. Actor accessible as `wsManager._wsActor`. State readable via `wsManager.connectionState`.
 - `conv-machine.js`: One actor per conversation. States: idle/streaming/queued. API exposed as `window.convMachineAPI`. All actors in `window.__convMachines` Map for debug.
+- `tool-install-machine.js`: One actor per tool ID. States: idle/installing/installed/updating/needs_update/failed. Replaces `operationInProgress` Set in `tools-manager.js`. Context: version, error, progress, installedVersion, publishedVersion. API: `window.toolInstallMachineAPI`. Actors in `window.__toolInstallMachines`.
+- `voice-machine.js`: Single actor for TTS playback. States: idle/queued/speaking/disabled. Replaces isSpeaking, isPlayingChunk, ttsDisabledUntilReset booleans and ttsConsecutiveFailures counter in `voice.js`. Circuit-breaker trips at 3 consecutive failures (disabled state, RESET to recover). API: `window.voiceMachineAPI`. Actor at `window.__voiceMachine`.
+- `conv-list-machine.js`: Single actor for conversation list. States: unloaded/loading/loaded/error. Context: conversations[], activeId, streamingIds[], version, lastPollAt. Replaces `_conversationVersion`, `_lastMutationSource`, `streamingConversations` Set in `ConversationManager`. All list mutations go through machine events. API: `window.convListMachineAPI`. Actor at `window.__convListMachine`.
+- `prompt-machine.js`: Single actor for prompt area. States: ready/loading/streaming/queued/disabled. Replaces dead `_promptState` string and `_promptStateTransitions` object in `client.js`. Driven by `enableControls()`, `disableControls()`, `handleStreamingStart()`, `handleStreamingComplete()`, `handleStreamingError()`. API: `window.promptMachineAPI`. Actor at `window.__promptMachine`.
 
-**XState browser loading**: UMD bundle at `static/lib/xstate.umd.min.js` (copied from `node_modules/xstate/dist/xstate.umd.min.js` during npm install). Loaded as `defer` script before ws-machine.js and conv-machine.js. Exposes `window.XState` global.
+**XState browser loading**: UMD bundle at `static/lib/xstate.umd.min.js` (copied from `node_modules/xstate/dist/xstate.umd.min.js` during npm install). Loaded as `defer` script. Load order: xstate.umd.min.js → ws-machine.js → conv-machine.js → tool-install-machine.js → voice-machine.js → conv-list-machine.js → prompt-machine.js → all other app scripts. Exposes `window.XState` global.
 
-**Integration pattern**: Machines augment existing state (Maps, Set, booleans). They receive events at the same points the Maps are mutated. Machine state does NOT replace Map checks in server logic — both run in parallel, machine is the formal model.
+**Authoritative pattern**: Each machine owns its domain exclusively. No parallel ad-hoc state alongside machines. `window.__*` globals expose all client actors for debug inspection.
 
 ## Key Details
 
@@ -151,7 +162,7 @@ Tool updates are managed through a complete pipeline:
 3. Tool manager (`lib/tool-manager.js` lines 400-432) executes `bun x <package>` and detects new version
 4. Version is saved to database: `queries.updateToolStatus(toolId, { version, status: 'installed' })`
 5. WebSocket broadcasts `tool_update_complete` with version and status data
-6. Frontend updates UI and removes tool from `operationInProgress` set
+6. Frontend machine transitions to installed/failed via WS event, UI re-renders from machine state
 
 **Critical Detail:** When updating tools in batch (`/api/tools/update`), the version parameter MUST be included in the database update call. This ensures database persistence across page reloads.
 
@@ -190,9 +201,9 @@ Current tools:
 
 When user clicks Install/Update button on a tool:
 
-1. **Frontend** (`static/js/tools-manager.js`): Immediately updates status to 'installing'/'updating', sends POST, adds toolId to `operationInProgress` to prevent duplicates
-2. **Backend** (`server.js`): Updates DB status, sends immediate `{ success: true }`, runs install/update async in background, broadcasts `tool_install_complete` or `tool_install_failed` on completion
-3. **Frontend WebSocket Handler**: Listens for completion events, updates UI, removes from `operationInProgress`
+1. **Frontend** (`static/js/tools-manager.js`): Sends INSTALL/UPDATE event to `toolInstallMachineAPI`, sends POST. Machine guards duplicate requests via `isLocked()`.
+2. **Backend** (`server.js`): `tool-install-machine.js` sends INSTALL_START/UPDATE_START, runs async, sends INSTALL_COMPLETE/UPDATE_COMPLETE/FAILED. Broadcasts WS events.
+3. **Frontend WebSocket Handler**: Sends COMPLETE/FAILED/PROGRESS to machine. UI renders from machine state only.
 
 ## WebSocket Protocol
 

package/lib/tool-install-machine.js

@@ -0,0 +1,157 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'tool-install',
+  initial: 'unchecked',
+  context: {
+    version: null,
+    error: null,
+    installedAt: null,
+    lastCheckedAt: null,
+  },
+  states: {
+    unchecked: {
+      on: {
+        CHECK_START: 'checking',
+        INSTALL_START: 'installing',
+      },
+    },
+    checking: {
+      entry: assign({ lastCheckedAt: () => Date.now() }),
+      on: {
+        IDLE: {
+          target: 'idle',
+          actions: assign(({ event }) => ({
+            version: event.version || null,
+            lastCheckedAt: Date.now(),
+          })),
+        },
+        INSTALLED: {
+          target: 'installed',
+          actions: assign(({ event }) => ({
+            version: event.version || null,
+            installedAt: event.installedAt || Date.now(),
+            lastCheckedAt: Date.now(),
+          })),
+        },
+        NEEDS_UPDATE: {
+          target: 'needs_update',
+          actions: assign(({ event }) => ({
+            version: event.version || null,
+            lastCheckedAt: Date.now(),
+          })),
+        },
+        FAILED: {
+          target: 'failed',
+          actions: assign(({ event }) => ({ error: event.error || 'check failed' })),
+        },
+      },
+    },
+    idle: {
+      on: {
+        CHECK_START: 'checking',
+        INSTALL_START: 'installing',
+      },
+    },
+    installing: {
+      entry: assign({ error: null }),
+      on: {
+        INSTALL_COMPLETE: {
+          target: 'installed',
+          actions: assign(({ event }) => ({
+            version: event.version || null,
+            installedAt: Date.now(),
+            error: null,
+          })),
+        },
+        FAILED: {
+          target: 'failed',
+          actions: assign(({ event }) => ({ error: event.error || 'install failed' })),
+        },
+      },
+    },
+    installed: {
+      on: {
+        CHECK_START: 'checking',
+        UPDATE_START: 'updating',
+      },
+    },
+    updating: {
+      entry: assign({ error: null }),
+      on: {
+        UPDATE_COMPLETE: {
+          target: 'installed',
+          actions: assign(({ event }) => ({
+            version: event.version || null,
+            error: null,
+          })),
+        },
+        FAILED: {
+          target: 'failed',
+          actions: assign(({ event }) => ({ error: event.error || 'update failed' })),
+        },
+      },
+    },
+    needs_update: {
+      on: {
+        UPDATE_START: 'updating',
+        CHECK_START: 'checking',
+      },
+    },
+    failed: {
+      on: {
+        CHECK_START: 'checking',
+        INSTALL_START: 'installing',
+      },
+    },
+  },
+});
+
+const actors = new Map();
+
+export function getOrCreate(toolId) {
+  if (actors.has(toolId)) return actors.get(toolId);
+  const actor = createActor(machine);
+  actor.start();
+  actors.set(toolId, actor);
+  return actor;
+}
+
+export function get(toolId) {
+  return actors.get(toolId) || null;
+}
+
+export function send(toolId, event) {
+  const actor = getOrCreate(toolId);
+  actor.send(event);
+  return actor.getSnapshot();
+}
+
+export function snapshot(toolId) {
+  const actor = actors.get(toolId);
+  return actor ? actor.getSnapshot() : null;
+}
+
+export function isLocked(toolId) {
+  const s = snapshot(toolId);
+  return s ? (s.value === 'installing' || s.value === 'updating') : false;
+}
+
+export function getState(toolId) {
+  const s = snapshot(toolId);
+  return s ? s.value : 'unchecked';
+}
+
+export function remove(toolId) {
+  const actor = actors.get(toolId);
+  if (actor) { actor.stop(); actors.delete(toolId); }
+}
+
+export function stopAll() {
+  for (const [, actor] of actors) actor.stop();
+  actors.clear();
+}
+
+export function getMachineActors() {
+  return actors;
+}

package/lib/tool-manager.js

@@ -17,7 +17,6 @@ const TOOLS = [
 ];
 
 const statusCache = new Map();
-const installLocks = new Map();
 
 const getTool = (id) => TOOLS.find(t => t.id === id);
 
@@ -51,7 +50,7 @@ export async function checkForUpdates(toolId) {
   return { needsUpdate: status.upgradeNeeded && status.installed };
 }
 
-const { install, update } = createInstaller(getTool, installLocks, statusCache, checkToolStatusAsync);
+const { install, update } = createInstaller(getTool, statusCache, checkToolStatusAsync);
 export { install, update };
 
 export function getAllTools() {

package/lib/tool-provisioner.js

@@ -1,4 +1,5 @@
 import { checkToolViaBunx } from './tool-version.js';
+import * as toolInstallMachine from './tool-install-machine.js';
 
 let updateCheckInterval = null;
 const UPDATE_CHECK_INTERVAL = 6 * 60 * 60 * 1000;
@@ -8,9 +9,11 @@ export async function autoProvision(TOOLS, statusCache, install, broadcast) {
   log('Starting background tool provisioning...');
   for (const tool of TOOLS) {
     try {
+      toolInstallMachine.send(tool.id, { type: 'CHECK_START' });
       const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, true, TOOLS);
       statusCache.set(tool.id, { ...status, toolId: tool.id, timestamp: Date.now() });
       if (!status.installed) {
+        toolInstallMachine.send(tool.id, { type: 'IDLE' });
         log(`${tool.id} not installed, installing...`);
         broadcast({ type: 'tool_install_started', toolId: tool.id });
         const result = await install(tool.id, (msg) => {
@@ -24,9 +27,9 @@ export async function autoProvision(TOOLS, statusCache, install, broadcast) {
           broadcast({ type: 'tool_install_failed', toolId: tool.id, data: result });
         }
       } else if (status.upgradeNeeded) {
+        toolInstallMachine.send(tool.id, { type: 'NEEDS_UPDATE', version: status.installedVersion });
         log(`${tool.id} needs update (${status.installedVersion} -> ${status.publishedVersion})`);
         broadcast({ type: 'tool_install_started', toolId: tool.id });
-        const { update } = await import('./tool-spawner.js').then(m => m);
         const result = await install(tool.id, (msg) => {
           broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
         });
@@ -38,10 +41,12 @@ export async function autoProvision(TOOLS, statusCache, install, broadcast) {
           broadcast({ type: 'tool_update_failed', toolId: tool.id, data: result });
         }
       } else {
+        toolInstallMachine.send(tool.id, { type: 'INSTALLED', version: status.installedVersion });
         log(`${tool.id} v${status.installedVersion || 'unknown'} up-to-date`);
         broadcast({ type: 'tool_status_update', toolId: tool.id, data: { installed: true, isUpToDate: true, installedVersion: status.installedVersion, status: 'installed' } });
       }
     } catch (err) {
+      toolInstallMachine.send(tool.id, { type: 'FAILED', error: err.message });
       log(`${tool.id} error: ${err.message}`);
     }
   }

package/lib/tool-spawner.js

@@ -1,6 +1,7 @@
 import { spawn } from 'child_process';
 import os from 'os';
 import { getCliVersion, getInstalledVersion, clearVersionCache, checkToolViaBunx } from './tool-version.js';
+import * as toolInstallMachine from './tool-install-machine.js';
 
 const isWindows = os.platform() === 'win32';
 
@@ -86,18 +87,24 @@ async function postInstallRefresh(tool, statusCache, checkToolStatusAsync) {
   return { success: true, error: null, version: version || freshStatus.publishedVersion || 'unknown', ...freshStatus };
 }
 
-export function createInstaller(getTool, installLocks, statusCache, checkToolStatusAsync) {
+export function createInstaller(getTool, statusCache, checkToolStatusAsync) {
   async function install(toolId, onProgress) {
     const tool = getTool(toolId);
     if (!tool) return { success: false, error: 'Tool not found' };
-    if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
-    installLocks.set(toolId, true);
+    if (toolInstallMachine.isLocked(toolId)) return { success: false, error: 'Install in progress' };
+    toolInstallMachine.send(toolId, { type: 'INSTALL_START' });
     try {
       const result = await spawnForTool(tool, onProgress);
-      if (result.success) return await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+      if (result.success) {
+        const fresh = await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+        toolInstallMachine.send(toolId, { type: 'INSTALL_COMPLETE', version: fresh.version });
+        return fresh;
+      }
+      toolInstallMachine.send(toolId, { type: 'FAILED', error: result.error });
       return result;
-    } finally {
-      installLocks.delete(toolId);
+    } catch (err) {
+      toolInstallMachine.send(toolId, { type: 'FAILED', error: err.message });
+      return { success: false, error: err.message };
     }
   }
 
@@ -106,14 +113,20 @@ export function createInstaller(getTool, installLocks, statusCache, checkToolSta
     if (!tool) return { success: false, error: 'Tool not found' };
     const current = await checkToolStatusAsync(toolId);
     if (!current?.installed) return { success: false, error: 'Tool not installed' };
-    if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
-    installLocks.set(toolId, true);
+    if (toolInstallMachine.isLocked(toolId)) return { success: false, error: 'Install in progress' };
+    toolInstallMachine.send(toolId, { type: 'UPDATE_START' });
     try {
       const result = await spawnForTool(tool, onProgress);
-      if (result.success) return await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+      if (result.success) {
+        const fresh = await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+        toolInstallMachine.send(toolId, { type: 'UPDATE_COMPLETE', version: fresh.version });
+        return fresh;
+      }
+      toolInstallMachine.send(toolId, { type: 'FAILED', error: result.error });
       return result;
-    } finally {
-      installLocks.delete(toolId);
+    } catch (err) {
+      toolInstallMachine.send(toolId, { type: 'FAILED', error: err.message });
+      return { success: false, error: err.message };
     }
   }
 

package/lib/ws-handlers-util.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { execSync, spawnSync } from 'child_process';
+import * as toolInstallMachine from './tool-install-machine.js';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
@@ -141,7 +142,10 @@ export function register(router, deps) {
   router.handle('tools.list', async () => {
     try {
       const tools = await toolManager.getAllToolsAsync();
-      return { tools: tools.map((t) => ({ id: t.id, name: t.name, pkg: t.pkg, category: t.category || 'plugin', installed: t.installed, status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed', isUpToDate: t.isUpToDate, upgradeNeeded: t.upgradeNeeded, hasUpdate: t.upgradeNeeded && t.installed, installedVersion: t.installedVersion, publishedVersion: t.publishedVersion })) };
+      return { tools: tools.map((t) => {
+        const machineState = toolInstallMachine.getState(t.id);
+        return { id: t.id, name: t.name, pkg: t.pkg, category: t.category || 'plugin', installed: t.installed, status: t.installed ? (t.isUpToDate ? 'installed' : 'needs_update') : 'not_installed', isUpToDate: t.isUpToDate, upgradeNeeded: t.upgradeNeeded, hasUpdate: t.upgradeNeeded && t.installed, installedVersion: t.installedVersion, publishedVersion: t.publishedVersion, machineState };
+      }) };
     } catch (e) { err(500, e.message); }
   });
 

package/package.json

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

package/server.js

@@ -31,6 +31,7 @@ import { register as registerQueueHandlers } from './lib/ws-handlers-queue.js';
 import { register as registerMsgHandlers } from './lib/ws-handlers-msg.js';
 import { startAll as startACPTools, stopAll as stopACPTools, getStatus as getACPStatus, getPort as getACPPort, ensureRunning, queryModels as queryACPModels, touch as touchACP } from './lib/acp-sdk-manager.js';
 import * as execMachine from './lib/execution-machine.js';
+import * as toolInstallMachine from './lib/tool-install-machine.js';
 import { installGMAgentConfigs } from './lib/gm-agent-configs.js';
 import * as toolManager from './lib/tool-manager.js';
 import { pm2Manager } from './lib/pm2-manager.js';
@@ -2099,6 +2100,22 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/debug/machines' && req.method === 'GET' && process.env.DEBUG) {
+      const toolSnap = {};
+      for (const [id, actor] of toolInstallMachine.getMachineActors()) {
+        const s = actor.getSnapshot();
+        toolSnap[id] = { state: s.value, context: s.context };
+      }
+      const execSnap = {};
+      const allExecConvIds = [...activeExecutions.keys()];
+      for (const id of allExecConvIds) {
+        const s = execMachine.snapshot(id);
+        if (s) execSnap[id] = { state: s.value, context: { pid: s.context.pid, sessionId: s.context.sessionId, queueLen: s.context.queue?.length } };
+      }
+      sendJSON(req, res, 200, { toolInstall: toolSnap, execution: execSnap });
+      return;
+    }
+
     if (pathOnly === '/api/tools' && req.method === 'GET') {
       console.log('[TOOLS-API] Handling GET /api/tools');
       try {
@@ -2118,12 +2135,12 @@ const server = http.createServer(async (req, res) => {
           upgradeNeeded: t.upgradeNeeded,
           hasUpdate: t.upgradeNeeded && t.installed,
           installedVersion: t.installedVersion,
-          publishedVersion: t.publishedVersion
+          publishedVersion: t.publishedVersion,
+          machineState: toolInstallMachine.getState(t.id),
         }));
         sendJSON(req, res, 200, { tools: result });
       } catch (err) {
         console.log('[TOOLS-API] Error getting tools, returning cached status:', err.message);
-        // Return synchronously cached tool status - this provides immediate response with last-known status
         const tools = toolManager.getAllToolsSync().map((t) => ({
           id: t.id,
           name: t.name,
@@ -2135,7 +2152,8 @@ const server = http.createServer(async (req, res) => {
           upgradeNeeded: t.upgradeNeeded || false,
           hasUpdate: (t.upgradeNeeded && t.installed) || false,
           installedVersion: t.installedVersion || null,
-          publishedVersion: t.publishedVersion || null
+          publishedVersion: t.publishedVersion || null,
+          machineState: toolInstallMachine.getState(t.id),
         }));
         sendJSON(req, res, 200, { tools });
       }
@@ -5139,8 +5157,9 @@ function onServerReady() {
   toolManager.autoProvision(toolBroadcaster)
     .catch(err => console.error('[TOOLS] Auto-provision error:', err.message))
     .then(() => {
-      // Start periodic update checker AFTER initial provisioning completes
-      // This runs in background and doesn't block GUI
+      const acpActors = ['opencode', 'kilo', 'codex'];
+      const execActorCount = execMachine.stopAll ? 0 : 0;
+      console.log(`[MACHINES] tool-install: ${toolInstallMachine.getMachineActors().size} actors, acp-server: ${acpActors.length} configured`);
       console.log('[TOOLS] Starting periodic update checker...');
       toolManager.startPeriodicUpdateCheck(toolBroadcaster);
     });

package/static/index.html

@@ -3314,6 +3314,10 @@
   <script defer src="/gm/lib/xstate.umd.min.js"></script>
   <script defer src="/gm/js/ws-machine.js"></script>
   <script defer src="/gm/js/conv-machine.js"></script>
+  <script defer src="/gm/js/tool-install-machine.js"></script>
+  <script defer src="/gm/js/voice-machine.js"></script>
+  <script defer src="/gm/js/conv-list-machine.js"></script>
+  <script defer src="/gm/js/prompt-machine.js"></script>
   <script defer src="/gm/lib/msgpackr.min.js"></script>
   <script defer src="/gm/js/websocket-manager.js"></script>
   <script defer src="/gm/js/ws-client.js"></script>
@@ -3323,6 +3327,7 @@
   <script defer src="/gm/js/state-barrier.js"></script>
    <script defer src="/gm/js/terminal.js"></script>
    <script defer src="/gm/js/script-runner.js"></script>
+   <script defer src="/gm/js/tools-manager-ui.js"></script>
    <script defer src="/gm/js/tools-manager.js"></script>
    <script defer src="/gm/js/stt-handler.js"></script>
    <script defer src="/gm/js/voice.js"></script>