@chemx/starter-kit 26.9.20-228 → 26.9.20-369

package/cli/ui-actions-codebase.js

@@ -0,0 +1,75 @@
+/**
+ * Chemical X UI Action Handlers: Codebase Explorer & Symbol Inspector
+ */
+
+export const buildFileTree = (files = []) => {
+  const root = { name: 'root', path: '', isFolder: true, children: [] };
+  for (const f of files) {
+    const parts = (f.path || '').split('/');
+    let cur = root;
+    for (let i = 0; i < parts.length; i++) {
+      const isFile = i === parts.length - 1;
+      if (isFile) {
+        cur.children.push({
+          name: parts[i], path: f.path, isFolder: false, lines: Number(f.lines || 0),
+          tier: f.tier || 'utility', healthScore: Number(f.healthScore ?? 100), hazardCount: Number(f.hazardCount ?? 0)
+        });
+      } else {
+        const p = parts.slice(0, i + 1).join('/');
+        let folder = cur.children.find((c) => c.isFolder && c.name === parts[i]);
+        if (!folder) {
+          folder = { name: parts[i], path: p, isFolder: true, children: [] };
+          cur.children.push(folder);
+        }
+        cur = folder;
+      }
+    }
+  }
+  return root.children;
+};
+
+export const handleCodebaseIndex = (db) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const files = db.prepare('SELECT path, tier, lines, health_score, hazard_count FROM files ORDER BY path ASC').all().map((f) => ({
+    path: f.path, tier: f.tier || 'utility', lines: Number(f.lines || 0),
+    healthScore: Number(f.health_score ?? 100), hazardCount: Number(f.hazard_count ?? 0)
+  }));
+  const violations = db.prepare('SELECT file_path, rule, severity, line, hazard, directive FROM violations ORDER BY id DESC LIMIT 50').all().map((v) => ({
+    filePath: v.file_path, rule: v.rule, severity: v.severity, line: Number(v.line || 0), hazard: v.hazard, directive: v.directive
+  }));
+  return { success: true, files, violations };
+};
+
+export const handleCodebaseTree = (db) => {
+  const res = handleCodebaseIndex(db);
+  if (!res.success) return res;
+  return { success: true, tree: buildFileTree(res.files), files: res.files, count: res.files.length };
+};
+
+export const handleCodebaseFile = (db, targetPath) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  if (!targetPath) return { success: false, error: 'File path required' };
+  const p = targetPath.trim();
+  const f = db.prepare('SELECT path, tier, lines, chars, health_score, hazard_count FROM files WHERE path = ?').get(p);
+  if (!f) return { success: false, error: 'File not indexed', path: p };
+
+  const symbols = db.prepare('SELECT name, kind, is_export, start_line, end_line, signature FROM symbols WHERE file_path = ? ORDER BY start_line ASC').all(p).map((s) => ({
+    name: s.name, kind: s.kind, isExport: Boolean(s.is_export), startLine: Number(s.start_line || 1), endLine: Number(s.end_line || 1), signature: s.signature || ''
+  }));
+  const imports = db.prepare('SELECT imported_symbol, source_module, line FROM imports WHERE importer_path = ? ORDER BY line ASC').all(p).map((i) => ({
+    symbol: i.imported_symbol, source: i.source_module, line: Number(i.line || 1)
+  }));
+  const base = p.split('/').pop().replace(/\.[^.]+$/, '');
+  const connections = db.prepare('SELECT DISTINCT i.importer_path, i.imported_symbol, i.source_module, i.line, f.tier FROM imports i LEFT JOIN files f ON i.importer_path = f.path WHERE i.source_module LIKE ? OR i.source_module LIKE ? ORDER BY i.importer_path ASC').all(`%/${base}%`, `%${base}%`).map((c) => ({
+    importerPath: c.importer_path, importedSymbol: c.imported_symbol, sourceModule: c.source_module, line: Number(c.line || 1), tier: c.tier || 'utility'
+  }));
+  const violations = db.prepare('SELECT rule, severity, line, hazard, directive FROM violations WHERE file_path = ? ORDER BY line ASC').all(p).map((v) => ({
+    rule: v.rule, severity: v.severity, line: Number(v.line || 1), hazard: v.hazard, directive: v.directive
+  }));
+
+  return {
+    success: true,
+    file: { path: f.path, tier: f.tier || 'utility', lines: Number(f.lines || 0), healthScore: Number(f.health_score ?? 100), hazardCount: Number(f.hazard_count ?? 0) },
+    symbols, exports: symbols.filter((s) => s.isExport), imports, connections, violations
+  };
+};

