agentgui 1.0.867 → 1.0.869

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [Unreleased] - observability + dead-code sweep + root test suite
+
+- Expose acp-server-machine snapshots in /api/debug/machines (previously only tool-install + execution machines)
+- Add /api/debug/state endpoint consolidating active executions, queues, wsClients, machine snapshots, ws-stats, recentErrors, uptime, memory (DEBUG=1 gated)
+- Alias /api/debug/ws-stats to /api/ws-stats so docs match runtime
+- Add getMachineActors() export to lib/acp-server-machine.js
+- Delete verified-orphan files: lib/rate-limit-machine.js, lib/model-download-machine.js, lib/agent-registry-configs.js, lib/plugin-interface.js, lib/plugins/git-plugin.js
+- Add root test.js (16 cases): codec roundtrip, DB init+queries, acp-queries helpers, WsRouter dispatch/errors/legacy, XState machine actor getters + lifecycle. Uses better-sqlite3 in-memory — no mocks.
+- CLAUDE.md: remove stale entries for deleted files
+
 ## [Unreleased] - merge: integrate remote UI redesign + cleanup CLAUDE.md
 
 - Merge origin/main: resolve UU conflicts in server.js (take remote _jsonlWatcher setter) and static/index.html (take remote UI redesign with overflow menu + SVG icons)

package/CLAUDE.md

