quoroom 0.1.0

package/out/mcp/api-server.js

@@ -0,0 +1,2855 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "quoroom",
+      version: "0.1.0",
+      description: "Autonomous AI agent collective engine \u2014 Queen, Workers, Quorum",
+      main: "./out/mcp/server.js",
+      bin: {
+        quoroom: "./out/mcp/cli.js"
+      },
+      author: "Quoroom <hello@quoroom.ai>",
+      homepage: "https://quoroom.ai",
+      repository: {
+        type: "git",
+        url: "https://github.com/quoroom-ai/room.git"
+      },
+      license: "MIT",
+      files: [
+        "out/mcp/cli.js",
+        "out/mcp/server.js",
+        "out/mcp/api-server.js"
+      ],
+      scripts: {
+        build: "npm run typecheck && npm run build:mcp && npm run build:ui",
+        "build:mcp": "node scripts/build-mcp.js",
+        "build:ui": "vite build --config src/ui/vite.config.ts",
+        "dev:ui": "vite --config src/ui/vite.config.ts",
+        typecheck: "tsc --noEmit",
+        test: "npm run rebuild:native:node && vitest run --pool=forks",
+        "test:watch": "npm run rebuild:native:node && vitest --pool=forks",
+        "test:e2e": "npm run build && npx playwright test",
+        "test:e2e:ui": "npm run build && npx playwright test e2e/ui.test.ts",
+        "rebuild:native:node": `node -e "try{require('better-sqlite3')(':memory:').close()}catch{process.exit(1)}" || npx --yes node-gyp rebuild --directory=node_modules/better-sqlite3`,
+        prepublishOnly: "npm run build:mcp"
+      },
+      dependencies: {
+        "@huggingface/transformers": "^3.4.1",
+        "@modelcontextprotocol/sdk": "^1.12.0",
+        "better-sqlite3": "^11.10.0",
+        "node-cron": "^3.0.3",
+        "sqlite-vec": "^0.1.7-alpha.2",
+        viem: "^2.46.2",
+        ws: "^8.16.0",
+        zod: "^3.24.0"
+      },
+      devDependencies: {
+        "@electron-toolkit/tsconfig": "^2.0.0",
+        "@playwright/test": "^1.58.2",
+        "@tailwindcss/vite": "^4.2.0",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/node": "^20.11.0",
+        "@types/node-cron": "^3.0.11",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@types/ws": "^8.5.10",
+        "@vitejs/plugin-react": "^5.1.4",
+        esbuild: "^0.24.0",
+        react: "^19.2.4",
+        "react-dom": "^19.2.4",
+        tailwindcss: "^4.2.0",
+        typescript: "^5.9.3",
+        vite: "^7.3.1",
+        vitest: "^1.6.1"
+      }
+    };
+  }
+});
+
+// src/server/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createApiServer: () => createApiServer,
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_http = __toESM(require("node:http"));
+var import_node_url = require("node:url");
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+
+// src/server/router.ts
+var Router = class {
+  routes = [];
+  get(path2, handler) {
+    this.add("GET", path2, handler);
+  }
+  post(path2, handler) {
+    this.add("POST", path2, handler);
+  }
+  patch(path2, handler) {
+    this.add("PATCH", path2, handler);
+  }
+  put(path2, handler) {
+    this.add("PUT", path2, handler);
+  }
+  delete(path2, handler) {
+    this.add("DELETE", path2, handler);
+  }
+  add(method, path2, handler) {
+    const paramNames = [];
+    const patternStr = path2.replace(/:(\w+)/g, (_, name) => {
+      paramNames.push(name);
+      return "([^/]+)";
+    });
+    this.routes.push({
+      method,
+      pattern: new RegExp(`^${patternStr}$`),
+      paramNames,
+      handler
+    });
+  }
+  match(method, pathname) {
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const match = pathname.match(route.pattern);
+      if (match) {
+        const params = {};
+        route.paramNames.forEach((name, i) => {
+          params[name] = decodeURIComponent(match[i + 1]);
+        });
+        return { handler: route.handler, params };
+      }
+    }
+    return null;
+  }
+};
+
+// src/server/auth.ts
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var serverToken = null;
+function generateToken() {
+  serverToken = import_node_crypto.default.randomBytes(32).toString("hex");
+  return serverToken;
+}
+function getToken() {
+  if (!serverToken) throw new Error("Token not yet generated");
+  return serverToken;
+}
+function validateToken(authHeader) {
+  if (!serverToken) return false;
+  if (!authHeader?.startsWith("Bearer ")) return false;
+  const provided = Buffer.from(authHeader.slice(7));
+  const expected = Buffer.from(serverToken);
+  if (provided.length !== expected.length) return false;
+  return import_node_crypto.default.timingSafeEqual(provided, expected);
+}
+function writeTokenFile(dataDir, token, port) {
+  (0, import_node_fs.mkdirSync)(dataDir, { recursive: true });
+  (0, import_node_fs.writeFileSync)((0, import_node_path.join)(dataDir, "api.token"), token, { mode: 384 });
+  (0, import_node_fs.writeFileSync)((0, import_node_path.join)(dataDir, "api.port"), String(port));
+}
+var ALLOWED_REMOTE_ORIGINS = [
+  "https://app.quoroom.ai",
+  "https://quoroom-ai.github.io"
+];
+function isAllowedOrigin(origin) {
+  if (!origin) return true;
+  try {
+    const url = new URL(origin);
+    if (url.hostname === "localhost" || url.hostname === "127.0.0.1") return true;
+    return ALLOWED_REMOTE_ORIGINS.includes(origin);
+  } catch {
+    return false;
+  }
+}
+function setCorsHeaders(origin, headers) {
+  if (origin && isAllowedOrigin(origin)) {
+    headers["Access-Control-Allow-Origin"] = origin;
+  }
+  headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS";
+  headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization";
+  headers["Access-Control-Max-Age"] = "86400";
+}
+
+// src/shared/constants.ts
+var DEFAULT_ROOM_CONFIG = {
+  threshold: "majority",
+  timeoutMinutes: 60,
+  keeperWeight: "dynamic",
+  tieBreaker: "queen",
+  autoApprove: ["low_impact"],
+  minCycleGapMs: 1e3
+};
+
+// src/shared/db-queries.ts
+function createEntity(db2, name, type = "fact", category) {
+  const result = db2.prepare("INSERT INTO entities (name, type, category) VALUES (?, ?, ?)").run(name, type, category ?? null);
+  return getEntity(db2, result.lastInsertRowid);
+}
+function getEntity(db2, id) {
+  const row = db2.prepare("SELECT * FROM entities WHERE id = ?").get(id);
+  return row ?? null;
+}
+function listEntities(db2, category) {
+  if (category) {
+    return db2.prepare("SELECT * FROM entities WHERE category = ? ORDER BY updated_at DESC").all(category);
+  }
+  return db2.prepare("SELECT * FROM entities ORDER BY updated_at DESC").all();
+}
+function updateEntity(db2, id, updates) {
+  const fields = [];
+  const values = [];
+  if (updates.name !== void 0) {
+    fields.push("name = ?");
+    values.push(updates.name);
+  }
+  if (updates.type !== void 0) {
+    fields.push("type = ?");
+    values.push(updates.type);
+  }
+  if (updates.category !== void 0) {
+    fields.push("category = ?");
+    values.push(updates.category);
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE entities SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteEntity(db2, id) {
+  db2.prepare("DELETE FROM entities WHERE id = ?").run(id);
+}
+function searchEntities(db2, query) {
+  try {
+    const ftsResults = db2.prepare(
+      `SELECT e.* FROM entities e
+         INNER JOIN memory_fts fts ON e.id = fts.rowid
+         WHERE memory_fts MATCH ?
+         ORDER BY rank`
+    ).all(query);
+    if (ftsResults.length > 0) return ftsResults;
+  } catch {
+  }
+  const escaped = query.replace(/[%_]/g, "\\$&");
+  return db2.prepare("SELECT * FROM entities WHERE name LIKE ? ESCAPE '\\' OR category LIKE ? ESCAPE '\\' ORDER BY updated_at DESC").all(`%${escaped}%`, `%${escaped}%`);
+}
+function addObservation(db2, entityId, content, source = "claude") {
+  const result = db2.prepare("INSERT INTO observations (entity_id, content, source) VALUES (?, ?, ?)").run(entityId, content, source);
+  db2.prepare("UPDATE entities SET embedded_at = NULL, updated_at = datetime('now','localtime') WHERE id = ?").run(entityId);
+  return getObservation(db2, result.lastInsertRowid);
+}
+function getObservation(db2, id) {
+  const row = db2.prepare("SELECT * FROM observations WHERE id = ?").get(id);
+  return row ?? null;
+}
+function getObservations(db2, entityId) {
+  return db2.prepare("SELECT * FROM observations WHERE entity_id = ? ORDER BY id DESC").all(entityId);
+}
+function deleteObservation(db2, id) {
+  db2.prepare("DELETE FROM observations WHERE id = ?").run(id);
+}
+function addRelation(db2, fromEntity, toEntity, relationType) {
+  const result = db2.prepare("INSERT INTO relations (from_entity, to_entity, relation_type) VALUES (?, ?, ?)").run(fromEntity, toEntity, relationType);
+  return getRelation(db2, result.lastInsertRowid);
+}
+function getRelation(db2, id) {
+  const row = db2.prepare("SELECT * FROM relations WHERE id = ?").get(id);
+  return row ?? null;
+}
+function getRelations(db2, entityId) {
+  return db2.prepare("SELECT * FROM relations WHERE from_entity = ? OR to_entity = ? ORDER BY created_at DESC").all(entityId, entityId);
+}
+function deleteRelation(db2, id) {
+  db2.prepare("DELETE FROM relations WHERE id = ?").run(id);
+}
+function getMemoryStats(db2) {
+  const entities = db2.prepare("SELECT COUNT(*) as count FROM entities").get();
+  const observations = db2.prepare("SELECT COUNT(*) as count FROM observations").get();
+  const relations = db2.prepare("SELECT COUNT(*) as count FROM relations").get();
+  return {
+    entityCount: entities.count,
+    observationCount: observations.count,
+    relationCount: relations.count
+  };
+}
+function createWorker(db2, input) {
+  if (input.isDefault) {
+    db2.prepare("UPDATE workers SET is_default = 0 WHERE is_default = 1").run();
+  }
+  const result = db2.prepare(
+    `INSERT INTO workers (name, role, system_prompt, description, model, is_default, room_id, agent_state)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(input.name, input.role ?? null, input.systemPrompt, input.description ?? null, input.model ?? null, input.isDefault ? 1 : 0, input.roomId ?? null, input.agentState ?? "idle");
+  return getWorker(db2, result.lastInsertRowid);
+}
+function getWorker(db2, id) {
+  const row = db2.prepare("SELECT * FROM workers WHERE id = ?").get(id);
+  return row ? mapWorkerRow(row) : null;
+}
+function listWorkers(db2) {
+  const rows = db2.prepare("SELECT * FROM workers ORDER BY is_default DESC, name ASC").all();
+  return rows.map(mapWorkerRow);
+}
+function updateWorker(db2, id, updates) {
+  if (updates.isDefault === true) {
+    db2.prepare("UPDATE workers SET is_default = 0 WHERE is_default = 1").run();
+  }
+  const fieldMap = {
+    name: "name",
+    role: "role",
+    systemPrompt: "system_prompt",
+    description: "description",
+    model: "model",
+    isDefault: "is_default",
+    roomId: "room_id",
+    agentState: "agent_state"
+  };
+  const fields = [];
+  const values = [];
+  for (const [key, value] of Object.entries(updates)) {
+    const dbField = fieldMap[key];
+    if (dbField) {
+      fields.push(`${dbField} = ?`);
+      values.push(key === "isDefault" ? value ? 1 : 0 : value);
+    }
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE workers SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteWorker(db2, id) {
+  db2.prepare("DELETE FROM workers WHERE id = ?").run(id);
+}
+function refreshWorkerTaskCount(db2, workerId) {
+  const row = db2.prepare("SELECT COUNT(*) as count FROM tasks WHERE worker_id = ?").get(workerId);
+  db2.prepare("UPDATE workers SET task_count = ? WHERE id = ?").run(row.count, workerId);
+}
+function mapWorkerRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    role: row.role ?? null,
+    systemPrompt: row.system_prompt,
+    description: row.description,
+    model: row.model,
+    isDefault: row.is_default === 1,
+    taskCount: row.task_count ?? 0,
+    roomId: row.room_id ?? null,
+    agentState: row.agent_state ?? "idle",
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function createTask(db2, input) {
+  const result = db2.prepare(
+    `INSERT INTO tasks (name, description, prompt, cron_expression, trigger_type, trigger_config, scheduled_at, executor, max_runs, worker_id, session_continuity, timeout_minutes, max_turns, allowed_tools, disallowed_tools, nudge_mode)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input.name,
+    input.description ?? null,
+    input.prompt,
+    input.cronExpression ?? null,
+    input.triggerType ?? "cron",
+    input.triggerConfig ?? null,
+    input.scheduledAt ?? null,
+    input.executor ?? "claude_code",
+    input.maxRuns ?? null,
+    input.workerId ?? null,
+    input.sessionContinuity ? 1 : 0,
+    input.timeoutMinutes ?? null,
+    input.maxTurns ?? null,
+    input.allowedTools ?? null,
+    input.disallowedTools ?? null,
+    input.nudgeMode ?? "always"
+  );
+  const task = getTask(db2, result.lastInsertRowid);
+  if (input.workerId) refreshWorkerTaskCount(db2, input.workerId);
+  return task;
+}
+function getTask(db2, id) {
+  const row = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  return row ? mapTaskRow(row) : null;
+}
+function listTasks(db2, status) {
+  const rows = status ? db2.prepare("SELECT * FROM tasks WHERE status = ? ORDER BY created_at DESC").all(status) : db2.prepare("SELECT * FROM tasks ORDER BY created_at DESC").all();
+  return rows.map(mapTaskRow);
+}
+function updateTask(db2, id, updates) {
+  const fieldMap = {
+    name: "name",
+    description: "description",
+    prompt: "prompt",
+    cronExpression: "cron_expression",
+    triggerType: "trigger_type",
+    triggerConfig: "trigger_config",
+    scheduledAt: "scheduled_at",
+    executor: "executor",
+    status: "status",
+    lastRun: "last_run",
+    lastResult: "last_result",
+    errorCount: "error_count",
+    maxRuns: "max_runs",
+    runCount: "run_count",
+    memoryEntityId: "memory_entity_id",
+    workerId: "worker_id",
+    sessionContinuity: "session_continuity",
+    sessionId: "session_id",
+    timeoutMinutes: "timeout_minutes",
+    maxTurns: "max_turns",
+    allowedTools: "allowed_tools",
+    disallowedTools: "disallowed_tools",
+    nudgeMode: "nudge_mode",
+    learnedContext: "learned_context"
+  };
+  const fields = [];
+  const values = [];
+  for (const [key, value] of Object.entries(updates)) {
+    const dbField = fieldMap[key];
+    if (dbField) {
+      fields.push(`${dbField} = ?`);
+      values.push(key === "sessionContinuity" ? value ? 1 : 0 : value);
+    }
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteTask(db2, id) {
+  const task = getTask(db2, id);
+  db2.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+  if (task?.workerId) refreshWorkerTaskCount(db2, task.workerId);
+}
+function pauseTask(db2, id) {
+  updateTask(db2, id, { status: "paused" });
+}
+function resumeTask(db2, id) {
+  updateTask(db2, id, { status: "active" });
+}
+function createWatch(db2, path2, description, actionPrompt) {
+  const result = db2.prepare("INSERT INTO watches (path, description, action_prompt) VALUES (?, ?, ?)").run(path2, description ?? null, actionPrompt ?? null);
+  return getWatch(db2, result.lastInsertRowid);
+}
+function getWatch(db2, id) {
+  const row = db2.prepare("SELECT * FROM watches WHERE id = ?").get(id);
+  return row ? mapWatchRow(row) : null;
+}
+function listWatches(db2, status) {
+  const rows = status ? db2.prepare("SELECT * FROM watches WHERE status = ? ORDER BY created_at DESC").all(status) : db2.prepare("SELECT * FROM watches ORDER BY created_at DESC").all();
+  return rows.map(mapWatchRow);
+}
+function deleteWatch(db2, id) {
+  db2.prepare("DELETE FROM watches WHERE id = ?").run(id);
+}
+function pauseWatch(db2, id) {
+  db2.prepare("UPDATE watches SET status = 'paused' WHERE id = ?").run(id);
+}
+function resumeWatch(db2, id) {
+  db2.prepare("UPDATE watches SET status = 'active' WHERE id = ?").run(id);
+}
+function getSetting(db2, key) {
+  const row = db2.prepare("SELECT value FROM settings WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setSetting(db2, key, value) {
+  db2.prepare(
+    `INSERT INTO settings (key, value, updated_at) VALUES (?, ?, datetime('now','localtime'))
+       ON CONFLICT(key) DO UPDATE SET value = ?, updated_at = datetime('now','localtime')`
+  ).run(key, value, value);
+}
+function getAllSettings(db2) {
+  const rows = db2.prepare("SELECT key, value FROM settings").all();
+  const result = {};
+  for (const row of rows) result[row.key] = row.value;
+  return result;
+}
+function createTaskRun(db2, taskId) {
+  const result = db2.prepare("INSERT INTO task_runs (task_id, started_at) VALUES (?, datetime('now','localtime'))").run(taskId);
+  return getTaskRun(db2, result.lastInsertRowid);
+}
+function getTaskRun(db2, id) {
+  const row = db2.prepare("SELECT * FROM task_runs WHERE id = ?").get(id);
+  return row ? mapTaskRunRow(row) : null;
+}
+function getTaskRuns(db2, taskId, limit = 20) {
+  const rows = db2.prepare("SELECT * FROM task_runs WHERE task_id = ? ORDER BY started_at DESC LIMIT ?").all(taskId, limit);
+  return rows.map(mapTaskRunRow);
+}
+function listAllRuns(db2, limit = 20) {
+  const rows = db2.prepare("SELECT * FROM task_runs ORDER BY started_at DESC LIMIT ?").all(limit);
+  return rows.map(mapTaskRunRow);
+}
+function cleanupAllRunningRuns(db2) {
+  const result = db2.prepare(`
+    UPDATE task_runs SET
+      status = 'failed',
+      finished_at = datetime('now','localtime'),
+      error_message = 'Stale run: process restarted'
+    WHERE status = 'running'
+  `).run();
+  return result.changes;
+}
+var PRUNE_INTERVAL_MS = 60 * 6e4;
+function getConsoleLogs(db2, runId, afterSeq = 0, limit = 100) {
+  const rows = db2.prepare("SELECT * FROM console_logs WHERE run_id = ? AND seq > ? ORDER BY seq ASC LIMIT ?").all(runId, afterSeq, limit);
+  return rows.map(mapConsoleLogRow);
+}
+function mapConsoleLogRow(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    seq: row.seq,
+    entryType: row.entry_type,
+    content: row.content,
+    createdAt: row.created_at
+  };
+}
+function mapTaskRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    prompt: row.prompt,
+    cronExpression: row.cron_expression,
+    triggerType: row.trigger_type,
+    triggerConfig: row.trigger_config,
+    scheduledAt: row.scheduled_at,
+    executor: row.executor,
+    status: row.status,
+    lastRun: row.last_run,
+    lastResult: row.last_result,
+    errorCount: row.error_count,
+    maxRuns: row.max_runs,
+    runCount: row.run_count ?? 0,
+    memoryEntityId: row.memory_entity_id,
+    workerId: row.worker_id,
+    sessionContinuity: row.session_continuity === 1,
+    sessionId: row.session_id,
+    timeoutMinutes: row.timeout_minutes,
+    maxTurns: row.max_turns,
+    allowedTools: row.allowed_tools,
+    disallowedTools: row.disallowed_tools,
+    nudgeMode: row.nudge_mode ?? "always",
+    learnedContext: row.learned_context,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function mapWatchRow(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    description: row.description,
+    actionPrompt: row.action_prompt,
+    status: row.status,
+    lastTriggered: row.last_triggered,
+    triggerCount: row.trigger_count,
+    createdAt: row.created_at
+  };
+}
+function mapTaskRunRow(row) {
+  return {
+    id: row.id,
+    taskId: row.task_id,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    status: row.status,
+    result: row.result,
+    resultFile: row.result_file,
+    errorMessage: row.error_message,
+    durationMs: row.duration_ms,
+    progress: row.progress,
+    progressMessage: row.progress_message,
+    sessionId: row.session_id
+  };
+}
+function clearTaskSession(db2, taskId) {
+  db2.prepare("UPDATE tasks SET session_id = NULL, updated_at = datetime('now','localtime') WHERE id = ?").run(taskId);
+}
+function mapRoomRow(row) {
+  let config = { ...DEFAULT_ROOM_CONFIG };
+  try {
+    if (row.config) config = { ...DEFAULT_ROOM_CONFIG, ...JSON.parse(row.config) };
+  } catch {
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    queenWorkerId: row.queen_worker_id ?? null,
+    goal: row.goal ?? null,
+    status: row.status,
+    visibility: row.visibility,
+    config,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function createRoom(db2, name, goal, config) {
+  const configJson = config ? JSON.stringify({ ...DEFAULT_ROOM_CONFIG, ...config }) : JSON.stringify(DEFAULT_ROOM_CONFIG);
+  const result = db2.prepare("INSERT INTO rooms (name, goal, config) VALUES (?, ?, ?)").run(name, goal ?? null, configJson);
+  return getRoom(db2, result.lastInsertRowid);
+}
+function getRoom(db2, id) {
+  const row = db2.prepare("SELECT * FROM rooms WHERE id = ?").get(id);
+  return row ? mapRoomRow(row) : null;
+}
+function listRooms(db2, status) {
+  if (status) {
+    const rows2 = db2.prepare("SELECT * FROM rooms WHERE status = ? ORDER BY created_at DESC").all(status);
+    return rows2.map(mapRoomRow);
+  }
+  const rows = db2.prepare("SELECT * FROM rooms ORDER BY created_at DESC").all();
+  return rows.map(mapRoomRow);
+}
+function updateRoom(db2, id, updates) {
+  const fieldMap = {
+    name: "name",
+    queenWorkerId: "queen_worker_id",
+    goal: "goal",
+    status: "status",
+    visibility: "visibility",
+    config: "config"
+  };
+  const fields = [];
+  const values = [];
+  for (const [key, value] of Object.entries(updates)) {
+    const dbField = fieldMap[key];
+    if (dbField) {
+      fields.push(`${dbField} = ?`);
+      values.push(key === "config" ? JSON.stringify(value) : value);
+    }
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE rooms SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteRoom(db2, id) {
+  db2.prepare("DELETE FROM rooms WHERE id = ?").run(id);
+}
+function mapRoomActivityRow(row) {
+  return {
+    id: row.id,
+    roomId: row.room_id,
+    eventType: row.event_type,
+    actorId: row.actor_id ?? null,
+    summary: row.summary,
+    details: row.details ?? null,
+    isPublic: row.is_public === 1,
+    createdAt: row.created_at
+  };
+}
+function logRoomActivity(db2, roomId, eventType, summary, details, actorId, isPublic = true) {
+  const result = db2.prepare("INSERT INTO room_activity (room_id, event_type, actor_id, summary, details, is_public) VALUES (?, ?, ?, ?, ?, ?)").run(roomId, eventType, actorId ?? null, summary, details ?? null, isPublic ? 1 : 0);
+  const row = db2.prepare("SELECT * FROM room_activity WHERE id = ?").get(result.lastInsertRowid);
+  return mapRoomActivityRow(row);
+}
+function getRoomActivity(db2, roomId, limit = 50, eventTypes) {
+  if (eventTypes && eventTypes.length > 0) {
+    const placeholders = eventTypes.map(() => "?").join(", ");
+    const rows2 = db2.prepare(`SELECT * FROM room_activity WHERE room_id = ? AND event_type IN (${placeholders}) ORDER BY created_at DESC LIMIT ?`).all(roomId, ...eventTypes, limit);
+    return rows2.map(mapRoomActivityRow);
+  }
+  const rows = db2.prepare("SELECT * FROM room_activity WHERE room_id = ? ORDER BY created_at DESC LIMIT ?").all(roomId, limit);
+  return rows.map(mapRoomActivityRow);
+}
+function mapDecisionRow(row) {
+  return {
+    id: row.id,
+    roomId: row.room_id,
+    proposerId: row.proposer_id ?? null,
+    proposal: row.proposal,
+    decisionType: row.decision_type,
+    status: row.status,
+    result: row.result ?? null,
+    threshold: row.threshold,
+    timeoutAt: row.timeout_at ?? null,
+    createdAt: row.created_at,
+    resolvedAt: row.resolved_at ?? null
+  };
+}
+function createDecision(db2, roomId, proposerId, proposal, decisionType, threshold = "majority", timeoutAt) {
+  const result = db2.prepare("INSERT INTO quorum_decisions (room_id, proposer_id, proposal, decision_type, threshold, timeout_at) VALUES (?, ?, ?, ?, ?, ?)").run(roomId, proposerId, proposal, decisionType, threshold, timeoutAt ?? null);
+  return getDecision(db2, result.lastInsertRowid);
+}
+function getDecision(db2, id) {
+  const row = db2.prepare("SELECT * FROM quorum_decisions WHERE id = ?").get(id);
+  return row ? mapDecisionRow(row) : null;
+}
+function listDecisions(db2, roomId, status) {
+  if (status) {
+    const rows2 = db2.prepare("SELECT * FROM quorum_decisions WHERE room_id = ? AND status = ? ORDER BY created_at DESC").all(roomId, status);
+    return rows2.map(mapDecisionRow);
+  }
+  const rows = db2.prepare("SELECT * FROM quorum_decisions WHERE room_id = ? ORDER BY created_at DESC").all(roomId);
+  return rows.map(mapDecisionRow);
+}
+function resolveDecision(db2, id, status, result) {
+  db2.prepare("UPDATE quorum_decisions SET status = ?, result = ?, resolved_at = datetime('now','localtime') WHERE id = ?").run(status, result ?? null, id);
+}
+function mapVoteRow(row) {
+  return {
+    id: row.id,
+    decisionId: row.decision_id,
+    workerId: row.worker_id,
+    vote: row.vote,
+    reasoning: row.reasoning ?? null,
+    createdAt: row.created_at
+  };
+}
+function castVote(db2, decisionId, workerId, vote, reasoning) {
+  const result = db2.prepare("INSERT INTO quorum_votes (decision_id, worker_id, vote, reasoning) VALUES (?, ?, ?, ?)").run(decisionId, workerId, vote, reasoning ?? null);
+  const row = db2.prepare("SELECT * FROM quorum_votes WHERE id = ?").get(result.lastInsertRowid);
+  return mapVoteRow(row);
+}
+function getVotes(db2, decisionId) {
+  const rows = db2.prepare("SELECT * FROM quorum_votes WHERE decision_id = ? ORDER BY created_at ASC").all(decisionId);
+  return rows.map(mapVoteRow);
+}
+function mapGoalRow(row) {
+  return {
+    id: row.id,
+    roomId: row.room_id,
+    description: row.description,
+    status: row.status,
+    parentGoalId: row.parent_goal_id ?? null,
+    assignedWorkerId: row.assigned_worker_id ?? null,
+    progress: row.progress ?? 0,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function createGoal(db2, roomId, description, parentGoalId, assignedWorkerId) {
+  const result = db2.prepare("INSERT INTO goals (room_id, description, parent_goal_id, assigned_worker_id) VALUES (?, ?, ?, ?)").run(roomId, description, parentGoalId ?? null, assignedWorkerId ?? null);
+  return getGoal(db2, result.lastInsertRowid);
+}
+function getGoal(db2, id) {
+  const row = db2.prepare("SELECT * FROM goals WHERE id = ?").get(id);
+  return row ? mapGoalRow(row) : null;
+}
+function listGoals(db2, roomId, status) {
+  if (status) {
+    const rows2 = db2.prepare("SELECT * FROM goals WHERE room_id = ? AND status = ? ORDER BY created_at ASC").all(roomId, status);
+    return rows2.map(mapGoalRow);
+  }
+  const rows = db2.prepare("SELECT * FROM goals WHERE room_id = ? ORDER BY created_at ASC").all(roomId);
+  return rows.map(mapGoalRow);
+}
+function getSubGoals(db2, parentGoalId) {
+  const rows = db2.prepare("SELECT * FROM goals WHERE parent_goal_id = ? ORDER BY created_at ASC").all(parentGoalId);
+  return rows.map(mapGoalRow);
+}
+function updateGoal(db2, id, updates) {
+  const fieldMap = {
+    description: "description",
+    status: "status",
+    assignedWorkerId: "assigned_worker_id",
+    progress: "progress"
+  };
+  const fields = [];
+  const values = [];
+  for (const [key, value] of Object.entries(updates)) {
+    const dbField = fieldMap[key];
+    if (dbField) {
+      fields.push(`${dbField} = ?`);
+      values.push(value);
+    }
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE goals SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteGoal(db2, id) {
+  db2.prepare("DELETE FROM goals WHERE id = ?").run(id);
+}
+function mapGoalUpdateRow(row) {
+  return {
+    id: row.id,
+    goalId: row.goal_id,
+    workerId: row.worker_id ?? null,
+    observation: row.observation,
+    metricValue: row.metric_value ?? null,
+    createdAt: row.created_at
+  };
+}
+function logGoalUpdate(db2, goalId, observation, metricValue, workerId) {
+  const result = db2.prepare("INSERT INTO goal_updates (goal_id, worker_id, observation, metric_value) VALUES (?, ?, ?, ?)").run(goalId, workerId ?? null, observation, metricValue ?? null);
+  const row = db2.prepare("SELECT * FROM goal_updates WHERE id = ?").get(result.lastInsertRowid);
+  return mapGoalUpdateRow(row);
+}
+function getGoalUpdates(db2, goalId, limit = 50) {
+  const rows = db2.prepare("SELECT * FROM goal_updates WHERE goal_id = ? ORDER BY created_at DESC LIMIT ?").all(goalId, limit);
+  return rows.map(mapGoalUpdateRow);
+}
+function mapSkillRow(row) {
+  let activationContext = null;
+  try {
+    if (row.activation_context) activationContext = JSON.parse(row.activation_context);
+  } catch {
+  }
+  return {
+    id: row.id,
+    roomId: row.room_id ?? null,
+    name: row.name,
+    content: row.content,
+    activationContext,
+    autoActivate: row.auto_activate === 1,
+    agentCreated: row.agent_created === 1,
+    createdByWorkerId: row.created_by_worker_id ?? null,
+    version: row.version ?? 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function createSkill(db2, roomId, name, content, opts) {
+  const result = db2.prepare("INSERT INTO skills (room_id, name, content, activation_context, auto_activate, agent_created, created_by_worker_id) VALUES (?, ?, ?, ?, ?, ?, ?)").run(
+    roomId,
+    name,
+    content,
+    opts?.activationContext ? JSON.stringify(opts.activationContext) : null,
+    opts?.autoActivate ? 1 : 0,
+    opts?.agentCreated ? 1 : 0,
+    opts?.createdByWorkerId ?? null
+  );
+  return getSkill(db2, result.lastInsertRowid);
+}
+function getSkill(db2, id) {
+  const row = db2.prepare("SELECT * FROM skills WHERE id = ?").get(id);
+  return row ? mapSkillRow(row) : null;
+}
+function listSkills(db2, roomId) {
+  if (roomId != null) {
+    const rows2 = db2.prepare("SELECT * FROM skills WHERE room_id = ? ORDER BY name ASC").all(roomId);
+    return rows2.map(mapSkillRow);
+  }
+  const rows = db2.prepare("SELECT * FROM skills ORDER BY name ASC").all();
+  return rows.map(mapSkillRow);
+}
+function updateSkill(db2, id, updates) {
+  const fields = [];
+  const values = [];
+  if (updates.name !== void 0) {
+    fields.push("name = ?");
+    values.push(updates.name);
+  }
+  if (updates.content !== void 0) {
+    fields.push("content = ?");
+    values.push(updates.content);
+  }
+  if (updates.activationContext !== void 0) {
+    fields.push("activation_context = ?");
+    values.push(updates.activationContext ? JSON.stringify(updates.activationContext) : null);
+  }
+  if (updates.autoActivate !== void 0) {
+    fields.push("auto_activate = ?");
+    values.push(updates.autoActivate ? 1 : 0);
+  }
+  if (updates.version !== void 0) {
+    fields.push("version = ?");
+    values.push(updates.version);
+  }
+  if (fields.length === 0) return;
+  fields.push("updated_at = datetime('now','localtime')");
+  values.push(id);
+  db2.prepare(`UPDATE skills SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+}
+function deleteSkill(db2, id) {
+  db2.prepare("DELETE FROM skills WHERE id = ?").run(id);
+}
+function mapSelfModRow(row) {
+  return {
+    id: row.id,
+    roomId: row.room_id ?? null,
+    workerId: row.worker_id ?? null,
+    filePath: row.file_path,
+    oldHash: row.old_hash ?? null,
+    newHash: row.new_hash ?? null,
+    reason: row.reason ?? null,
+    reversible: row.reversible === 1,
+    reverted: row.reverted === 1,
+    createdAt: row.created_at
+  };
+}
+function getSelfModHistory(db2, roomId, limit = 50) {
+  const rows = db2.prepare("SELECT * FROM self_mod_audit WHERE room_id = ? ORDER BY created_at DESC LIMIT ?").all(roomId, limit);
+  return rows.map(mapSelfModRow);
+}
+function mapEscalationRow(row) {
+  return {
+    id: row.id,
+    roomId: row.room_id,
+    fromAgentId: row.from_agent_id ?? null,
+    toAgentId: row.to_agent_id ?? null,
+    question: row.question,
+    answer: row.answer ?? null,
+    status: row.status,
+    createdAt: row.created_at,
+    resolvedAt: row.resolved_at ?? null
+  };
+}
+function createEscalation(db2, roomId, fromAgentId, question, toAgentId) {
+  const result = db2.prepare("INSERT INTO escalations (room_id, from_agent_id, to_agent_id, question) VALUES (?, ?, ?, ?)").run(roomId, fromAgentId, toAgentId ?? null, question);
+  return getEscalation(db2, result.lastInsertRowid);
+}
+function getEscalation(db2, id) {
+  const row = db2.prepare("SELECT * FROM escalations WHERE id = ?").get(id);
+  return row ? mapEscalationRow(row) : null;
+}
+function getPendingEscalations(db2, roomId, toAgentId) {
+  if (toAgentId != null) {
+    const rows2 = db2.prepare("SELECT * FROM escalations WHERE room_id = ? AND status = 'pending' AND (to_agent_id = ? OR to_agent_id IS NULL) ORDER BY created_at ASC").all(roomId, toAgentId);
+    return rows2.map(mapEscalationRow);
+  }
+  const rows = db2.prepare("SELECT * FROM escalations WHERE room_id = ? AND status = 'pending' ORDER BY created_at ASC").all(roomId);
+  return rows.map(mapEscalationRow);
+}
+function resolveEscalation(db2, id, answer) {
+  db2.prepare("UPDATE escalations SET answer = ?, status = 'resolved', resolved_at = datetime('now','localtime') WHERE id = ?").run(answer, id);
+}
+function listRoomWorkers(db2, roomId) {
+  const rows = db2.prepare("SELECT * FROM workers WHERE room_id = ? ORDER BY name ASC").all(roomId);
+  return rows.map(mapWorkerRow);
+}
+function updateAgentState(db2, workerId, state) {
+  db2.prepare("UPDATE workers SET agent_state = ?, updated_at = datetime('now','localtime') WHERE id = ?").run(state, workerId);
+}
+
+// src/shared/goals.ts
+function setRoomObjective(db2, roomId, description) {
+  return createGoal(db2, roomId, description);
+}
+
+// src/shared/room.ts
+var DEFAULT_QUEEN_SYSTEM_PROMPT = `You are the Queen agent of this Room \u2014 the strategic coordinator.
+Your role is to pursue the room's objectives by:
+- Decomposing goals into actionable sub-goals
+- Creating and delegating to worker agents
+- Proposing decisions to the quorum
+- Self-improving your strategies and skills based on results
+- Managing resources efficiently
+
+You have access to all room MCP tools. Use them to manage goals, workers, skills, and decisions.`;
+function createRoom2(db2, input) {
+  const config = { ...DEFAULT_ROOM_CONFIG, ...input.config };
+  const room = createRoom(db2, input.name, input.goal, config);
+  const queen = createWorker(db2, {
+    name: `${input.name} Queen`,
+    systemPrompt: input.queenSystemPrompt ?? DEFAULT_QUEEN_SYSTEM_PROMPT,
+    roomId: room.id,
+    agentState: "idle"
+  });
+  updateRoom(db2, room.id, { queenWorkerId: queen.id });
+  let rootGoal = null;
+  if (input.goal) {
+    rootGoal = setRoomObjective(db2, room.id, input.goal);
+  }
+  logRoomActivity(
+    db2,
+    room.id,
+    "system",
+    `Room "${input.name}" created${input.goal ? ` with objective: ${input.goal}` : ""}`,
+    void 0,
+    queen.id
+  );
+  return {
+    room: getRoom(db2, room.id),
+    queen,
+    rootGoal
+  };
+}
+function pauseRoom(db2, roomId) {
+  const room = getRoom(db2, roomId);
+  if (!room) throw new Error(`Room ${roomId} not found`);
+  updateRoom(db2, roomId, { status: "paused" });
+  const workers = listRoomWorkers(db2, roomId);
+  for (const w of workers) {
+    updateAgentState(db2, w.id, "idle");
+  }
+  logRoomActivity(db2, roomId, "system", "Room paused");
+}
+function restartRoom(db2, roomId, newGoal) {
+  const room = getRoom(db2, roomId);
+  if (!room) throw new Error(`Room ${roomId} not found`);
+  db2.prepare("DELETE FROM goals WHERE room_id = ?").run(roomId);
+  db2.prepare("DELETE FROM quorum_decisions WHERE room_id = ?").run(roomId);
+  db2.prepare("DELETE FROM escalations WHERE room_id = ?").run(roomId);
+  const workers = listRoomWorkers(db2, roomId);
+  for (const w of workers) {
+    updateAgentState(db2, w.id, "idle");
+  }
+  updateRoom(db2, roomId, { status: "active", goal: newGoal ?? room.goal });
+  if (newGoal) {
+    setRoomObjective(db2, roomId, newGoal);
+  }
+  logRoomActivity(
+    db2,
+    roomId,
+    "system",
+    `Room restarted${newGoal ? ` with new objective: ${newGoal}` : ""}`
+  );
+}
+function deleteRoom2(db2, roomId) {
+  const room = getRoom(db2, roomId);
+  if (!room) throw new Error(`Room ${roomId} not found`);
+  const workers = listRoomWorkers(db2, roomId);
+  for (const w of workers) {
+    deleteWorker(db2, w.id);
+  }
+  deleteRoom(db2, roomId);
+}
+function getRoomStatus(db2, roomId) {
+  const room = getRoom(db2, roomId);
+  if (!room) throw new Error(`Room ${roomId} not found`);
+  const workers = listRoomWorkers(db2, roomId);
+  const activeGoals = listGoals(db2, roomId).filter(
+    (g) => g.status === "active" || g.status === "in_progress"
+  );
+  const pendingDecisions = listDecisions(db2, roomId, "voting").length;
+  return { room, workers, activeGoals, pendingDecisions };
+}
+
+// src/server/event-bus.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  wildcardHandlers = /* @__PURE__ */ new Set();
+  emit(channel, type, data) {
+    const event = {
+      type,
+      channel,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const channelHandlers = this.handlers.get(channel);
+    if (channelHandlers) {
+      for (const handler of channelHandlers) handler(event);
+    }
+    for (const handler of this.wildcardHandlers) handler(event);
+  }
+  on(channel, handler) {
+    let set = this.handlers.get(channel);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(channel, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+      if (set.size === 0) this.handlers.delete(channel);
+    };
+  }
+  onAny(handler) {
+    this.wildcardHandlers.add(handler);
+    return () => {
+      this.wildcardHandlers.delete(handler);
+    };
+  }
+  /** Remove all handlers (useful for tests) */
+  clear() {
+    this.handlers.clear();
+    this.wildcardHandlers.clear();
+  }
+};
+var eventBus = new EventBus();
+
+// src/server/routes/rooms.ts
+function registerRoomRoutes(router) {
+  router.post("/api/rooms", (ctx) => {
+    const { name, goal, queenSystemPrompt, config } = ctx.body || {};
+    if (!name || typeof name !== "string") return { status: 400, error: "name is required" };
+    const result = createRoom2(ctx.db, {
+      name,
+      goal,
+      queenSystemPrompt,
+      config
+    });
+    eventBus.emit(`room:${result.room.id}`, "room:created", result.room);
+    return { status: 201, data: result };
+  });
+  router.get("/api/rooms", (ctx) => {
+    const rooms = listRooms(ctx.db, ctx.query.status);
+    return { data: rooms };
+  });
+  router.get("/api/rooms/:id", (ctx) => {
+    const room = getRoom(ctx.db, Number(ctx.params.id));
+    if (!room) return { status: 404, error: "Room not found" };
+    return { data: room };
+  });
+  router.get("/api/rooms/:id/status", (ctx) => {
+    try {
+      const status = getRoomStatus(ctx.db, Number(ctx.params.id));
+      return { data: status };
+    } catch (e) {
+      return { status: 404, error: e.message };
+    }
+  });
+  router.get("/api/rooms/:id/activity", (ctx) => {
+    const roomId = Number(ctx.params.id);
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const activity = getRoomActivity(ctx.db, roomId, limit);
+    return { data: activity };
+  });
+  router.post("/api/rooms/:id/pause", (ctx) => {
+    const roomId = Number(ctx.params.id);
+    try {
+      pauseRoom(ctx.db, roomId);
+      eventBus.emit(`room:${roomId}`, "room:paused", { roomId });
+      return { data: { ok: true } };
+    } catch (e) {
+      return { status: 404, error: e.message };
+    }
+  });
+  router.post("/api/rooms/:id/restart", (ctx) => {
+    const roomId = Number(ctx.params.id);
+    const { goal } = ctx.body || {};
+    try {
+      restartRoom(ctx.db, roomId, goal);
+      eventBus.emit(`room:${roomId}`, "room:restarted", { roomId });
+      return { data: { ok: true } };
+    } catch (e) {
+      return { status: 404, error: e.message };
+    }
+  });
+  router.delete("/api/rooms/:id", (ctx) => {
+    const roomId = Number(ctx.params.id);
+    try {
+      deleteRoom2(ctx.db, roomId);
+      eventBus.emit(`room:${roomId}`, "room:deleted", { roomId });
+      return { data: { ok: true } };
+    } catch (e) {
+      return { status: 404, error: e.message };
+    }
+  });
+}
+
+// src/server/routes/workers.ts
+function registerWorkerRoutes(router) {
+  router.post("/api/workers", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.name || typeof body.name !== "string") return { status: 400, error: "name is required" };
+    if (!body.systemPrompt || typeof body.systemPrompt !== "string") return { status: 400, error: "systemPrompt is required" };
+    const worker = createWorker(ctx.db, {
+      name: body.name,
+      systemPrompt: body.systemPrompt,
+      description: body.description,
+      role: body.role,
+      isDefault: body.isDefault,
+      roomId: body.roomId,
+      agentState: body.agentState
+    });
+    eventBus.emit("workers", "worker:created", worker);
+    return { status: 201, data: worker };
+  });
+  router.get("/api/workers", (ctx) => {
+    const workers = listWorkers(ctx.db);
+    return { data: workers };
+  });
+  router.get("/api/workers/:id", (ctx) => {
+    const worker = getWorker(ctx.db, Number(ctx.params.id));
+    if (!worker) return { status: 404, error: "Worker not found" };
+    return { data: worker };
+  });
+  router.patch("/api/workers/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const worker = getWorker(ctx.db, id);
+    if (!worker) return { status: 404, error: "Worker not found" };
+    const body = ctx.body || {};
+    updateWorker(ctx.db, id, body);
+    const updated = getWorker(ctx.db, id);
+    eventBus.emit("workers", "worker:updated", updated);
+    return { data: updated };
+  });
+  router.delete("/api/workers/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const worker = getWorker(ctx.db, id);
+    if (!worker) return { status: 404, error: "Worker not found" };
+    deleteWorker(ctx.db, id);
+    eventBus.emit("workers", "worker:deleted", { id });
+    return { data: { ok: true } };
+  });
+  router.get("/api/rooms/:roomId/workers", (ctx) => {
+    const workers = listRoomWorkers(ctx.db, Number(ctx.params.roomId));
+    return { data: workers };
+  });
+}
+
+// src/server/routes/goals.ts
+function registerGoalRoutes(router) {
+  router.post("/api/rooms/:roomId/goals", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const body = ctx.body || {};
+    if (!body.description || typeof body.description !== "string") {
+      return { status: 400, error: "description is required" };
+    }
+    const goal = createGoal(
+      ctx.db,
+      roomId,
+      body.description,
+      body.parentGoalId,
+      body.assignedWorkerId
+    );
+    eventBus.emit(`room:${roomId}`, "goal:created", goal);
+    return { status: 201, data: goal };
+  });
+  router.get("/api/rooms/:roomId/goals", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const goals = listGoals(ctx.db, roomId, ctx.query.status);
+    return { data: goals };
+  });
+  router.get("/api/goals/:id", (ctx) => {
+    const goal = getGoal(ctx.db, Number(ctx.params.id));
+    if (!goal) return { status: 404, error: "Goal not found" };
+    return { data: goal };
+  });
+  router.get("/api/goals/:id/subgoals", (ctx) => {
+    const subgoals = getSubGoals(ctx.db, Number(ctx.params.id));
+    return { data: subgoals };
+  });
+  router.patch("/api/goals/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const goal = getGoal(ctx.db, id);
+    if (!goal) return { status: 404, error: "Goal not found" };
+    const body = ctx.body || {};
+    updateGoal(ctx.db, id, body);
+    const updated = getGoal(ctx.db, id);
+    eventBus.emit(`room:${goal.roomId}`, "goal:updated", updated);
+    return { data: updated };
+  });
+  router.delete("/api/goals/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const goal = getGoal(ctx.db, id);
+    if (!goal) return { status: 404, error: "Goal not found" };
+    deleteGoal(ctx.db, id);
+    eventBus.emit(`room:${goal.roomId}`, "goal:deleted", { id });
+    return { data: { ok: true } };
+  });
+  router.post("/api/goals/:id/updates", (ctx) => {
+    const id = Number(ctx.params.id);
+    const goal = getGoal(ctx.db, id);
+    if (!goal) return { status: 404, error: "Goal not found" };
+    const body = ctx.body || {};
+    if (!body.observation || typeof body.observation !== "string") {
+      return { status: 400, error: "observation is required" };
+    }
+    const update = logGoalUpdate(
+      ctx.db,
+      id,
+      body.observation,
+      body.metricValue,
+      body.workerId
+    );
+    eventBus.emit(`room:${goal.roomId}`, "goal:progress", {
+      goalId: id,
+      update
+    });
+    return { status: 201, data: update };
+  });
+  router.get("/api/goals/:id/updates", (ctx) => {
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const updates = getGoalUpdates(ctx.db, Number(ctx.params.id), limit);
+    return { data: updates };
+  });
+}
+
+// src/server/routes/decisions.ts
+function registerDecisionRoutes(router) {
+  router.post("/api/rooms/:roomId/decisions", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const body = ctx.body || {};
+    if (!body.proposerId || typeof body.proposerId !== "number") {
+      return { status: 400, error: "proposerId is required" };
+    }
+    if (!body.proposal || typeof body.proposal !== "string") {
+      return { status: 400, error: "proposal is required" };
+    }
+    if (!body.decisionType || typeof body.decisionType !== "string") {
+      return { status: 400, error: "decisionType is required" };
+    }
+    const decision = createDecision(
+      ctx.db,
+      roomId,
+      body.proposerId,
+      body.proposal,
+      body.decisionType,
+      body.threshold,
+      body.timeoutAt
+    );
+    eventBus.emit(`room:${roomId}`, "decision:created", decision);
+    return { status: 201, data: decision };
+  });
+  router.get("/api/rooms/:roomId/decisions", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const decisions = listDecisions(ctx.db, roomId, ctx.query.status);
+    return { data: decisions };
+  });
+  router.get("/api/decisions/:id", (ctx) => {
+    const decision = getDecision(ctx.db, Number(ctx.params.id));
+    if (!decision) return { status: 404, error: "Decision not found" };
+    return { data: decision };
+  });
+  router.post("/api/decisions/:id/resolve", (ctx) => {
+    const id = Number(ctx.params.id);
+    const decision = getDecision(ctx.db, id);
+    if (!decision) return { status: 404, error: "Decision not found" };
+    const body = ctx.body || {};
+    if (!body.status || typeof body.status !== "string") {
+      return { status: 400, error: "status is required (approved/rejected)" };
+    }
+    resolveDecision(ctx.db, id, body.status, body.result);
+    const updated = getDecision(ctx.db, id);
+    eventBus.emit(`room:${decision.roomId}`, "decision:resolved", updated);
+    return { data: updated };
+  });
+  router.post("/api/decisions/:id/vote", (ctx) => {
+    const id = Number(ctx.params.id);
+    const decision = getDecision(ctx.db, id);
+    if (!decision) return { status: 404, error: "Decision not found" };
+    const body = ctx.body || {};
+    if (!body.workerId || typeof body.workerId !== "number") {
+      return { status: 400, error: "workerId is required" };
+    }
+    if (!body.vote || typeof body.vote !== "string") {
+      return { status: 400, error: "vote is required (yes/no/abstain)" };
+    }
+    const vote = castVote(ctx.db, id, body.workerId, body.vote, body.reasoning);
+    eventBus.emit(`room:${decision.roomId}`, "decision:vote_cast", vote);
+    return { status: 201, data: vote };
+  });
+  router.get("/api/decisions/:id/votes", (ctx) => {
+    const votes = getVotes(ctx.db, Number(ctx.params.id));
+    return { data: votes };
+  });
+}
+
+// src/server/routes/tasks.ts
+function registerTaskRoutes(router) {
+  router.post("/api/tasks", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.prompt || typeof body.prompt !== "string") {
+      return { status: 400, error: "prompt is required" };
+    }
+    const task = createTask(ctx.db, {
+      name: body.name || body.prompt.slice(0, 50),
+      prompt: body.prompt,
+      description: body.description,
+      triggerType: body.triggerType || "manual",
+      cronExpression: body.cronExpression,
+      scheduledAt: body.scheduledAt,
+      workerId: body.workerId,
+      maxRuns: body.maxRuns,
+      maxTurns: body.maxTurns,
+      timeoutMinutes: body.timeout,
+      allowedTools: body.allowedTools,
+      disallowedTools: body.disallowedTools,
+      sessionContinuity: body.sessionContinuity
+    });
+    eventBus.emit("tasks", "task:created", task);
+    return { status: 201, data: task };
+  });
+  router.get("/api/tasks", (ctx) => {
+    const tasks = listTasks(ctx.db, ctx.query.status);
+    return { data: tasks };
+  });
+  router.get("/api/tasks/:id", (ctx) => {
+    const task = getTask(ctx.db, Number(ctx.params.id));
+    if (!task) return { status: 404, error: "Task not found" };
+    return { data: task };
+  });
+  router.patch("/api/tasks/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    const body = ctx.body || {};
+    updateTask(ctx.db, id, body);
+    const updated = getTask(ctx.db, id);
+    return { data: updated };
+  });
+  router.delete("/api/tasks/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    deleteTask(ctx.db, id);
+    return { data: { ok: true } };
+  });
+  router.post("/api/tasks/:id/pause", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    pauseTask(ctx.db, id);
+    return { data: { ok: true } };
+  });
+  router.post("/api/tasks/:id/resume", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    resumeTask(ctx.db, id);
+    return { data: { ok: true } };
+  });
+  router.get("/api/tasks/:id/runs", (ctx) => {
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const runs = getTaskRuns(ctx.db, Number(ctx.params.id), limit);
+    return { data: runs };
+  });
+  router.post("/api/tasks/:id/run", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    const run = createTaskRun(ctx.db, id);
+    eventBus.emit("runs", "run:created", { taskId: id, runId: run.id });
+    return { status: 201, data: { ok: true, runId: run.id } };
+  });
+  router.post("/api/tasks/:id/reset-session", (ctx) => {
+    const id = Number(ctx.params.id);
+    const task = getTask(ctx.db, id);
+    if (!task) return { status: 404, error: "Task not found" };
+    clearTaskSession(ctx.db, id);
+    return { data: { ok: true } };
+  });
+}
+
+// src/server/routes/runs.ts
+function registerRunRoutes(router) {
+  router.get("/api/runs", (ctx) => {
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const runs = listAllRuns(ctx.db, limit);
+    return { data: runs };
+  });
+  router.get("/api/runs/:id", (ctx) => {
+    const run = getTaskRun(ctx.db, Number(ctx.params.id));
+    if (!run) return { status: 404, error: "Run not found" };
+    return { data: run };
+  });
+  router.get("/api/runs/:id/logs", (ctx) => {
+    const afterSeq = ctx.query.afterSeq ? Number(ctx.query.afterSeq) : void 0;
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const logs = getConsoleLogs(ctx.db, Number(ctx.params.id), afterSeq, limit);
+    return { data: logs };
+  });
+}
+
+// src/server/routes/memory.ts
+function registerMemoryRoutes(router) {
+  router.post("/api/memory/entities", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.name || typeof body.name !== "string") {
+      return { status: 400, error: "name is required" };
+    }
+    const entity = createEntity(
+      ctx.db,
+      body.name,
+      body.type,
+      body.category
+    );
+    eventBus.emit("memory", "entity:created", entity);
+    return { status: 201, data: entity };
+  });
+  router.get("/api/memory/entities", (ctx) => {
+    const entities = listEntities(ctx.db, ctx.query.category);
+    return { data: entities };
+  });
+  router.get("/api/memory/entities/:id", (ctx) => {
+    const entity = getEntity(ctx.db, Number(ctx.params.id));
+    if (!entity) return { status: 404, error: "Entity not found" };
+    return { data: entity };
+  });
+  router.patch("/api/memory/entities/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const entity = getEntity(ctx.db, id);
+    if (!entity) return { status: 404, error: "Entity not found" };
+    const body = ctx.body || {};
+    updateEntity(ctx.db, id, body);
+    const updated = getEntity(ctx.db, id);
+    eventBus.emit("memory", "entity:updated", updated);
+    return { data: updated };
+  });
+  router.delete("/api/memory/entities/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const entity = getEntity(ctx.db, id);
+    if (!entity) return { status: 404, error: "Entity not found" };
+    deleteEntity(ctx.db, id);
+    eventBus.emit("memory", "entity:deleted", { id });
+    return { data: { ok: true } };
+  });
+  router.get("/api/memory/search", (ctx) => {
+    const q = ctx.query.q;
+    if (!q) return { status: 400, error: "q query parameter is required" };
+    const results = searchEntities(ctx.db, q);
+    return { data: results };
+  });
+  router.get("/api/memory/stats", (ctx) => {
+    const stats = getMemoryStats(ctx.db);
+    return { data: stats };
+  });
+  router.post("/api/memory/entities/:entityId/observations", (ctx) => {
+    const entityId = Number(ctx.params.entityId);
+    const body = ctx.body || {};
+    if (!body.content || typeof body.content !== "string") {
+      return { status: 400, error: "content is required" };
+    }
+    const observation = addObservation(
+      ctx.db,
+      entityId,
+      body.content,
+      body.source
+    );
+    eventBus.emit("memory", "observation:added", observation);
+    return { status: 201, data: observation };
+  });
+  router.get("/api/memory/entities/:entityId/observations", (ctx) => {
+    const observations = getObservations(ctx.db, Number(ctx.params.entityId));
+    return { data: observations };
+  });
+  router.delete("/api/memory/observations/:id", (ctx) => {
+    deleteObservation(ctx.db, Number(ctx.params.id));
+    return { data: { ok: true } };
+  });
+  router.post("/api/memory/relations", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.fromEntityId || typeof body.fromEntityId !== "number") {
+      return { status: 400, error: "fromEntityId is required" };
+    }
+    if (!body.toEntityId || typeof body.toEntityId !== "number") {
+      return { status: 400, error: "toEntityId is required" };
+    }
+    if (!body.relationType || typeof body.relationType !== "string") {
+      return { status: 400, error: "relationType is required" };
+    }
+    const relation = addRelation(
+      ctx.db,
+      body.fromEntityId,
+      body.toEntityId,
+      body.relationType
+    );
+    return { status: 201, data: relation };
+  });
+  router.get("/api/memory/entities/:entityId/relations", (ctx) => {
+    const relations = getRelations(ctx.db, Number(ctx.params.entityId));
+    return { data: relations };
+  });
+  router.delete("/api/memory/relations/:id", (ctx) => {
+    deleteRelation(ctx.db, Number(ctx.params.id));
+    return { data: { ok: true } };
+  });
+}
+
+// src/server/routes/skills.ts
+function registerSkillRoutes(router) {
+  router.post("/api/skills", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.roomId || typeof body.roomId !== "number") {
+      return { status: 400, error: "roomId is required" };
+    }
+    if (!body.name || typeof body.name !== "string") {
+      return { status: 400, error: "name is required" };
+    }
+    if (!body.content || typeof body.content !== "string") {
+      return { status: 400, error: "content is required" };
+    }
+    const skill = createSkill(ctx.db, body.roomId, body.name, body.content, {
+      autoActivate: body.autoActivate,
+      activationContext: body.activationContext,
+      agentCreated: body.agentCreated
+    });
+    eventBus.emit(`room:${body.roomId}`, "skill:created", skill);
+    return { status: 201, data: skill };
+  });
+  router.get("/api/skills", (ctx) => {
+    const roomId = ctx.query.roomId ? Number(ctx.query.roomId) : void 0;
+    const skills = listSkills(ctx.db, roomId);
+    return { data: skills };
+  });
+  router.get("/api/skills/:id", (ctx) => {
+    const skill = getSkill(ctx.db, Number(ctx.params.id));
+    if (!skill) return { status: 404, error: "Skill not found" };
+    return { data: skill };
+  });
+  router.patch("/api/skills/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const skill = getSkill(ctx.db, id);
+    if (!skill) return { status: 404, error: "Skill not found" };
+    const body = ctx.body || {};
+    updateSkill(ctx.db, id, body);
+    const updated = getSkill(ctx.db, id);
+    eventBus.emit(`room:${skill.roomId}`, "skill:updated", updated);
+    return { data: updated };
+  });
+  router.delete("/api/skills/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const skill = getSkill(ctx.db, id);
+    if (!skill) return { status: 404, error: "Skill not found" };
+    deleteSkill(ctx.db, id);
+    eventBus.emit(`room:${skill.roomId}`, "skill:deleted", { id });
+    return { data: { ok: true } };
+  });
+}
+
+// src/server/routes/watches.ts
+function registerWatchRoutes(router) {
+  router.post("/api/watches", (ctx) => {
+    const body = ctx.body || {};
+    if (!body.path || typeof body.path !== "string") {
+      return { status: 400, error: "path is required" };
+    }
+    const watch = createWatch(
+      ctx.db,
+      body.path,
+      body.description,
+      body.actionPrompt
+    );
+    return { status: 201, data: watch };
+  });
+  router.get("/api/watches", (ctx) => {
+    const watches = listWatches(ctx.db, ctx.query.status);
+    return { data: watches };
+  });
+  router.get("/api/watches/:id", (ctx) => {
+    const watch = getWatch(ctx.db, Number(ctx.params.id));
+    if (!watch) return { status: 404, error: "Watch not found" };
+    return { data: watch };
+  });
+  router.delete("/api/watches/:id", (ctx) => {
+    const id = Number(ctx.params.id);
+    const watch = getWatch(ctx.db, id);
+    if (!watch) return { status: 404, error: "Watch not found" };
+    deleteWatch(ctx.db, id);
+    return { data: { ok: true } };
+  });
+  router.post("/api/watches/:id/pause", (ctx) => {
+    const id = Number(ctx.params.id);
+    const watch = getWatch(ctx.db, id);
+    if (!watch) return { status: 404, error: "Watch not found" };
+    pauseWatch(ctx.db, id);
+    return { data: { ok: true } };
+  });
+  router.post("/api/watches/:id/resume", (ctx) => {
+    const id = Number(ctx.params.id);
+    const watch = getWatch(ctx.db, id);
+    if (!watch) return { status: 404, error: "Watch not found" };
+    resumeWatch(ctx.db, id);
+    return { data: { ok: true } };
+  });
+}
+
+// src/server/routes/settings.ts
+function registerSettingRoutes(router) {
+  router.get("/api/settings", (ctx) => {
+    const settings = getAllSettings(ctx.db);
+    return { data: settings };
+  });
+  router.get("/api/settings/:key", (ctx) => {
+    const value = getSetting(ctx.db, ctx.params.key);
+    return { data: { key: ctx.params.key, value } };
+  });
+  router.put("/api/settings/:key", (ctx) => {
+    const body = ctx.body || {};
+    if (body.value === void 0) {
+      return { status: 400, error: "value is required" };
+    }
+    setSetting(ctx.db, ctx.params.key, String(body.value));
+    return { data: { key: ctx.params.key, value: String(body.value) } };
+  });
+}
+
+// src/server/routes/escalations.ts
+function registerEscalationRoutes(router) {
+  router.post("/api/rooms/:roomId/escalations", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const body = ctx.body || {};
+    if (!body.fromAgentId || typeof body.fromAgentId !== "number") {
+      return { status: 400, error: "fromAgentId is required" };
+    }
+    if (!body.question || typeof body.question !== "string") {
+      return { status: 400, error: "question is required" };
+    }
+    const escalation = createEscalation(
+      ctx.db,
+      roomId,
+      body.fromAgentId,
+      body.question,
+      body.toAgentId
+    );
+    eventBus.emit(`room:${roomId}`, "escalation:created", escalation);
+    return { status: 201, data: escalation };
+  });
+  router.get("/api/rooms/:roomId/escalations", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const toAgentId = ctx.query.toAgentId ? Number(ctx.query.toAgentId) : void 0;
+    const escalations = getPendingEscalations(ctx.db, roomId, toAgentId);
+    return { data: escalations };
+  });
+  router.post("/api/escalations/:id/resolve", (ctx) => {
+    const id = Number(ctx.params.id);
+    const escalation = getEscalation(ctx.db, id);
+    if (!escalation) return { status: 404, error: "Escalation not found" };
+    const body = ctx.body || {};
+    if (!body.answer || typeof body.answer !== "string") {
+      return { status: 400, error: "answer is required" };
+    }
+    resolveEscalation(ctx.db, id, body.answer);
+    const updated = getEscalation(ctx.db, id);
+    eventBus.emit(`room:${escalation.roomId}`, "escalation:resolved", updated);
+    return { data: updated };
+  });
+}
+
+// src/server/routes/self-mod.ts
+function registerSelfModRoutes(router) {
+  router.get("/api/rooms/:roomId/self-mod", (ctx) => {
+    const roomId = Number(ctx.params.roomId);
+    const limit = ctx.query.limit ? Number(ctx.query.limit) : void 0;
+    const history = getSelfModHistory(ctx.db, roomId, limit);
+    return { data: history };
+  });
+}
+
+// src/server/routes/status.ts
+var import_node_child_process = require("node:child_process");
+
+// src/server/db.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_os = require("os");
+var import_path = require("path");
+var import_fs = require("fs");
+
+// src/shared/schema.ts
+var SCHEMA = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- Memory: entities, observations, relations
+CREATE TABLE IF NOT EXISTS entities (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'fact',
+    category TEXT,
+    embedded_at DATETIME,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_entities_category ON entities(category);
+CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+
+CREATE TABLE IF NOT EXISTS observations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    source TEXT NOT NULL DEFAULT 'claude',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_observations_entity_id ON observations(entity_id);
+
+CREATE TABLE IF NOT EXISTS relations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_entity INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+    to_entity INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+    relation_type TEXT NOT NULL,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity);
+CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+    name, content, category, content='entities', content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS entities_ai AFTER INSERT ON entities BEGIN
+    INSERT INTO memory_fts(rowid, name, content, category) VALUES (new.id, new.name, '', new.category);
+END;
+CREATE TRIGGER IF NOT EXISTS entities_ad AFTER DELETE ON entities BEGIN
+    INSERT INTO memory_fts(memory_fts, rowid, name, content, category) VALUES ('delete', old.id, old.name, '', old.category);
+END;
+CREATE TRIGGER IF NOT EXISTS entities_au AFTER UPDATE ON entities BEGIN
+    INSERT INTO memory_fts(memory_fts, rowid, name, content, category) VALUES ('delete', old.id, old.name, '', old.category);
+    INSERT INTO memory_fts(rowid, name, content, category) VALUES (new.id, new.name, '', new.category);
+END;
+
+-- Embeddings (semantic search)
+CREATE TABLE IF NOT EXISTS embeddings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+    source_type TEXT NOT NULL DEFAULT 'entity',
+    source_id INTEGER NOT NULL,
+    text_hash TEXT NOT NULL,
+    vector BLOB NOT NULL,
+    model TEXT NOT NULL DEFAULT 'all-MiniLM-L6-v2',
+    dimensions INTEGER NOT NULL DEFAULT 384,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_embeddings_entity_id ON embeddings(entity_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_embeddings_source ON embeddings(source_type, source_id, model);
+
+-- Workers
+CREATE TABLE IF NOT EXISTS workers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    role TEXT,
+    system_prompt TEXT NOT NULL,
+    description TEXT,
+    model TEXT,
+    is_default INTEGER NOT NULL DEFAULT 0,
+    task_count INTEGER NOT NULL DEFAULT 0,
+    room_id INTEGER,
+    agent_state TEXT NOT NULL DEFAULT 'idle',
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_workers_name ON workers(name);
+
+-- Tasks
+CREATE TABLE IF NOT EXISTS tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    description TEXT,
+    prompt TEXT NOT NULL,
+    cron_expression TEXT,
+    trigger_type TEXT NOT NULL DEFAULT 'cron',
+    trigger_config TEXT,
+    executor TEXT NOT NULL DEFAULT 'claude_code',
+    status TEXT NOT NULL DEFAULT 'active',
+    last_run DATETIME,
+    last_result TEXT,
+    error_count INTEGER NOT NULL DEFAULT 0,
+    scheduled_at DATETIME,
+    max_runs INTEGER,
+    run_count INTEGER NOT NULL DEFAULT 0,
+    memory_entity_id INTEGER REFERENCES entities(id) ON DELETE SET NULL,
+    worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    session_continuity INTEGER NOT NULL DEFAULT 0,
+    session_id TEXT,
+    timeout_minutes INTEGER,
+    max_turns INTEGER,
+    allowed_tools TEXT,
+    disallowed_tools TEXT,
+    nudge_mode TEXT NOT NULL DEFAULT 'always',
+    learned_context TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_scheduled_at ON tasks(scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_trigger_type ON tasks(trigger_type);
+
+-- Task runs
+CREATE TABLE IF NOT EXISTS task_runs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    started_at DATETIME DEFAULT (datetime('now','localtime')),
+    finished_at DATETIME,
+    status TEXT NOT NULL DEFAULT 'running',
+    result TEXT,
+    result_file TEXT,
+    error_message TEXT,
+    duration_ms INTEGER,
+    progress REAL,
+    progress_message TEXT,
+    session_id TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_task_runs_task_id ON task_runs(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_runs_started_at ON task_runs(started_at);
+CREATE INDEX IF NOT EXISTS idx_task_runs_status ON task_runs(status);
+
+-- Console logs
+CREATE TABLE IF NOT EXISTS console_logs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id INTEGER NOT NULL REFERENCES task_runs(id) ON DELETE CASCADE,
+    seq INTEGER NOT NULL,
+    entry_type TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_console_logs_run_seq ON console_logs(run_id, seq);
+
+-- File watchers
+CREATE TABLE IF NOT EXISTS watches (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    path TEXT NOT NULL,
+    description TEXT,
+    action_prompt TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    last_triggered DATETIME,
+    trigger_count INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+
+-- Settings
+CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT,
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+
+-- Rooms
+CREATE TABLE IF NOT EXISTS rooms (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    queen_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    goal TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    visibility TEXT NOT NULL DEFAULT 'private',
+    config TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_rooms_status ON rooms(status);
+
+-- Room activity
+CREATE TABLE IF NOT EXISTS room_activity (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    event_type TEXT NOT NULL,
+    actor_id INTEGER,
+    summary TEXT NOT NULL,
+    details TEXT,
+    is_public INTEGER NOT NULL DEFAULT 1,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_room_activity_room ON room_activity(room_id);
+CREATE INDEX IF NOT EXISTS idx_room_activity_type ON room_activity(event_type);
+
+-- Quorum decisions
+CREATE TABLE IF NOT EXISTS quorum_decisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    proposer_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    proposal TEXT NOT NULL,
+    decision_type TEXT NOT NULL DEFAULT 'low_impact',
+    status TEXT NOT NULL DEFAULT 'voting',
+    result TEXT,
+    threshold TEXT NOT NULL DEFAULT 'majority',
+    timeout_at DATETIME,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    resolved_at DATETIME
+);
+CREATE INDEX IF NOT EXISTS idx_quorum_decisions_room ON quorum_decisions(room_id);
+CREATE INDEX IF NOT EXISTS idx_quorum_decisions_status ON quorum_decisions(status);
+
+-- Quorum votes
+CREATE TABLE IF NOT EXISTS quorum_votes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    decision_id INTEGER NOT NULL REFERENCES quorum_decisions(id) ON DELETE CASCADE,
+    worker_id INTEGER NOT NULL REFERENCES workers(id) ON DELETE CASCADE,
+    vote TEXT NOT NULL,
+    reasoning TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    UNIQUE(decision_id, worker_id)
+);
+CREATE INDEX IF NOT EXISTS idx_quorum_votes_decision ON quorum_votes(decision_id);
+
+-- Goals
+CREATE TABLE IF NOT EXISTS goals (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    description TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active',
+    parent_goal_id INTEGER REFERENCES goals(id) ON DELETE CASCADE,
+    assigned_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    progress REAL NOT NULL DEFAULT 0.0,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_goals_room ON goals(room_id);
+CREATE INDEX IF NOT EXISTS idx_goals_parent ON goals(parent_goal_id);
+CREATE INDEX IF NOT EXISTS idx_goals_status ON goals(status);
+
+-- Goal updates
+CREATE TABLE IF NOT EXISTS goal_updates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    goal_id INTEGER NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+    worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    observation TEXT NOT NULL,
+    metric_value REAL,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_goal_updates_goal ON goal_updates(goal_id);
+
+-- Skills
+CREATE TABLE IF NOT EXISTS skills (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    content TEXT NOT NULL,
+    activation_context TEXT,
+    auto_activate INTEGER NOT NULL DEFAULT 0,
+    agent_created INTEGER NOT NULL DEFAULT 0,
+    created_by_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_skills_room ON skills(room_id);
+CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
+
+-- Self-modification audit
+CREATE TABLE IF NOT EXISTS self_mod_audit (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER REFERENCES rooms(id) ON DELETE CASCADE,
+    worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    file_path TEXT NOT NULL,
+    old_hash TEXT,
+    new_hash TEXT,
+    reason TEXT,
+    reversible INTEGER NOT NULL DEFAULT 1,
+    reverted INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_self_mod_audit_room ON self_mod_audit(room_id);
+
+-- Escalations
+CREATE TABLE IF NOT EXISTS escalations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    from_agent_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    to_agent_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    question TEXT NOT NULL,
+    answer TEXT,
+    status TEXT NOT NULL DEFAULT 'pending',
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    resolved_at DATETIME
+);
+CREATE INDEX IF NOT EXISTS idx_escalations_room ON escalations(room_id);
+CREATE INDEX IF NOT EXISTS idx_escalations_status ON escalations(status);
+
+-- Credentials
+CREATE TABLE IF NOT EXISTS credentials (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'other',
+    value_encrypted TEXT NOT NULL,
+    provided_by TEXT NOT NULL DEFAULT 'keeper',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_credentials_room ON credentials(room_id);
+
+-- Wallets
+CREATE TABLE IF NOT EXISTS wallets (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    address TEXT NOT NULL,
+    private_key_encrypted TEXT NOT NULL,
+    chain TEXT NOT NULL DEFAULT 'base',
+    erc8004_agent_id TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_wallets_room ON wallets(room_id);
+
+-- Wallet transactions
+CREATE TABLE IF NOT EXISTS wallet_transactions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    wallet_id INTEGER NOT NULL REFERENCES wallets(id) ON DELETE CASCADE,
+    type TEXT NOT NULL,
+    amount TEXT NOT NULL,
+    counterparty TEXT,
+    tx_hash TEXT,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'confirmed',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_wallet_tx_wallet ON wallet_transactions(wallet_id);
+
+-- Stations
+CREATE TABLE IF NOT EXISTS stations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    external_id TEXT,
+    tier TEXT NOT NULL,
+    region TEXT,
+    status TEXT NOT NULL DEFAULT 'provisioning',
+    monthly_cost REAL NOT NULL DEFAULT 0,
+    config TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_stations_room ON stations(room_id);
+
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY,
+    applied_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+INSERT OR IGNORE INTO schema_version (version) VALUES (1);
+INSERT OR IGNORE INTO schema_version (version) VALUES (2);
+INSERT OR IGNORE INTO schema_version (version) VALUES (3);
+INSERT OR IGNORE INTO schema_version (version) VALUES (4);
+INSERT OR IGNORE INTO schema_version (version) VALUES (5);
+INSERT OR IGNORE INTO schema_version (version) VALUES (6);
+INSERT OR IGNORE INTO schema_version (version) VALUES (7);
+INSERT OR IGNORE INTO schema_version (version) VALUES (8);
+INSERT OR IGNORE INTO schema_version (version) VALUES (9);
+INSERT OR IGNORE INTO schema_version (version) VALUES (10);
+INSERT OR IGNORE INTO schema_version (version) VALUES (11);
+INSERT OR IGNORE INTO schema_version (version) VALUES (12);
+INSERT OR IGNORE INTO schema_version (version) VALUES (13);
+INSERT OR IGNORE INTO schema_version (version) VALUES (14);
+INSERT OR IGNORE INTO schema_version (version) VALUES (15);
+INSERT OR IGNORE INTO schema_version (version) VALUES (16);
+INSERT OR IGNORE INTO schema_version (version) VALUES (17);
+INSERT OR IGNORE INTO schema_version (version) VALUES (18);
+INSERT OR IGNORE INTO schema_version (version) VALUES (19);
+INSERT OR IGNORE INTO schema_version (version) VALUES (20);
+`;
+var MIGRATIONS = [
+  {
+    version: 2,
+    label: "one-time tasks + progress tracking",
+    sql: `
+ALTER TABLE tasks ADD COLUMN scheduled_at DATETIME;
+ALTER TABLE task_runs ADD COLUMN progress REAL;
+ALTER TABLE task_runs ADD COLUMN progress_message TEXT;
+CREATE INDEX IF NOT EXISTS idx_tasks_scheduled_at ON tasks(scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_tasks_trigger_type ON tasks(trigger_type);
+INSERT OR IGNORE INTO schema_version (version) VALUES (2);`
+  },
+  {
+    version: 3,
+    label: "max runs",
+    sql: `
+ALTER TABLE tasks ADD COLUMN max_runs INTEGER;
+ALTER TABLE tasks ADD COLUMN run_count INTEGER NOT NULL DEFAULT 0;
+INSERT OR IGNORE INTO schema_version (version) VALUES (3);`
+  },
+  {
+    version: 4,
+    label: "memory-task integration",
+    sql: `
+ALTER TABLE tasks ADD COLUMN memory_entity_id INTEGER REFERENCES entities(id) ON DELETE SET NULL;
+INSERT OR IGNORE INTO schema_version (version) VALUES (4);`
+  },
+  {
+    version: 5,
+    label: "workers, sessions, embeddings",
+    sql: `
+CREATE TABLE IF NOT EXISTS workers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    system_prompt TEXT NOT NULL,
+    description TEXT,
+    model TEXT,
+    is_default INTEGER NOT NULL DEFAULT 0,
+    task_count INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_workers_name ON workers(name);
+ALTER TABLE tasks ADD COLUMN worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL;
+ALTER TABLE tasks ADD COLUMN session_continuity INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE tasks ADD COLUMN session_id TEXT;
+ALTER TABLE task_runs ADD COLUMN session_id TEXT;
+CREATE TABLE IF NOT EXISTS embeddings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+    source_type TEXT NOT NULL DEFAULT 'entity',
+    source_id INTEGER NOT NULL,
+    text_hash TEXT NOT NULL,
+    vector BLOB NOT NULL,
+    model TEXT NOT NULL DEFAULT 'all-MiniLM-L6-v2',
+    dimensions INTEGER NOT NULL DEFAULT 384,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_embeddings_entity_id ON embeddings(entity_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_embeddings_source ON embeddings(source_type, source_id, model);
+ALTER TABLE entities ADD COLUMN embedded_at DATETIME;
+INSERT OR IGNORE INTO schema_version (version) VALUES (5);`
+  },
+  {
+    version: 6,
+    label: "task timeout",
+    sql: `
+ALTER TABLE tasks ADD COLUMN timeout_minutes INTEGER;
+INSERT OR IGNORE INTO schema_version (version) VALUES (6);`
+  },
+  {
+    version: 7,
+    label: "task_runs status index",
+    sql: `
+CREATE INDEX IF NOT EXISTS idx_task_runs_status ON task_runs(status);
+INSERT OR IGNORE INTO schema_version (version) VALUES (7);`
+  },
+  {
+    version: 8,
+    label: "console logs for task runs",
+    sql: `
+CREATE TABLE IF NOT EXISTS console_logs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id INTEGER NOT NULL REFERENCES task_runs(id) ON DELETE CASCADE,
+    seq INTEGER NOT NULL,
+    entry_type TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_console_logs_run_seq ON console_logs(run_id, seq);
+INSERT OR IGNORE INTO schema_version (version) VALUES (8);`
+  },
+  {
+    version: 9,
+    label: "task max turns",
+    sql: `
+ALTER TABLE tasks ADD COLUMN max_turns INTEGER;
+INSERT OR IGNORE INTO schema_version (version) VALUES (9);`
+  },
+  {
+    version: 10,
+    label: "task tool restrictions",
+    sql: `
+ALTER TABLE tasks ADD COLUMN allowed_tools TEXT;
+ALTER TABLE tasks ADD COLUMN disallowed_tools TEXT;
+INSERT OR IGNORE INTO schema_version (version) VALUES (10);`
+  },
+  {
+    version: 11,
+    label: "task learned context",
+    sql: `
+ALTER TABLE tasks ADD COLUMN learned_context TEXT;
+INSERT OR IGNORE INTO schema_version (version) VALUES (11);`
+  },
+  {
+    version: 12,
+    label: "per-task nudge mode",
+    sql: `
+ALTER TABLE tasks ADD COLUMN nudge_mode TEXT NOT NULL DEFAULT 'always';
+INSERT OR IGNORE INTO schema_version (version) VALUES (12);`
+  },
+  {
+    version: 13,
+    label: "worker role field",
+    sql: `
+ALTER TABLE workers ADD COLUMN role TEXT;
+INSERT OR IGNORE INTO schema_version (version) VALUES (13);`
+  },
+  {
+    version: 14,
+    label: "rooms + room activity",
+    sql: `
+CREATE TABLE IF NOT EXISTS rooms (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    queen_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    goal TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    visibility TEXT NOT NULL DEFAULT 'private',
+    config TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_rooms_status ON rooms(status);
+CREATE TABLE IF NOT EXISTS room_activity (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    event_type TEXT NOT NULL,
+    actor_id INTEGER,
+    summary TEXT NOT NULL,
+    details TEXT,
+    is_public INTEGER NOT NULL DEFAULT 1,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_room_activity_room ON room_activity(room_id);
+CREATE INDEX IF NOT EXISTS idx_room_activity_type ON room_activity(event_type);
+INSERT OR IGNORE INTO schema_version (version) VALUES (14);`
+  },
+  {
+    version: 15,
+    label: "quorum decisions + votes",
+    sql: `
+CREATE TABLE IF NOT EXISTS quorum_decisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    proposer_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    proposal TEXT NOT NULL,
+    decision_type TEXT NOT NULL DEFAULT 'low_impact',
+    status TEXT NOT NULL DEFAULT 'voting',
+    result TEXT,
+    threshold TEXT NOT NULL DEFAULT 'majority',
+    timeout_at DATETIME,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    resolved_at DATETIME
+);
+CREATE INDEX IF NOT EXISTS idx_quorum_decisions_room ON quorum_decisions(room_id);
+CREATE INDEX IF NOT EXISTS idx_quorum_decisions_status ON quorum_decisions(status);
+CREATE TABLE IF NOT EXISTS quorum_votes (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    decision_id INTEGER NOT NULL REFERENCES quorum_decisions(id) ON DELETE CASCADE,
+    worker_id INTEGER NOT NULL REFERENCES workers(id) ON DELETE CASCADE,
+    vote TEXT NOT NULL,
+    reasoning TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    UNIQUE(decision_id, worker_id)
+);
+CREATE INDEX IF NOT EXISTS idx_quorum_votes_decision ON quorum_votes(decision_id);
+INSERT OR IGNORE INTO schema_version (version) VALUES (15);`
+  },
+  {
+    version: 16,
+    label: "goals + goal updates",
+    sql: `
+CREATE TABLE IF NOT EXISTS goals (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    description TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active',
+    parent_goal_id INTEGER REFERENCES goals(id) ON DELETE CASCADE,
+    assigned_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    progress REAL NOT NULL DEFAULT 0.0,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_goals_room ON goals(room_id);
+CREATE INDEX IF NOT EXISTS idx_goals_parent ON goals(parent_goal_id);
+CREATE INDEX IF NOT EXISTS idx_goals_status ON goals(status);
+CREATE TABLE IF NOT EXISTS goal_updates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    goal_id INTEGER NOT NULL REFERENCES goals(id) ON DELETE CASCADE,
+    worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    observation TEXT NOT NULL,
+    metric_value REAL,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_goal_updates_goal ON goal_updates(goal_id);
+INSERT OR IGNORE INTO schema_version (version) VALUES (16);`
+  },
+  {
+    version: 17,
+    label: "skills",
+    sql: `
+CREATE TABLE IF NOT EXISTS skills (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    content TEXT NOT NULL,
+    activation_context TEXT,
+    auto_activate INTEGER NOT NULL DEFAULT 0,
+    agent_created INTEGER NOT NULL DEFAULT 0,
+    created_by_worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_skills_room ON skills(room_id);
+CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
+INSERT OR IGNORE INTO schema_version (version) VALUES (17);`
+  },
+  {
+    version: 18,
+    label: "self-mod audit + escalations",
+    sql: `
+CREATE TABLE IF NOT EXISTS self_mod_audit (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER REFERENCES rooms(id) ON DELETE CASCADE,
+    worker_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    file_path TEXT NOT NULL,
+    old_hash TEXT,
+    new_hash TEXT,
+    reason TEXT,
+    reversible INTEGER NOT NULL DEFAULT 1,
+    reverted INTEGER NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_self_mod_audit_room ON self_mod_audit(room_id);
+CREATE TABLE IF NOT EXISTS escalations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    from_agent_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    to_agent_id INTEGER REFERENCES workers(id) ON DELETE SET NULL,
+    question TEXT NOT NULL,
+    answer TEXT,
+    status TEXT NOT NULL DEFAULT 'pending',
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    resolved_at DATETIME
+);
+CREATE INDEX IF NOT EXISTS idx_escalations_room ON escalations(room_id);
+CREATE INDEX IF NOT EXISTS idx_escalations_status ON escalations(status);
+INSERT OR IGNORE INTO schema_version (version) VALUES (18);`
+  },
+  {
+    version: 19,
+    label: "credentials + worker room extensions",
+    sql: `
+CREATE TABLE IF NOT EXISTS credentials (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'other',
+    value_encrypted TEXT NOT NULL,
+    provided_by TEXT NOT NULL DEFAULT 'keeper',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_credentials_room ON credentials(room_id);
+ALTER TABLE workers ADD COLUMN room_id INTEGER;
+ALTER TABLE workers ADD COLUMN agent_state TEXT NOT NULL DEFAULT 'idle';
+INSERT OR IGNORE INTO schema_version (version) VALUES (19);`
+  },
+  {
+    version: 20,
+    label: "wallets, wallet transactions, stations",
+    sql: `
+CREATE TABLE IF NOT EXISTS wallets (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    address TEXT NOT NULL,
+    private_key_encrypted TEXT NOT NULL,
+    chain TEXT NOT NULL DEFAULT 'base',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_wallets_room ON wallets(room_id);
+CREATE TABLE IF NOT EXISTS wallet_transactions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    wallet_id INTEGER NOT NULL REFERENCES wallets(id) ON DELETE CASCADE,
+    type TEXT NOT NULL,
+    amount TEXT NOT NULL,
+    counterparty TEXT,
+    tx_hash TEXT,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'confirmed',
+    created_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_wallet_tx_wallet ON wallet_transactions(wallet_id);
+CREATE TABLE IF NOT EXISTS stations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    room_id INTEGER NOT NULL REFERENCES rooms(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    external_id TEXT,
+    tier TEXT NOT NULL,
+    region TEXT,
+    status TEXT NOT NULL DEFAULT 'provisioning',
+    monthly_cost REAL NOT NULL DEFAULT 0,
+    config TEXT,
+    created_at DATETIME DEFAULT (datetime('now','localtime')),
+    updated_at DATETIME DEFAULT (datetime('now','localtime'))
+);
+CREATE INDEX IF NOT EXISTS idx_stations_room ON stations(room_id);
+INSERT OR IGNORE INTO schema_version (version) VALUES (20);`
+  },
+  {
+    version: 21,
+    label: "ERC-8004 on-chain identity",
+    sql: `
+ALTER TABLE wallets ADD COLUMN erc8004_agent_id TEXT;
+INSERT OR IGNORE INTO schema_version (version) VALUES (21);`
+  }
+];
+
+// src/shared/db-migrations.ts
+function runMigrations(database, log = console.log) {
+  const hasVersionTable = database.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+  if (!hasVersionTable) {
+    database.exec(SCHEMA);
+    log("Database schema initialized (fresh install)");
+    return;
+  }
+  const row = database.prepare("SELECT MAX(version) as version FROM schema_version").get();
+  const currentVersion = row?.version ?? 0;
+  for (const migration of MIGRATIONS) {
+    if (currentVersion < migration.version) {
+      database.transaction(() => {
+        database.exec(migration.sql);
+      })();
+      log(`Database schema v${migration.version} applied (${migration.label})`);
+    }
+  }
+}
+
+// src/shared/embeddings.ts
+var sqliteVecLoaded = false;
+function loadSqliteVec(db2) {
+  if (sqliteVecLoaded) return true;
+  try {
+    const sqliteVec = require("sqlite-vec");
+    sqliteVec.load(db2);
+    sqliteVecLoaded = true;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/server/db.ts
+var db = null;
+function expandTilde(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return p.replace("~", (0, import_os.homedir)());
+  }
+  return p;
+}
+function getDefaultDataDir() {
+  return (0, import_path.join)((0, import_os.homedir)(), ".quoroom");
+}
+function getDataDir() {
+  const raw = process.env.QUOROOM_DATA_DIR || getDefaultDataDir();
+  return expandTilde(raw);
+}
+function getServerDatabase() {
+  if (db) return db;
+  const dataDir = getDataDir();
+  (0, import_fs.mkdirSync)(dataDir, { recursive: true });
+  const rawPath = process.env.QUOROOM_DB_PATH || process.env.DAYMON_DB_PATH || (0, import_path.join)(dataDir, "data.db");
+  const dbPath = expandTilde(rawPath);
+  db = new import_better_sqlite3.default(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  loadSqliteVec(db);
+  runMigrations(db, (msg) => console.error(`API server: ${msg}`));
+  const cleaned = cleanupAllRunningRuns(db);
+  if (cleaned > 0) {
+    console.error(`API server: Cleaned up ${cleaned} stale task run(s)`);
+  }
+  return db;
+}
+function closeServerDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/server/routes/status.ts
+var startedAt = Date.now();
+var cachedVersion = null;
+function getVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    cachedVersion = require_package().version;
+  } catch {
+    cachedVersion = "unknown";
+  }
+  return cachedVersion;
+}
+var cachedClaudeCheck = null;
+function checkClaude() {
+  if (cachedClaudeCheck) return cachedClaudeCheck;
+  try {
+    const out = (0, import_node_child_process.execSync)("claude --version 2>/dev/null", { timeout: 5e3 }).toString().trim();
+    cachedClaudeCheck = { available: true, version: out };
+  } catch {
+    cachedClaudeCheck = { available: false };
+  }
+  return cachedClaudeCheck;
+}
+function registerStatusRoutes(router) {
+  router.get("/api/status", (ctx) => {
+    const dataDir = getDataDir();
+    const dbPath = ctx.db.name;
+    const claude = checkClaude();
+    return {
+      data: {
+        version: getVersion(),
+        uptime: Math.floor((Date.now() - startedAt) / 1e3),
+        dataDir,
+        dbPath,
+        claude
+      }
+    };
+  });
+}
+
+// src/server/routes/index.ts
+function registerAllRoutes(router) {
+  registerRoomRoutes(router);
+  registerWorkerRoutes(router);
+  registerGoalRoutes(router);
+  registerDecisionRoutes(router);
+  registerTaskRoutes(router);
+  registerRunRoutes(router);
+  registerMemoryRoutes(router);
+  registerSkillRoutes(router);
+  registerWatchRoutes(router);
+  registerSettingRoutes(router);
+  registerEscalationRoutes(router);
+  registerSelfModRoutes(router);
+  registerStatusRoutes(router);
+}
+
+// src/server/ws.ts
+var import_ws = require("ws");
+function createWsServer(server) {
+  const wss = new import_ws.WebSocketServer({ noServer: true });
+  const clients = /* @__PURE__ */ new Map();
+  server.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url, `http://${req.headers.host || "localhost"}`);
+    if (url.pathname !== "/ws") {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const token = url.searchParams.get("token");
+    if (!validateToken(token ? `Bearer ${token}` : void 0)) {
+      socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+  wss.on("connection", (ws) => {
+    clients.set(ws, { channels: /* @__PURE__ */ new Set() });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        handleClientMessage(ws, clients.get(ws), msg);
+      } catch {
+        sendError(ws, "Invalid JSON");
+      }
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+    });
+  });
+  const unsub = eventBus.onAny((event) => {
+    for (const [ws, state] of clients) {
+      if (ws.readyState !== import_ws.WebSocket.OPEN) continue;
+      if (state.channels.has(event.channel)) {
+        ws.send(JSON.stringify(event));
+      }
+    }
+  });
+  wss.on("close", () => {
+    unsub();
+  });
+  return wss;
+}
+function handleClientMessage(ws, state, msg) {
+  if (msg.type === "subscribe" && Array.isArray(msg.channels)) {
+    for (const ch of msg.channels) {
+      if (typeof ch === "string") state.channels.add(ch);
+    }
+    ws.send(JSON.stringify({
+      type: "subscribed",
+      channels: [...state.channels]
+    }));
+    return;
+  }
+  if (msg.type === "unsubscribe" && Array.isArray(msg.channels)) {
+    for (const ch of msg.channels) {
+      state.channels.delete(ch);
+    }
+    ws.send(JSON.stringify({
+      type: "unsubscribed",
+      channels: [...state.channels]
+    }));
+    return;
+  }
+  if (msg.type === "ping") {
+    ws.send(JSON.stringify({ type: "pong" }));
+    return;
+  }
+  sendError(ws, `Unknown message type: ${msg.type}`);
+}
+function sendError(ws, message) {
+  if (ws.readyState === import_ws.WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "error", message }));
+  }
+}
+
+// src/server/index.ts
+var DEFAULT_PORT = 3700;
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) return resolve(void 0);
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".webp": "image/webp",
+  ".webmanifest": "application/manifest+json"
+};
+function serveStatic(staticDir, pathname, res) {
+  const safePath = import_node_path2.default.normalize(pathname).replace(/^(\.\.[/\\])+/, "");
+  let filePath = import_node_path2.default.join(staticDir, safePath);
+  try {
+    const stat = import_node_fs2.default.statSync(filePath);
+    if (stat.isDirectory()) {
+      filePath = import_node_path2.default.join(filePath, "index.html");
+    }
+  } catch {
+    filePath = import_node_path2.default.join(staticDir, "index.html");
+  }
+  try {
+    const data = import_node_fs2.default.readFileSync(filePath);
+    const ext = import_node_path2.default.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(data);
+  } catch {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+  }
+}
+function createApiServer(options = {}) {
+  const db2 = options.db ?? getServerDatabase();
+  const port = options.port ?? DEFAULT_PORT;
+  const dataDir = options.dataDir ?? getDataDir();
+  const router = new Router();
+  registerAllRoutes(router);
+  const token = generateToken();
+  if (!options.skipTokenFile) {
+    writeTokenFile(dataDir, token, port);
+  }
+  const server = import_node_http.default.createServer(async (req, res) => {
+    const url = new import_node_url.URL(req.url, `http://${req.headers.host || "localhost"}`);
+    const pathname = url.pathname;
+    const origin = req.headers.origin;
+    if (req.method === "OPTIONS") {
+      const headers = {};
+      setCorsHeaders(origin, headers);
+      res.writeHead(204, headers);
+      res.end();
+      return;
+    }
+    const responseHeaders = {
+      "Content-Type": "application/json"
+    };
+    setCorsHeaders(origin, responseHeaders);
+    if (pathname.startsWith("/api/") && !isAllowedOrigin(origin)) {
+      res.writeHead(403, responseHeaders);
+      res.end(JSON.stringify({ error: "Forbidden origin" }));
+      return;
+    }
+    if (pathname === "/api/auth/handshake" && req.method === "GET") {
+      res.writeHead(200, responseHeaders);
+      res.end(JSON.stringify({ token: getToken() }));
+      return;
+    }
+    if (pathname === "/api/auth/verify" && req.method === "GET") {
+      if (!validateToken(req.headers.authorization)) {
+        res.writeHead(401, responseHeaders);
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        return;
+      }
+      res.writeHead(200, responseHeaders);
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+    if (pathname.startsWith("/api/")) {
+      if (!validateToken(req.headers.authorization)) {
+        res.writeHead(401, responseHeaders);
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        return;
+      }
+      const matched = router.match(req.method, pathname);
+      if (!matched) {
+        res.writeHead(404, responseHeaders);
+        res.end(JSON.stringify({ error: "Not found" }));
+        return;
+      }
+      try {
+        const body = await parseBody(req);
+        const query = Object.fromEntries(url.searchParams);
+        const ctx = {
+          params: matched.params,
+          query,
+          body,
+          db: db2
+        };
+        const result = await matched.handler(ctx);
+        const status = result.error ? result.status || 400 : result.status || 200;
+        res.writeHead(status, responseHeaders);
+        res.end(JSON.stringify(result.error ? { error: result.error } : result.data));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Internal error";
+        res.writeHead(500, responseHeaders);
+        res.end(JSON.stringify({ error: message }));
+      }
+      return;
+    }
+    if (options.staticDir) {
+      serveStatic(options.staticDir, pathname, res);
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+  });
+  createWsServer(server);
+  return { server, token, db: db2 };
+}
+function startServer(options = {}) {
+  const port = options.port ?? DEFAULT_PORT;
+  if (!options.staticDir) {
+    const defaultUiDir = import_node_path2.default.join(__dirname, "../ui");
+    if (import_node_fs2.default.existsSync(defaultUiDir)) {
+      options.staticDir = defaultUiDir;
+    }
+  }
+  const { server, token } = createApiServer(options);
+  server.listen(port, "127.0.0.1", () => {
+    console.error(`Quoroom API server started on http://localhost:${port}`);
+    console.error(`Auth token: ${token.slice(0, 8)}...`);
+    console.error(`WebSocket: ws://localhost:${port}/ws?token=<token>`);
+  });
+  process.on("SIGINT", () => {
+    console.error("Shutting down...");
+    server.close();
+    closeServerDatabase();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    server.close();
+    closeServerDatabase();
+    process.exit(0);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApiServer,
+  startServer
+});