package/cli/ui-actions-studio.js

@@ -0,0 +1,91 @@
+/**
+ * Chemical X UI Studio Actions: Prompt Workbench & Database Studio (R7/R8)
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { runAudit } from './audit.js';
+import {
+  buildMasterPrompt,
+  buildGradeFPrompt,
+  buildGradeDPrompt,
+  buildGradeCPrompt,
+  buildGradeBPrompt,
+  buildAiSlopPrompt,
+  buildHotspotsPrompt
+} from './audit/prompts.js';
+
+const PROMPT_BUILDERS = {
+  'master': buildMasterPrompt,
+  'grade-f': buildGradeFPrompt,
+  'grade-d': buildGradeDPrompt,
+  'grade-c': buildGradeCPrompt,
+  'grade-b': buildGradeBPrompt,
+  'ai-slop': buildAiSlopPrompt,
+  'hotspots': buildHotspotsPrompt
+};
+
+export const handleGeneratePrompt = (db, body = {}, cwd = process.cwd()) => {
+  const rawScope = String(body.scope || 'master').toLowerCase().trim().replace(/[\s_]+/g, '-');
+  const builder = PROMPT_BUILDERS[rawScope] || buildMasterPrompt;
+  const targetDir = body.dir || (fs.existsSync(path.resolve(cwd, 'src')) ? 'src' : '.');
+  const report = body.report || runAudit(targetDir, { cwd });
+  const prompt = builder(report, { excludeAiSlop: Boolean(body.excludeAiSlop) }) || '';
+  const estimatedTokens = Math.round(prompt.length / 3.8);
+  return { success: true, scope: rawScope, prompt: prompt || 'No violations found for scope.', estimatedTokens, charCount: prompt.length };
+};
+
+const getTableNames = (db) => {
+  if (!db) return [];
+  return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name ASC").all().map((r) => r.name);
+};
+
+export const handleDbTables = (db) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const tables = getTableNames(db).map((name) => {
+    const row = db.prepare(`SELECT COUNT(*) as c FROM ${name}`).get();
+    return { name, rowCount: row?.c || 0 };
+  });
+  return { success: true, tables, totalTables: tables.length };
+};
+
+export const handleDbBrowse = (db, queryParams = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const tableNames = getTableNames(db);
+  const table = queryParams.table || tableNames[0] || 'agent_tasks';
+  if (!tableNames.includes(table)) return { success: false, error: `Invalid table: ${table}` };
+
+  const page = Math.max(1, parseInt(queryParams.page || '1', 10));
+  const pageSize = Math.min(100, Math.max(1, parseInt(queryParams.pageSize || queryParams.limit || '25', 10)));
+  const offset = (page - 1) * pageSize;
+  const totalRows = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get()?.c || 0;
+  const rows = db.prepare(`SELECT * FROM ${table} LIMIT ? OFFSET ?`).all(pageSize, offset);
+  const columns = rows.length > 0 ? Object.keys(rows[0]) : db.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name);
+
+  return { success: true, table, columns, rows, totalRows, page, pageSize, totalPages: Math.ceil(totalRows / pageSize) || 1 };
+};
+
+export const handleDbStructure = (db, queryParams = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const tableNames = getTableNames(db);
+  const table = queryParams.table || tableNames[0] || 'agent_tasks';
+  if (!tableNames.includes(table)) return { success: false, error: `Invalid table: ${table}` };
+
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  const indexes = db.prepare(`PRAGMA index_list(${table})`).all();
+  return { success: true, table, columns, indexes };
+};
+
+export const handleDbQuery = (db, body = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const sql = (body.sql || body.query || '').trim();
+  if (!sql) return { success: false, error: 'Empty SQL query' };
+  if (!/^(SELECT|PRAGMA|EXPLAIN)\b/i.test(sql)) {
+    return { success: false, error: 'Only SELECT, PRAGMA, and EXPLAIN queries are permitted.' };
+  }
+  const start = performance.now();
+  const rows = db.prepare(sql).all().slice(0, 100);
+  const durationMs = Number((performance.now() - start).toFixed(2));
+  const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+  return { success: true, query: sql, columns, rows, rowCount: rows.length, durationMs };
+};

package/cli/ui-actions-tasks.js

@@ -0,0 +1,87 @@
+/**
+ * Chemical X UI Task & Lock Actions
+ * Status updates, agent reassignments, and lock overrides
+ */
+
+import { getTask, updateTaskStatus, postFeedEvent } from './team/team-db.js';
+import { promoteNextWaiter } from './team/team-db-locks.js';
+
+const formatAgentHandle = (id) => {
+  const hasId = Boolean(id);
+  if (!hasId) return null;
+  const isPrefixed = id.startsWith('@');
+  return isPrefixed ? id : `@${id}`;
+};
+
+export const handleUpdateTaskStatus = (db, body = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const taskId = Number(body.taskId || body.id);
+  const status = body.status;
+  const hasTaskId = Boolean(taskId);
+  const hasStatus = Boolean(status);
+  const isValid = hasTaskId && hasStatus;
+  if (!isValid) return { success: false, error: 'taskId and status required' };
+
+  const blockedReason = body.blocked_reason || body.blockedReason || '';
+  const agentId = formatAgentHandle(body.agentId || body.agent) || '@ui-operator';
+  const updated = updateTaskStatus(db, taskId, status, { blockedReason });
+  if (!updated) return { success: false, error: 'Task not found' };
+
+  postFeedEvent(db, {
+    author_id: agentId,
+    event_type: 'task_status_updated',
+    task_id: taskId,
+    message: `Task #${taskId} status updated to '${status}'` + (blockedReason ? `: ${blockedReason}` : '')
+  });
+
+  return { success: true, task: updated };
+};
+
+export const handleAssignTask = (db, body = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const taskId = Number(body.taskId || body.id);
+  if (!taskId) return { success: false, error: 'taskId required' };
+
+  const rawAgent = body.assigned_agent_id || body.assignedAgentId || body.agentId || body.agent || null;
+  const cleanAgent = formatAgentHandle(rawAgent);
+  const now = Date.now();
+
+  db.prepare('UPDATE agent_tasks SET assigned_agent_id = ?, updated_at = ? WHERE id = ?')
+    .run(cleanAgent, now, taskId);
+
+  if (cleanAgent) {
+    db.prepare('UPDATE agents SET current_task_id = ?, status = ? WHERE id = ?')
+      .run(taskId, 'busy', cleanAgent);
+  }
+
+  postFeedEvent(db, {
+    author_id: '@ui-operator',
+    recipient_id: cleanAgent,
+    event_type: 'task_reassigned',
+    task_id: taskId,
+    message: `Task #${taskId} reassigned to ${cleanAgent || 'unassigned'}`
+  });
+
+  return { success: true, taskId, assigned_agent_id: cleanAgent, task: getTask(db, taskId) };
+};
+
+export const handleOverrideLock = (db, body = {}) => {
+  if (!db) return { success: false, error: 'Database unavailable' };
+  const filePath = body.filePath || body.path;
+  if (!filePath) return { success: false, error: 'filePath is required' };
+  const operator = formatAgentHandle(body.agentId || body.agent) || '@ui-operator';
+
+  const existing = db.prepare('SELECT * FROM file_leases WHERE file_path = ?').get(filePath);
+  db.prepare('DELETE FROM file_leases WHERE file_path = ?').run(filePath);
+
+  postFeedEvent(db, {
+    author_id: operator,
+    event_type: 'lock_override',
+    file_path: filePath,
+    message: `${operator} overrode lock lease on ${filePath}` + (existing ? ` (held by ${existing.locked_by})` : '')
+  });
+
+  const next = promoteNextWaiter(db, filePath);
+  const promotedWaiter = next ? next.waiter.agent_id : null;
+  return { success: true, overridden: true, filePath, previousHolder: existing?.locked_by || null, promotedWaiter };
+};