@@ -25,7 +25,6 @@ lib/acp-protocol.js    ACP session/update message normalization (shared by all A
 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/agent-discovery.js Agent binary detection (findCommand), ACP server query, discoverAgents, CLI wrapper logic
-lib/agent-registry-configs.js  Agent registration configs (Claude Code, OpenCode, Gemini, 10+ ACP agents)
 lib/agent-descriptors.js  Data-driven ACP agent descriptor builder
 lib/checkpoint-manager.js  Session recovery - load checkpoints, inject into resume flow, idempotency
 lib/codec.js           msgpack encode/decode (pack/unpack wrappers)
@@ -37,7 +36,6 @@ lib/jsonl-watcher.js   Watches ~/.claude/projects for JSONL file changes, delega
 lib/oauth-common.js    Shared OAuth helpers (buildBaseUrl, isRemoteRequest, encodeOAuthState, result/relay pages)
 lib/oauth-gemini.js    Gemini OAuth flow (credential discovery, token exchange, callback handling)
 lib/oauth-codex.js     Codex CLI OAuth flow (PKCE S256, token exchange, callback handling)
-lib/plugin-interface.js  Plugin interface contract definition
 lib/plugin-loader.js   Plugin discovery and loading (EventEmitter-based)
 lib/pm2-manager.js     PM2 process management wrapper
 lib/speech.js          Speech-to-text and text-to-speech via @huggingface/transformers
@@ -370,3 +368,15 @@ The README.md uses shields.io badges with a consistent pattern:
 - **`JsonlWatcher._read(fp)` override:** Captures `this._currentFp` before calling `super._read(fp)`, making the file path available to `_line()` callbacks for project-directory decoding in `_conv()`. JSONL project dirs are encoded (e.g., `-config-workspace-agentgui`) — decoded via `'/' + dirName.slice(1).replace(/-/g, '/')`.
 - **`createHttpHandler` uses `getWss: () => wss` (lazy getter):** Passing `wss` directly would crash with TDZ since `wss` is declared after `createHttpHandler` is called. The function form defers access until request time when `wss` is initialized.
 - **`_promptPushIfWeOwnRemote` fires after every `streaming_complete`:** `client-streaming4.js` calls `git.check` on the server after each agent turn. If `ownsRemote && (hasChanges || hasUnpushed)`, it auto-sends "Push the changes to the remote repository." to the current conversation. `ownsRemote` is true for non-github remotes, and for github.com remotes only when `GITHUB_USER` env var is set and appears in the URL. Without `GITHUB_USER`, github.com remotes return `ownsRemote=false` (safe default).
+
+## Critical Knowledge for Future Sessions
+
+**Codebase Insight Stale:** `.codeinsight` snapshot is outdated (v1.0.811 claimed server.js=3407L, db-queries.js=1412L, but actual as of 2026-04-17: server.js=201L, db-queries.js=94L). Heavy refactoring already done. Before acting on insight "issues" (SQL injection claims, hardcoded secrets, large files), always verify with grep/read against current state. Most reported issues are false positives or stale.
+
+**Test Harness Pattern:** Use better-sqlite3 in-memory Database, call `initSchema()` → `migrateConversationColumns()` → `migrateACPSchema()` in order (conversations table needs agentType column from second migration). `createQueries` signature: `(db, prep, generateId)` where `prep=(sql)=>db.prepare(sql)`. Silence console during schema init to keep test output clean. Node ships with better-sqlite3 available (optional dep resolved).
+
+**CI Auto-Rewrites History:** Every push to main triggers Auto-Declaudeify workflow that filters Claude coauthor commits and force-pushes filtered history. After a push, `git fetch origin` is needed — local SHA drifts from origin SHA.
+
+**Debug Endpoints Scattered:** Routes at `/api/debug`, `/api/debug/machines`, `/api/debug/state`, `/api/ws-stats`, `/api/debug/ws-stats` (alias). `routes-debug.js` wires all five + backup/restore. DEBUG API in browser: `window.__debug.getSyncState()`.
+
+**Plugin Files NOT Orphans:** lib/plugins/* are dynamically loaded via `lib/plugin-loader.js` (import with file:// URL + cache-busting `?v=` timestamp). Only truly dead plugin was `lib/plugins/git-plugin.js`. Static scan showing orphans is misleading.

package/lib/acp-server-machine.js

@@ -160,6 +160,10 @@ export function getBackoffDelay(toolId) {
   return calcBackoff(purgeOldRestarts(s.context.restarts));
 }
 
+export function getMachineActors() {
+  return actors;
+}
+
 export function stopAll() {
   for (const [, actor] of actors) actor.stop();
   actors.clear();

package/lib/routes-debug.js

@@ -3,28 +3,94 @@ import path from 'path';
 import os from 'os';
 import * as toolInstallMachine from './tool-install-machine.js';
 import * as execMachine from './execution-machine.js';
+import * as acpServerMachine from './acp-server-machine.js';
+
+function collectMachineSnapshots(activeExecutions) {
+  const toolInstall = {};
+  for (const [id, actor] of toolInstallMachine.getMachineActors()) {
+    const s = actor.getSnapshot();
+    toolInstall[id] = { state: s.value, context: s.context };
+  }
+  const execution = {};
+  for (const id of activeExecutions.keys()) {
+    const s = execMachine.snapshot(id);
+    if (s) execution[id] = { state: s.value, context: { pid: s.context.pid, sessionId: s.context.sessionId, queueLen: s.context.queue?.length } };
+  }
+  const acpServer = {};
+  for (const [id, actor] of acpServerMachine.getMachineActors()) {
+    const s = actor.getSnapshot();
+    acpServer[id] = { state: s.value, context: { pid: s.context.pid, healthy: s.context.healthy, startedAt: s.context.startedAt, lastUsed: s.context.lastUsed, restarts: s.context.restarts?.length || 0, providerInfo: s.context.providerInfo } };
+  }
+  return { toolInstall, execution, acpServer };
+}
+
+function readRecentErrors(errLogPath, limit = 50) {
+  try {
+    const raw = fs.readFileSync(errLogPath, 'utf8');
+    return raw.trim().split('\n').slice(-limit).map(l => { try { return JSON.parse(l); } catch { return l; } });
+  } catch { return []; }
+}
 
 export function register(deps) {
   const { sendJSON, queries, activeExecutions, messageQueues, syncClients, wsOptimizer, _errLogPath } = deps;
   const routes = {};
 
+  function snapshotExecutions() {
+    const o = {};
+    for (const [k, v] of activeExecutions) o[k] = { pid: v.pid, startTime: v.startTime, sessionId: v.sessionId, lastActivity: v.lastActivity };
+    return o;
+  }
+  function snapshotQueues() {
+    const o = {};
+    for (const [k, v] of messageQueues) o[k] = { length: v.length, messageIds: v.map(m => m.messageId) };
+    return o;
+  }
+  function snapshotWsClients() {
+    const out = [];
+    for (const ws of syncClients) out.push({ clientId: ws.clientId, subs: ws.subscriptions ? [...ws.subscriptions] : [] });
+    return out;
+  }
+  function streamingConvs() {
+    try { return queries.getConversationsList().filter(c => c.isStreaming).map(c => ({ id: c.id, isStreaming: c.isStreaming })); }
+    catch { return []; }
+  }
+
   routes['GET /api/debug'] = async (req, res) => {
-    const execSnap = {};
-    for (const [k, v] of activeExecutions) execSnap[k] = { pid: v.pid, startTime: v.startTime, sessionId: v.sessionId, lastActivity: v.lastActivity };
-    const queueSnap = {};
-    for (const [k, v] of messageQueues) queueSnap[k] = { length: v.length, messageIds: v.map(m => m.messageId) };
-    let streamingConvs = [];
-    try { streamingConvs = queries.getConversationsList().filter(c => c.isStreaming).map(c => ({ id: c.id, isStreaming: c.isStreaming })); } catch (_) {}
-    const clientSubs = [];
-    for (const ws of syncClients) clientSubs.push({ clientId: ws.clientId, subs: ws.subscriptions ? [...ws.subscriptions] : [] });
-    let recentErrors = [];
-    try {
-      const raw = fs.readFileSync(_errLogPath, 'utf8');
-      recentErrors = raw.trim().split('\n').slice(-20).map(l => { try { return JSON.parse(l); } catch { return l; } });
-    } catch (_) {}
-    sendJSON(req, res, 200, { activeExecutions: execSnap, messageQueues: queueSnap, streamingConversations: streamingConvs, wsClients: clientSubs, recentErrors });
+    sendJSON(req, res, 200, {
+      activeExecutions: snapshotExecutions(),
+      messageQueues: snapshotQueues(),
+      streamingConversations: streamingConvs(),
+      wsClients: snapshotWsClients(),
+      recentErrors: readRecentErrors(_errLogPath, 20),
+    });
+  };
+
+  routes['GET /api/debug/state'] = async (req, res) => {
+    if (!process.env.DEBUG) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    sendJSON(req, res, 200, {
+      activeExecutions: snapshotExecutions(),
+      messageQueues: snapshotQueues(),
+      streamingConversations: streamingConvs(),
+      wsClients: snapshotWsClients(),
+      machines: collectMachineSnapshots(activeExecutions),
+      wsStats: wsOptimizer.getStats(),
+      recentErrors: readRecentErrors(_errLogPath, 50),
+      uptime: process.uptime(),
+      memory: process.memoryUsage(),
+    });
+  };
+
+  routes['GET /api/debug/machines'] = async (req, res) => {
+    if (!process.env.DEBUG) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
+    sendJSON(req, res, 200, collectMachineSnapshots(activeExecutions));
   };
 
+  routes['GET /api/ws-stats'] = async (req, res) => {
+    sendJSON(req, res, 200, wsOptimizer.getStats());
+  };
+
+  routes['GET /api/debug/ws-stats'] = routes['GET /api/ws-stats'];
+
   routes['GET /api/backup'] = async (req, res) => {
     const dbPath = path.join(os.homedir(), '.gmgui', 'data.db');
     if (!fs.existsSync(dbPath)) { sendJSON(req, res, 404, { error: 'Database not found' }); return; }
@@ -53,28 +119,7 @@ export function register(deps) {
     });
   };
 
-  routes['GET /api/debug/machines'] = async (req, res) => {
-    if (!process.env.DEBUG) { sendJSON(req, res, 404, { error: 'Not found' }); return; }
-    const toolSnap = {};
-    for (const [id, actor] of toolInstallMachine.getMachineActors()) {
-      const s = actor.getSnapshot();
-      toolSnap[id] = { state: s.value, context: s.context };
-    }
-    const execSnap = {};
-    for (const id of activeExecutions.keys()) {
-      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 });
-  };
-
-  routes['GET /api/ws-stats'] = async (req, res) => {
-    sendJSON(req, res, 200, wsOptimizer.getStats());
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    return routes[`${method} ${pathOnly}`] || null;
-  };
+  routes['_match'] = (method, pathOnly) => routes[`${method} ${pathOnly}`] || null;
 
   return routes;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.867",
+  "version": "1.0.869",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/test.js

@@ -0,0 +1,165 @@
+import assert from 'assert';
+import Database from 'better-sqlite3';
+import { initSchema } from './database-schema.js';
+import { migrateConversationColumns } from './database-migrations.js';
+import { migrateACPSchema } from './database-migrations-acp.js';
+import { createQueries } from './lib/db-queries.js';
+import { encode, decode } from './lib/codec.js';
+import { WsRouter } from './lib/ws-protocol.js';
+import * as toolInstallMachine from './lib/tool-install-machine.js';
+import * as execMachine from './lib/execution-machine.js';
+import * as acpServerMachine from './lib/acp-server-machine.js';
+
+let passed = 0, failed = 0;
+const section = (name, fn) => {
+  try { fn(); console.log(`ok — ${name}`); passed++; }
+  catch (err) { console.error(`FAIL — ${name}: ${err.message}`); failed++; }
+};
+
+function inMemDb() {
+  const db = new Database(':memory:');
+  db.pragma('foreign_keys = ON');
+  const origLog = console.log, origWarn = console.warn;
+  console.log = () => {}; console.warn = () => {};
+  try {
+    initSchema(db);
+    migrateConversationColumns(db);
+    migrateACPSchema(db);
+  } finally { console.log = origLog; console.warn = origWarn; }
+  const prep = (sql) => db.prepare(sql);
+  const gid = (p) => `${p}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  return { db, prep, gid };
+}
+
+section('codec: roundtrip primitives', () => {
+  const obj = { a: 1, b: 'str', c: [1, 2, 3], d: { nested: true } };
+  assert.deepEqual(decode(encode(obj)), obj);
+});
+
+section('codec: binary payload', () => {
+  const buf = Buffer.from([1, 2, 3, 4]);
+  const round = decode(encode({ bin: buf }));
+  assert.deepEqual(Array.from(round.bin), [1, 2, 3, 4]);
+});
+
+section('db: init schema creates conversations table', () => {
+  const { db } = inMemDb();
+  const t = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='conversations'").get();
+  assert.ok(t, 'conversations table exists');
+});
+
+section('db-queries: createConversation round-trip', () => {
+  const { db, prep, gid } = inMemDb();
+  const q = createQueries(db, prep, gid);
+  const c = q.createConversation('claude-code', 'Test', '/tmp', 'sonnet', null);
+  assert.equal(c.title, 'Test');
+  const fetched = q.getConversation(c.id);
+  assert.equal(fetched.title, 'Test');
+  assert.equal(fetched.status, 'active');
+});
+
+section('db-queries: archive + restore', () => {
+  const { db, prep, gid } = inMemDb();
+  const q = createQueries(db, prep, gid);
+  const c = q.createConversation('claude-code', 'A');
+  q.archiveConversation(c.id);
+  assert.equal(q.getConversation(c.id).status, 'archived');
+  q.restoreConversation(c.id);
+  assert.equal(q.getConversation(c.id).status, 'active');
+});
+
+section('db-queries: streaming flag', () => {
+  const { db, prep, gid } = inMemDb();
+  const q = createQueries(db, prep, gid);
+  const c = q.createConversation('claude-code', 'S');
+  q.setIsStreaming(c.id, true);
+  assert.equal(q.getIsStreaming(c.id), true);
+  q.setIsStreaming(c.id, false);
+  assert.equal(q.getIsStreaming(c.id), false);
+});
+
+section('acp-queries: createThread + getThread + patchThread', () => {
+  const { db, prep, gid } = inMemDb();
+  const q = createQueries(db, prep, gid);
+  const t = q.createThread({ foo: 'bar' });
+  assert.ok(t.thread_id);
+  const got = q.getThread(t.thread_id);
+  assert.deepEqual(got.metadata, { foo: 'bar' });
+  const patched = q.patchThread(t.thread_id, { metadata: { foo: 'baz' }, status: 'active' });
+  assert.equal(patched.status, 'active');
+  assert.deepEqual(q.getThread(t.thread_id).metadata, { foo: 'baz' });
+});
+
+section('acp-queries: searchThreads parameterized', () => {
+  const { db, prep, gid } = inMemDb();
+  const q = createQueries(db, prep, gid);
+  q.createThread({ kind: 'a' });
+  q.createThread({ kind: 'b' });
+  const r = q.searchThreads({});
+  assert.equal(r.total, 2);
+  assert.equal(r.threads.length, 2);
+});
+
+section('WsRouter: dispatch registered method', async () => {
+  const router = new WsRouter();
+  router.handle('ping', async (p) => ({ pong: p.n }));
+  const replies = [];
+  const ws = { readyState: 1, send: (buf) => replies.push(decode(buf)), clientId: 'c1' };
+  await router.onMessage(ws, encode({ r: 1, m: 'ping', p: { n: 7 } }));
+  assert.deepEqual(replies[0], { r: 1, d: { pong: 7 } });
+});
+
+section('WsRouter: unknown method replies 404', async () => {
+  const router = new WsRouter();
+  const replies = [];
+  const ws = { readyState: 1, send: (buf) => replies.push(decode(buf)), clientId: 'c' };
+  await router.onMessage(ws, encode({ r: 2, m: 'nope', p: {} }));
+  assert.equal(replies[0].r, 2);
+  assert.equal(replies[0].e.c, 404);
+});
+
+section('WsRouter: handler exception becomes error reply', async () => {
+  const router = new WsRouter();
+  router.handle('boom', async () => { throw Object.assign(new Error('kaboom'), { code: 422 }); });
+  const replies = [];
+  const ws = { readyState: 1, send: (buf) => replies.push(decode(buf)), clientId: 'c' };
+  await router.onMessage(ws, encode({ r: 3, m: 'boom', p: {} }));
+  assert.equal(replies[0].e.c, 422);
+  assert.equal(replies[0].e.m, 'kaboom');
+});
+
+section('WsRouter: legacy handler called for non-RPC messages', async () => {
+  const router = new WsRouter();
+  let seen = null;
+  router.onLegacy((msg) => { seen = msg; });
+  const ws = { readyState: 1, send: () => {}, clientId: 'c' };
+  await router.onMessage(ws, encode({ type: 'subscribe', id: 'x' }));
+  assert.equal(seen.type, 'subscribe');
+});
+
+section('tool-install-machine: actors map exposed', () => {
+  const actors = toolInstallMachine.getMachineActors();
+  assert.ok(actors instanceof Map);
+});
+
+section('execution-machine: snapshot returns null for unknown id', () => {
+  assert.equal(execMachine.snapshot('nonexistent-conv-id'), null);
+});
+
+section('acp-server-machine: lifecycle transitions', () => {
+  const actor = acpServerMachine.getOrCreate('test-tool');
+  assert.equal(actor.getSnapshot().value, 'stopped');
+  acpServerMachine.send('test-tool', { type: 'START', pid: 123 });
+  assert.equal(acpServerMachine.get('test-tool').getSnapshot().value, 'starting');
+  acpServerMachine.send('test-tool', { type: 'HEALTHY', providerInfo: { ok: true } });
+  assert.equal(acpServerMachine.isHealthy('test-tool'), true);
+  acpServerMachine.stopAll();
+});
+
+section('acp-server-machine: getMachineActors returns Map', () => {
+  const actors = acpServerMachine.getMachineActors();
+  assert.ok(actors instanceof Map);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/lib/agent-registry-configs.js

@@ -1,125 +0,0 @@
-import { acpProtocolHandler } from './acp-protocol.js';
-
-const SIMPLE_ACP_AGENTS = [
-  { id: 'goose', name: 'Goose', command: 'goose' },
-  { id: 'openhands', name: 'OpenHands', command: 'openhands' },
-  { id: 'augment', name: 'Augment Code', command: 'augment' },
-  { id: 'cline', name: 'Cline', command: 'cline' },
-  { id: 'kimi', name: 'Kimi CLI', command: 'kimi' },
-  { id: 'qwen', name: 'Qwen Code', command: 'qwen-code' },
-  { id: 'codex', name: 'Codex CLI', command: 'codex' },
-  { id: 'mistral', name: 'Mistral Vibe', command: 'mistral-vibe' },
-  { id: 'kiro', name: 'Kiro CLI', command: 'kiro' },
-  { id: 'fast-agent', name: 'fast-agent', command: 'fast-agent' },
-];
-
-function parseClaudeOutput(line) {
-  try {
-    const entry = JSON.parse(line);
-    if (!entry || typeof entry !== 'object') return null;
-    if (entry.type === 'user' && entry.isMeta === true) return null;
-    if (entry.isApiErrorMessage === true && entry.error === 'rate_limit') {
-      entry._rateLimitDetected = true;
-    }
-    if (entry.type === 'assistant' && entry.message) {
-      entry._isFragment = entry.message.stop_reason === null || entry.message.stop_reason === undefined;
-    }
-    if (entry.type === 'system' && entry.subtype === 'turn_duration' && entry.durationMs) {
-      entry._turnDurationMs = entry.durationMs;
-    }
-    if (entry.type === 'system' && entry.subtype === 'compact_boundary' && entry.compactMetadata) {
-      entry._preTokens = entry.compactMetadata.preTokens;
-    }
-    if (entry.message?.usage) {
-      const u = entry.message.usage;
-      entry._cacheUsage = {
-        cache_creation: u.cache_creation_input_tokens || u['cache_creation.ephemeral_1h_input_tokens'] || u['cache_creation.ephemeral_5m_input_tokens'] || 0,
-        cache_read: u.cache_read_input_tokens || 0
-      };
-    }
-    return entry;
-  } catch {
-    return null;
-  }
-}
-
-export function registerAllAgents(registry) {
-  registry.register({
-    id: 'claude-code',
-    name: 'Claude Code',
-    command: 'claude',
-    protocol: 'direct',
-    supportsStdin: false,
-    closeStdin: true,
-    useJsonRpcStdin: false,
-    supportedFeatures: ['streaming', 'resume', 'system-prompt', 'permissions-skip', 'steering'],
-    spawnEnv: { MAX_THINKING_TOKENS: '0', AGENTGUI_SUBPROCESS: '1' },
-    buildArgs(prompt, config) {
-      const { verbose = true, outputFormat = 'stream-json', print = true, resumeSessionId = null, systemPrompt = null, model = null } = config;
-      const flags = [];
-      if (print) flags.push('--print');
-      if (verbose) flags.push('--verbose');
-      flags.push(`--output-format=${outputFormat}`);
-      if (model) flags.push('--model', model);
-      if (resumeSessionId) flags.push('--resume', resumeSessionId);
-      if (systemPrompt) flags.push('--append-system-prompt', systemPrompt);
-      flags.push('--dangerously-skip-permissions');
-      flags.push(typeof prompt === 'string' ? prompt : String(prompt));
-      return flags;
-    },
-    parseOutput: parseClaudeOutput,
-  });
-
-  registry.register({
-    id: 'opencode',
-    name: 'OpenCode',
-    command: 'opencode',
-    protocol: 'acp',
-    supportsStdin: false,
-    npxPackage: 'opencode-ai',
-    supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
-    buildArgs: () => ['acp'],
-    protocolHandler: acpProtocolHandler,
-  });
-
-  registry.register({
-    id: 'gemini',
-    name: 'Gemini CLI',
-    command: 'gemini',
-    protocol: 'acp',
-    supportsStdin: false,
-    npxPackage: '@google/gemini-cli',
-    supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
-    buildArgs(prompt, config) {
-      const args = ['--experimental-acp', '--yolo'];
-      if (config?.model) args.push('--model', config.model);
-      return args;
-    },
-    protocolHandler: acpProtocolHandler,
-  });
-
-  registry.register({
-    id: 'kilo',
-    name: 'Kilo CLI',
-    command: 'kilo',
-    protocol: 'acp',
-    supportsStdin: false,
-    npxPackage: '@kilocode/cli',
-    supportedFeatures: ['streaming', 'resume', 'acp-protocol', 'models'],
-    buildArgs: () => ['acp'],
-    protocolHandler: acpProtocolHandler,
-  });
-
-  for (const agent of SIMPLE_ACP_AGENTS) {
-    registry.register({
-      id: agent.id,
-      name: agent.name,
-      command: agent.command,
-      protocol: 'acp',
-      supportsStdin: false,
-      supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
-      buildArgs: () => ['acp'],
-      protocolHandler: acpProtocolHandler,
-    });
-  }
-}

package/lib/model-download-machine.js

@@ -1,107 +0,0 @@
-import { createMachine, createActor, assign } from 'xstate';
-
-const machine = createMachine({
-  id: 'model-download',
-  initial: 'idle',
-  context: {
-    progress: null,
-    error: null,
-    startTime: null,
-    waiters: [],
-  },
-  states: {
-    idle: {
-      on: {
-        START: {
-          target: 'downloading',
-          actions: assign({ startTime: () => Date.now(), error: null }),
-        },
-        WAIT: {
-          actions: assign(({ context, event }) => ({
-            waiters: [...context.waiters, event.resolve],
-          })),
-        },
-      },
-    },
-    downloading: {
-      on: {
-        PROGRESS: {
-          actions: assign(({ event }) => ({ progress: event.progress })),
-        },
-        COMPLETE: { target: 'complete' },
-        ERROR: {
-          target: 'error',
-          actions: assign(({ event }) => ({ error: event.error })),
-        },
-        WAIT: {
-          actions: assign(({ context, event }) => ({
-            waiters: [...context.waiters, event.resolve],
-          })),
-        },
-      },
-    },
-    complete: {
-      entry: assign(({ context }) => {
-        for (const resolve of context.waiters) resolve(true);
-        return { waiters: [] };
-      }),
-      on: {
-        RESET: { target: 'idle' },
-      },
-    },
-    error: {
-      entry: assign(({ context }) => {
-        for (const resolve of context.waiters) resolve(false);
-        return { waiters: [] };
-      }),
-      on: {
-        RESET: { target: 'idle' },
-        START: {
-          target: 'downloading',
-          actions: assign({ startTime: () => Date.now(), error: null }),
-        },
-      },
-    },
-  },
-});
-
-let actor = null;
-
-export function getActor() {
-  if (!actor) {
-    actor = createActor(machine);
-    actor.start();
-  }
-  return actor;
-}
-
-export function send(event) {
-  return getActor().send(event);
-}
-
-export function snapshot() {
-  return getActor().getSnapshot();
-}
-
-export function isDownloading() {
-  const s = snapshot();
-  return s.value === 'downloading';
-}
-
-export function isComplete() {
-  const s = snapshot();
-  return s.value === 'complete';
-}
-
-export function isError() {
-  const s = snapshot();
-  return s.value === 'error';
-}
-
-export function getState() {
-  return snapshot().value;
-}
-
-export function getContext() {
-  return snapshot().context;
-}

package/lib/plugin-interface.js

@@ -1,36 +0,0 @@
-// Plugin interface contract - every plugin must implement this
-
-export default {
-  // Plugin metadata
-  name: 'plugin-name', // unique identifier
-  version: '1.0.0',
-  dependencies: [], // list of other plugin names this depends on
-
-  // Lifecycle methods (all required)
-  async init(config, plugins) {
-    // config = { router, wsManager, db, logger, env }
-    // plugins = Map<name, plugin> of all loaded plugins
-    // MUST return: { routes[], wsHandlers{}, api{}, stop() }
-    return {
-      routes: [], // [ { method, path, handler } ]
-      wsHandlers: {}, // { eventType: handler(data, clients) }
-      api: {}, // exported functions for other plugins
-    };
-  },
-
-  async reload(state) {
-    // Called on hot reload. Preserve state from previous instance.
-    // Return new state (or updated state from previous)
-    return state;
-  },
-
-  async stop() {
-    // Graceful shutdown. Clean up resources.
-    // No need to return anything.
-  },
-
-  // Optional: Called when another plugin throws error
-  async handleError(error, context) {
-    // context = { pluginName, phase, ... }
-  },
-};

package/lib/plugins/git-plugin.js

@@ -1,117 +0,0 @@
-// Git plugin - version control, workflow detection, push events
-
-import { execSync } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-
-export default {
-  name: 'git',
-  version: '1.0.0',
-  dependencies: [],
-
-  async init(config, plugins) {
-    let lastPushSha = null;
-    let workflowsList = [];
-    let pushInProgress = false;
-
-    const getRepoRoot = () => {
-      try {
-        return execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
-      } catch {
-        return process.cwd();
-      }
-    };
-
-    const getStatus = async () => {
-      try {
-        const status = execSync('git status --short', { encoding: 'utf8' });
-        const unpushed = execSync('git rev-list --count @{u}..HEAD', { encoding: 'utf8' }).trim();
-        return { dirty: status.length > 0, unpushedCount: parseInt(unpushed) || 0 };
-      } catch (e) {
-        return { dirty: false, unpushedCount: 0 };
-      }
-    };
-
-    const listWorkflows = () => {
-      const root = getRepoRoot();
-      const workflowDir = path.join(root, '.github', 'workflows');
-      if (!fs.existsSync(workflowDir)) return [];
-      return fs.readdirSync(workflowDir).filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
-    };
-
-    const push = async (message) => {
-      if (pushInProgress) throw new Error('Push already in progress');
-      pushInProgress = true;
-      try {
-        execSync('git add -A');
-        execSync(`git commit -m "${message}"`);
-        const result = execSync('git push', { encoding: 'utf8' });
-        lastPushSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
-        return { success: true, sha: lastPushSha };
-      } catch (error) {
-        return { success: false, error: error.message };
-      } finally {
-        pushInProgress = false;
-      }
-    };
-
-    workflowsList = listWorkflows();
-
-    return {
-      routes: [
-        {
-          method: 'GET',
-          path: '/api/git/status',
-          handler: async (req, res) => {
-            const status = await getStatus();
-            res.json({ ...status, workflows: workflowsList });
-          },
-        },
-        {
-          method: 'POST',
-          path: '/api/git/push',
-          handler: async (req, res) => {
-            const { message } = req.body;
-            try {
-              const result = await push(message);
-              res.json(result);
-            } catch (e) {
-              res.status(400).json({ error: e.message });
-            }
-          },
-        },
-        {
-          method: 'GET',
-          path: '/api/git/workflows',
-          handler: (req, res) => {
-            res.json({ workflows: workflowsList });
-          },
-        },
-        {
-          method: 'POST',
-          path: '/api/git/workflow/:name/run',
-          handler: (req, res) => {
-            res.json({ status: 'not-implemented', message: 'Use GitHub Actions API' });
-          },
-        },
-      ],
-      wsHandlers: {
-        git_status_changed: (data, clients) => {
-          // Broadcast git status to all clients
-        },
-      },
-      api: {
-        getStatus,
-        push,
-        listWorkflows,
-      },
-      stop: async () => {},
-    };
-  },
-
-  async reload(state) {
-    return state;
-  },
-
-  async stop() {},
-};

package/lib/rate-limit-machine.js

@@ -1,99 +0,0 @@
-import { createMachine, createActor, assign } from 'xstate';
-
-const machine = createMachine({
-  id: 'rate-limit',
-  initial: 'normal',
-  context: {
-    retryCount: 0,
-    retryAt: null,
-    cooldownMs: null,
-    isStreamDetected: false,
-  },
-  states: {
-    normal: {
-      entry: assign({ retryCount: 0, retryAt: null, cooldownMs: null, isStreamDetected: false }),
-      on: {
-        HIT: {
-          target: 'limited',
-          actions: assign(({ context, event }) => ({
-            retryCount: context.retryCount + 1,
-            retryAt: event.retryAt,
-            cooldownMs: event.cooldownMs,
-            isStreamDetected: event.isStreamDetected || false,
-          })),
-        },
-      },
-    },
-    limited: {
-      on: {
-        CLEAR: [
-          { guard: ({ context }) => context.retryCount >= 3, target: 'exceeded' },
-          { target: 'normal' },
-        ],
-        HIT: {
-          actions: assign(({ context, event }) => ({
-            retryCount: context.retryCount + 1,
-            retryAt: event.retryAt,
-            cooldownMs: event.cooldownMs,
-            isStreamDetected: event.isStreamDetected || false,
-          })),
-        },
-      },
-    },
-    exceeded: {
-      on: {
-        RESET: { target: 'normal' },
-      },
-    },
-  },
-});
-
-const actors = new Map();
-
-export function getOrCreate(convId) {
-  if (actors.has(convId)) return actors.get(convId);
-  const actor = createActor(machine);
-  actor.start();
-  actors.set(convId, actor);
-  return actor;
-}
-
-export function get(convId) {
-  return actors.get(convId) || null;
-}
-
-export function remove(convId) {
-  const actor = actors.get(convId);
-  if (actor) { actor.stop(); actors.delete(convId); }
-}
-
-export function snapshot(convId) {
-  const actor = actors.get(convId);
-  return actor ? actor.getSnapshot() : null;
-}
-
-export function send(convId, event) {
-  const actor = getOrCreate(convId);
-  actor.send(event);
-  return actor.getSnapshot();
-}
-
-export function isLimited(convId) {
-  const s = snapshot(convId);
-  return s ? s.value === 'limited' : false;
-}
-
-export function isExceeded(convId) {
-  const s = snapshot(convId);
-  return s ? s.value === 'exceeded' : false;
-}
-
-export function getContext(convId) {
-  const s = snapshot(convId);
-  return s ? s.context : null;
-}
-
-export function has(convId) {
-  const s = snapshot(convId);
-  return s ? s.value !== 'normal' : false;
-}