package/cli/ui-actions.js

@@ -7,33 +7,7 @@ import { createTask, claimTask, requestFileLock, releaseFileLock } from './team/
 import { completeTaskWithAudit } from './team/team-triage.js';
 import { executeSettingsAction } from './ui-actions-helpers.js';
 
-export const handleCodebaseIndex = (db) => {
-  if (!db) return { success: false, error: 'Database unavailable' };
-  const files = db.prepare(`
-    SELECT path, tier, lines, health_score, hazard_count
-    FROM files ORDER BY health_score ASC, lines DESC
-  `).all().map((f) => ({
-    path: f.path,
-    tier: f.tier || 'utility',
-    lines: Number(f.lines || 0),
-    healthScore: Number(f.health_score || 0),
-    hazardCount: Number(f.hazard_count || 0)
-  }));
-
-  const violations = db.prepare(`
-    SELECT file_path, rule, severity, line, hazard, directive
-    FROM violations ORDER BY id DESC LIMIT 50
-  `).all().map((v) => ({
-    filePath: v.file_path,
-    rule: v.rule,
-    severity: v.severity,
-    line: Number(v.line || 0),
-    hazard: v.hazard,
-    directive: v.directive
-  }));
-
-  return { success: true, files, violations };
-};
+export { handleCodebaseIndex, handleCodebaseTree, handleCodebaseFile } from './ui-actions-codebase.js';
 
 export const handleCreateTask = (db, body = {}) => {
   if (!db) return { success: false, error: 'Database unavailable' };
@@ -83,3 +57,13 @@ export const handleReleaseLock = (db, body = {}) => {
 export const handleSettingsAction = (db, body = {}) => {
   return executeSettingsAction(db, body.action, body);
 };
+
+export { handleUpdateTaskStatus, handleAssignTask, handleOverrideLock } from './ui-actions-tasks.js';
+export {
+  handleGeneratePrompt,
+  handleDbTables,
+  handleDbBrowse,
+  handleDbStructure,
+  handleDbQuery
+} from './ui-actions-studio.js';
+

package/cli/ui-canonical-routes.spec.js

@@ -0,0 +1,130 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { initTeamSchema } from './team/team-schema.js';
+import { handleSwarmStatus } from './ui-handlers.js';
+import { routeGet, routePost } from './ui-server-routes.js';
+import { startUiServer } from './ui-server.js';
+
+const setupTestDb = () => {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      mtime INTEGER NOT NULL,
+      size INTEGER NOT NULL,
+      tier TEXT NOT NULL,
+      lines INTEGER NOT NULL,
+      chars INTEGER NOT NULL,
+      health_score INTEGER NOT NULL DEFAULT 100,
+      hazard_count INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+  initTeamSchema(db);
+  return db;
+};
+
+test('ui-handlers: handleSwarmStatus returns clean arrays for leases, waitingLocks, tasks, and agents', () => {
+  const db = setupTestDb();
+  const now = Date.now();
+  db.prepare("INSERT INTO agents (id, name, role, heartbeat) VALUES ('@agent-1', 'Agent 1', 'worker', ?)").run(now);
+  db.prepare("INSERT INTO file_leases (file_path, locked_by, acquired_at, expires_at, purpose) VALUES ('src/test.ts', '@agent-1', ?, ?, 'editing')").run(now, now + 60000);
+  db.prepare("INSERT INTO file_lock_queue (file_path, agent_id, requested_at, status, priority, purpose) VALUES ('src/test.ts', '@agent-2', ?, 'waiting', 1, 'waiting lock')").run(now);
+  db.prepare("INSERT INTO agent_tasks (title, tier, status, created_at, updated_at) VALUES ('Canonical Task', 'backend', 'todo', ?, ?)").run(now, now);
+
+  const status = handleSwarmStatus(db);
+  assert.strictEqual(status.success, true);
+  assert.ok(Array.isArray(status.leases));
+  assert.ok(Array.isArray(status.waitingLocks));
+  assert.ok(Array.isArray(status.tasks));
+  assert.ok(Array.isArray(status.agents));
+
+  assert.strictEqual(status.leases.length, 1);
+  assert.strictEqual(status.leases[0].filePath, 'src/test.ts');
+  assert.strictEqual(status.leases[0].lockedBy, '@agent-1');
+  assert.strictEqual(status.leases[0].waitingCount, 1);
+
+  assert.strictEqual(status.waitingLocks.length, 1);
+  assert.strictEqual(status.waitingLocks[0].filePath, 'src/test.ts');
+  assert.strictEqual(status.waitingLocks[0].agentId, '@agent-2');
+
+  assert.strictEqual(status.tasks.length, 1);
+  assert.strictEqual(status.tasks[0].title, 'Canonical Task');
+
+  assert.strictEqual(status.agents.length, 1);
+  assert.strictEqual(status.agents[0].id, '@agent-1');
+});
+
+test('ui-server-routes: routeGet resolves canonical aliases /api/status, /api/feed, /api/tasks', () => {
+  const db = setupTestDb();
+  const now = Date.now();
+  db.prepare("INSERT INTO agent_tasks (title, tier, status, created_at, updated_at) VALUES ('Route Task', 'backend', 'todo', ?, ?)").run(now, now);
+  db.prepare("INSERT INTO agent_feed (author_id, event_type, message, timestamp) VALUES ('@agent-1', 'broadcast', 'Route Feed Message', ?)").run(now);
+
+  const statusRes = routeGet('/api/status', db);
+  assert.ok(statusRes);
+  assert.strictEqual(statusRes.success, true);
+  assert.ok(Array.isArray(statusRes.leases));
+  assert.ok(Array.isArray(statusRes.waitingLocks));
+
+  const feedRes = routeGet('/api/feed', db);
+  assert.ok(feedRes);
+  assert.strictEqual(feedRes.success, true);
+  assert.ok(Array.isArray(feedRes.feed));
+  assert.ok(feedRes.feed.some((f) => f.message === 'Route Feed Message'));
+
+  const tasksRes = routeGet('/api/tasks', db);
+  assert.ok(tasksRes);
+  assert.strictEqual(tasksRes.success, true);
+  assert.ok(Array.isArray(tasksRes.tasks));
+  assert.ok(tasksRes.tasks.some((t) => t.title === 'Route Task'));
+});
+
+test('ui-server-routes: routePost resolves canonical aliases /api/feed and /api/tasks', () => {
+  const db = setupTestDb();
+  const now = Date.now();
+  db.prepare("INSERT INTO agents (id, name, role, heartbeat) VALUES ('@tester', 'Tester', 'qa', ?)").run(now);
+
+  const postFeedRes = routePost('/api/feed', db, {
+    author: '@tester',
+    message: 'Canonical post test',
+    channel: 'general'
+  });
+  assert.ok(postFeedRes);
+  assert.strictEqual(postFeedRes.success, true);
+
+  const postTaskRes = routePost('/api/tasks', db, {
+    title: 'Created via canonical route',
+    tier: 'backend'
+  });
+  assert.ok(postTaskRes);
+  assert.strictEqual(postTaskRes.success, true);
+
+  const tasksRes = routeGet('/api/tasks', db);
+  assert.ok(tasksRes.tasks.some((t) => t.title === 'Created via canonical route'));
+});
+
+test('ui-server: HTTP integration serves canonical routes /api/status, /api/feed, /api/tasks', async () => {
+  const running = await startUiServer({ port: 0, cwd: process.cwd() });
+  try {
+    const resStatus = await fetch(`http://localhost:${running.port}/api/status`);
+    assert.strictEqual(resStatus.status, 200);
+    const jsonStatus = await resStatus.json();
+    assert.strictEqual(jsonStatus.success, true);
+    assert.ok(Array.isArray(jsonStatus.waitingLocks));
+
+    const resFeed = await fetch(`http://localhost:${running.port}/api/feed`);
+    assert.strictEqual(resFeed.status, 200);
+    const jsonFeed = await resFeed.json();
+    assert.strictEqual(jsonFeed.success, true);
+    assert.ok(Array.isArray(jsonFeed.feed));
+
+    const resTasks = await fetch(`http://localhost:${running.port}/api/tasks`);
+    assert.strictEqual(resTasks.status, 200);
+    const jsonTasks = await resTasks.json();
+    assert.strictEqual(jsonTasks.success, true);
+    assert.ok(Array.isArray(jsonTasks.tasks));
+  } finally {
+    running.server.close();
+  }
+});

package/cli/ui-client-api.js

@@ -4,46 +4,84 @@
 export const UI_CLIENT_API_SCRIPT = `
 window.chemxApi = {
   fetchStatus: async () => {
-    try {
-      const res = await fetch('/api/swarm/status');
-      if (res.ok) return await res.json();
-    } catch {}
+    try { const res = await fetch('/api/swarm/status'); if (res.ok) return await res.json(); } catch (_err) { return null; }
     return null;
   },
   fetchCodebase: async () => {
-    try {
-      const res = await fetch('/api/swarm/codebase');
-      if (res.ok) { const d = await res.json(); return d.files || []; }
-    } catch {}
+    try { const res = await fetch('/api/swarm/codebase'); if (res.ok) { const d = await res.json(); return d.files || []; } } catch (_err) { return []; }
     return [];
   },
+  fetchFileTree: async () => {
+    try { const res = await fetch('/api/codebase/tree'); if (res.ok) return await res.json(); } catch (_err) { return { success: false, tree: [], files: [] }; }
+    return { success: false, tree: [], files: [] };
+  },
+  fetchFileDetails: async (path) => {
+    try { const res = await fetch('/api/codebase/file?path=' + encodeURIComponent(path)); if (res.ok) return await res.json(); } catch (_err) { return { success: false, error: 'Network error' }; }
+    return { success: false, error: 'Network error' };
+  },
   fetchAttention: async () => {
-    try {
-      const res = await fetch('/api/swarm/attention');
-      if (res.ok) return await res.json();
-    } catch {}
+    try { const res = await fetch('/api/swarm/attention'); if (res.ok) return await res.json(); } catch (_err) { return { items: [], antigravityRunning: false }; }
     return { items: [], antigravityRunning: false };
   },
   confirmAttention: async (itemId, action) => {
     await fetch('/api/swarm/attention/action', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ itemId, action }) });
   },
   fetchDbMetrics: async () => {
-    try {
-      const res = await fetch('/api/swarm/database/metrics');
-      if (res.ok) return await res.json();
-    } catch {}
+    try { const res = await fetch('/api/swarm/database/metrics'); if (res.ok) return await res.json(); } catch (_err) { return null; }
     return null;
   },
+  fetchDbTables: async () => {
+    try { const res = await fetch('/api/db/tables'); if (res.ok) return await res.json(); } catch (_err) { return { success: false, tables: [] }; }
+    return { success: false, tables: [] };
+  },
+  fetchDbBrowse: async (table, page = 1, pageSize = 25) => {
+    try { const res = await fetch('/api/db/browse?table=' + encodeURIComponent(table) + '&page=' + page + '&pageSize=' + pageSize); if (res.ok) return await res.json(); } catch (_err) { return { success: false, rows: [], columns: [] }; }
+    return { success: false, rows: [], columns: [] };
+  },
+  fetchDbStructure: async (table) => {
+    try { const res = await fetch('/api/db/structure?table=' + encodeURIComponent(table)); if (res.ok) return await res.json(); } catch (_err) { return { success: false, columns: [] }; }
+    return { success: false, columns: [] };
+  },
+  generatePrompt: async (scope = 'master', excludeAiSlop = false) => {
+    try { const res = await fetch('/api/prompts/generate', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ scope, excludeAiSlop }) }); if (res.ok) return await res.json(); } catch (_err) { return { success: false, error: 'Network error' }; }
+    return { success: false, error: 'Failed to generate prompt' };
+  },
   runDbQuery: async (query) => {
     try {
-      const res = await fetch('/api/swarm/database/query', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ query }) });
+      const res = await fetch('/api/db/query', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ query }) });
       return await res.json();
-    } catch (err) {
-      return { success: false, error: err.message };
-    }
+    } catch (err) { return { success: false, error: err.message }; }
   },
   postJson: async (url, body) => {
     return fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+  },
+  updateTaskStatus: async (taskId, status, blockedReason = '') => {
+    const res = await fetch('/api/tasks/update', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ taskId, status, blockedReason }) });
+    return await res.json();
+  },
+  assignTask: async (taskId, agentId) => {
+    const res = await fetch('/api/tasks/assign', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ taskId, agentId }) });
+    return await res.json();
+  },
+  overrideLock: async (filePath, agentId = '@ui-operator') => {
+    const res = await fetch('/api/locks/override', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ filePath, agentId }) });
+    return await res.json();
+  },
+  createTask: async (payload) => {
+    const res = await fetch('/api/tasks', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
+    return await res.json();
+  },
+  fetchTopics: async (category = '') => {
+    try { const res = await fetch('/api/topics' + (category ? '?category=' + encodeURIComponent(category) : '')); if (res.ok) return await res.json(); } catch (_err) { return { success: false, topics: [] }; }
+    return { success: false, topics: [] };
+  },
+  fetchTopicPosts: async (topicId) => {
+    try { const res = await fetch('/api/topics/posts?topicId=' + encodeURIComponent(topicId)); if (res.ok) return await res.json(); } catch (_err) { return { success: false, posts: [] }; }
+    return { success: false, posts: [] };
+  },
+  createTopic: async (payload) => {
+    const res = await fetch('/api/topics', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
+    return await res.json();
   }
 };
 `;

package/cli/ui-client-filetree.js

@@ -0,0 +1,93 @@
+/**
+ * Chemical X UI File Tree & Inspector Reactive State
+ */
+export const UI_CLIENT_FILETREE_SCRIPT = `
+window.createFileTreeState = (Vue, api, codebaseFiles) => {
+  const { ref, computed } = Vue;
+  const selectedFilePath = ref(''), selectedFileDetail = ref(null), selectedFileLoading = ref(false);
+  const inspectorTab = ref('outline'), collapsedFolders = ref(new Set()), fileFilterQuery = ref('');
+
+  const flattenedNodes = computed(() => {
+    const files = codebaseFiles.value || [], folderMap = new Map(), nodes = [];
+    for (const f of files) {
+      const parts = (f.path || '').split('/');
+      let cur = '';
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur = cur ? cur + '/' + parts[i] : parts[i];
+        if (!folderMap.has(cur)) folderMap.set(cur, { name: parts[i], path: cur, isFolder: true, depth: i, fileCount: 0 });
+        folderMap.get(cur).fileCount++;
+      }
+    }
+    const allPaths = Array.from(new Set([...folderMap.keys(), ...files.map((f) => f.path)])).sort();
+    for (const p of allPaths) {
+      if (folderMap.has(p)) {
+        nodes.push(folderMap.get(p));
+      } else {
+        const fileObj = files.find((x) => x.path === p);
+        if (fileObj) {
+          const parts = p.split('/');
+          nodes.push({
+            name: parts[parts.length - 1], path: p, isFolder: false, depth: parts.length - 1,
+            lines: Number(fileObj.lines || 0), tier: fileObj.tier || 'utility',
+            healthScore: Number(fileObj.healthScore ?? 100), hazardCount: Number(fileObj.hazardCount ?? 0)
+          });
+        }
+      }
+    }
+    return nodes;
+  });
+
+  const filteredFileTree = computed(() => {
+    const q = fileFilterQuery.value.trim().toLowerCase();
+    const collapsed = collapsedFolders.value;
+    return flattenedNodes.value.filter((node) => {
+      const parts = node.path.split('/');
+      let prefix = '';
+      for (let i = 0; i < parts.length - 1; i++) {
+        prefix = prefix ? prefix + '/' + parts[i] : parts[i];
+        if (collapsed.has(prefix)) return false;
+      }
+      if (!q) return true;
+      if (node.isFolder) return true;
+      return node.name.toLowerCase().includes(q) || (node.tier && node.tier.toLowerCase().includes(q));
+    });
+  });
+
+  const cleanFileCount = computed(() => (codebaseFiles.value || []).filter((f) => Number(f.lines || 0) <= 100).length);
+  const monolithFileCount = computed(() => (codebaseFiles.value || []).filter((f) => Number(f.lines || 0) > 100).length);
+  const codebaseHazardCount = computed(() => (codebaseFiles.value || []).reduce((acc, f) => acc + Number(f.hazardCount || 0), 0));
+
+  const isFolderExpanded = (path) => !collapsedFolders.value.has(path);
+  const toggleFolder = (path) => {
+    const next = new Set(collapsedFolders.value);
+    if (next.has(path)) next.delete(path); else next.add(path);
+    collapsedFolders.value = next;
+  };
+  const expandAllFolders = () => { collapsedFolders.value = new Set(); };
+  const collapseAllFolders = () => {
+    const all = new Set();
+    for (const n of flattenedNodes.value) { if (n.isFolder) all.add(n.path); }
+    collapsedFolders.value = all;
+  };
+
+  const selectFile = async (path) => {
+    selectedFilePath.value = path;
+    selectedFileLoading.value = true;
+    const res = await api.fetchFileDetails(path);
+    selectedFileLoading.value = false;
+    if (res?.success) selectedFileDetail.value = res;
+  };
+
+  const refreshCodebase = async () => {
+    const res = await api.fetchFileTree();
+    if (res?.files) codebaseFiles.value = res.files;
+    else codebaseFiles.value = await api.fetchCodebase();
+  };
+
+  return {
+    selectedFilePath, selectedFileDetail, selectedFileLoading, inspectorTab, fileFilterQuery,
+    filteredFileTree, cleanFileCount, monolithFileCount, codebaseHazardCount,
+    isFolderExpanded, toggleFolder, expandAllFolders, collapseAllFolders, selectFile, refreshCodebase
+  };
+};
+`;