@michael-joseph-miller/ant-bot 0.1.0

package/dist/server.js

@@ -0,0 +1,3016 @@
+import { createRequire as __antbotCreateRequire } from 'node:module';
+const require = __antbotCreateRequire(import.meta.url);
+import {
+  ApprovalDecisionRequest,
+  CreateBotRequest,
+  CreateRoutineRequest,
+  CreateRuleRequest,
+  CreateSkillRequest,
+  CreateThreadRequest,
+  LIMITS,
+  LIMIT_ERROR,
+  LimitError,
+  PostMessageRequest,
+  SettingsPatchSchema,
+  SettingsSchema,
+  UpdateBotRequest
+} from "./chunk-DYIJTUMY.js";
+import {
+  findWebDist,
+  nodeLocateDeps,
+  readPackageVersion
+} from "./chunk-Z2YT2PZN.js";
+import {
+  describeSkillSource
+} from "./chunk-7BOHBPB2.js";
+import {
+  newId,
+  now,
+  slugify
+} from "./chunk-KSQOVWP5.js";
+import {
+  logger
+} from "./chunk-AHAON6J7.js";
+
+// packages/server/src/api/server.ts
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { createRequire } from "node:module";
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
+import websocket from "@fastify/websocket";
+import fastifyStatic from "@fastify/static";
+
+// packages/server/src/app.ts
+import path8 from "node:path";
+
+// packages/server/src/db/db.ts
+import Database from "better-sqlite3";
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// packages/server/src/db/migrations.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// packages/server/src/db/schema.ts
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS bots (
+  id TEXT PRIMARY KEY, slug TEXT UNIQUE NOT NULL, name TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '',
+  avatar_emoji TEXT NOT NULL DEFAULT '\u{1F916}', model_tier TEXT NOT NULL DEFAULT 'sonnet',
+  pinned INTEGER NOT NULL DEFAULT 0, hidden INTEGER NOT NULL DEFAULT 0,
+  notifications INTEGER NOT NULL DEFAULT 1, session_id TEXT,
+  state TEXT NOT NULL DEFAULT 'idle', attention TEXT NOT NULL DEFAULT 'none',
+  thread_id TEXT, created_at INTEGER NOT NULL, deleted_at INTEGER
+);
+CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY, kind TEXT NOT NULL CHECK(kind IN ('dm','group')),
+  title TEXT NOT NULL DEFAULT '', member_bot_ids TEXT NOT NULL DEFAULT '[]',
+  pinned INTEGER NOT NULL DEFAULT 0, hidden INTEGER NOT NULL DEFAULT 0,
+  last_read_at INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY, thread_id TEXT NOT NULL,
+  author_kind TEXT NOT NULL CHECK(author_kind IN ('user','bot','system')),
+  author_bot_id TEXT, reply_to_id TEXT, content_md TEXT NOT NULL DEFAULT '',
+  cards TEXT NOT NULL DEFAULT '[]', streaming INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id, created_at);
+CREATE TABLE IF NOT EXISTS attachments (
+  id TEXT PRIMARY KEY, message_id TEXT, path TEXT NOT NULL, name TEXT NOT NULL,
+  mime TEXT NOT NULL, bytes INTEGER NOT NULL, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS approvals (
+  id TEXT PRIMARY KEY, bot_id TEXT NOT NULL, thread_id TEXT NOT NULL,
+  tool_name TEXT NOT NULL, input_summary TEXT NOT NULL, raw_input TEXT NOT NULL DEFAULT 'null',
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','allowed','denied','expired')),
+  decided_by TEXT CHECK(decided_by IN ('user','rule','auto_review')),
+  reason TEXT NOT NULL DEFAULT '', rule_id TEXT,
+  created_at INTEGER NOT NULL, decided_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_approvals_status ON approvals(status);
+CREATE TABLE IF NOT EXISTS rules (
+  id TEXT PRIMARY KEY, kind TEXT NOT NULL CHECK(kind IN ('require','allow')),
+  tool_pattern TEXT NOT NULL DEFAULT '*', input_pattern TEXT NOT NULL DEFAULT '',
+  scope_note TEXT NOT NULL DEFAULT '', builtin INTEGER NOT NULL DEFAULT 0,
+  enabled INTEGER NOT NULL DEFAULT 1, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS skills (
+  id TEXT PRIMARY KEY, slug TEXT UNIQUE NOT NULL, name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '', path TEXT NOT NULL,
+  source TEXT NOT NULL DEFAULT 'user' CHECK(source IN ('user','taught','imported')),
+  created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS bot_skills (
+  bot_id TEXT NOT NULL, skill_id TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (bot_id, skill_id)
+);
+CREATE TABLE IF NOT EXISTS routines (
+  id TEXT PRIMARY KEY, bot_id TEXT NOT NULL, name TEXT NOT NULL,
+  cron_expr TEXT NOT NULL, timezone TEXT NOT NULL DEFAULT 'UTC',
+  instruction_md TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1,
+  last_run_at INTEGER, next_run_at INTEGER, created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_routines_bot ON routines(bot_id);
+CREATE TABLE IF NOT EXISTS routine_runs (
+  id TEXT PRIMARY KEY, routine_id TEXT NOT NULL, started_at INTEGER NOT NULL,
+  finished_at INTEGER, status TEXT NOT NULL CHECK(status IN ('running','ok','failed','interrupted')),
+  summary TEXT NOT NULL DEFAULT '', thread_id TEXT, is_test INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_runs_routine ON routine_runs(routine_id, started_at DESC);
+CREATE TABLE IF NOT EXISTS mailbox (
+  id TEXT PRIMARY KEY, from_bot_id TEXT NOT NULL, to_bot_id TEXT NOT NULL,
+  content_md TEXT NOT NULL, hops INTEGER NOT NULL DEFAULT 1,
+  delivered INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS usage (
+  id TEXT PRIMARY KEY, bot_id TEXT NOT NULL, turn_id TEXT NOT NULL, model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0, output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens INTEGER NOT NULL DEFAULT 0, cost_estimate REAL NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_usage_created ON usage(created_at);
+CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  content_md, content='messages', content_rowid='rowid'
+);
+CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+  INSERT INTO messages_fts(rowid, content_md) VALUES (new.rowid, new.content_md);
+END;
+CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, content_md) VALUES('delete', old.rowid, old.content_md);
+END;
+CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, content_md) VALUES('delete', old.rowid, old.content_md);
+  INSERT INTO messages_fts(rowid, content_md) VALUES (new.rowid, new.content_md);
+END;
+`;
+
+// packages/server/src/db/migrations.ts
+var MigrationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MigrationError";
+  }
+  code;
+};
+var BASELINE_VERSION = 1;
+var BASELINE_SENTINEL_TABLE = "bots";
+var MIGRATIONS = [
+  { version: BASELINE_VERSION, name: "baseline", up: SCHEMA_SQL }
+];
+var SCHEMA_VERSION_SQL = `
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at INTEGER NOT NULL
+);
+`;
+function detectBaselineAdoption(hasLedgerRows, hasBaselineTable) {
+  return !hasLedgerRows && hasBaselineTable;
+}
+function planMigrations(currentVersion, migrations) {
+  const sorted = [...migrations].sort((a, b2) => a.version - b2.version);
+  let prev = 0;
+  for (const m of sorted) {
+    if (!Number.isInteger(m.version) || m.version < 1) {
+      throw new MigrationError("MIGRATION_ORDER", `migration "${m.name}" has invalid version ${m.version}`);
+    }
+    if (m.version === prev) {
+      throw new MigrationError("MIGRATION_ORDER", `duplicate migration version ${m.version}`);
+    }
+    prev = m.version;
+  }
+  const latest = sorted.length ? sorted[sorted.length - 1].version : 0;
+  if (currentVersion > latest) {
+    throw new MigrationError(
+      "MIGRATION_DOWNGRADE",
+      `database is at schema version ${currentVersion} but this build only knows up to ${latest}. Upgrade ant-bot (npm i -g @michael-joseph-miller/ant-bot) rather than downgrading the database.`
+    );
+  }
+  return sorted.filter((m) => m.version > currentVersion);
+}
+function readCurrentVersion(db) {
+  db.exec(SCHEMA_VERSION_SQL);
+  const row = db.prepare(`SELECT MAX(version) v FROM schema_version`).get();
+  if (row.v !== null) return { version: row.v, adopted: false };
+  const sentinel = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(BASELINE_SENTINEL_TABLE);
+  const adopted = detectBaselineAdoption(false, Boolean(sentinel));
+  return { version: adopted ? BASELINE_VERSION : 0, adopted };
+}
+function snapshot(db, backupsDir, toVersion, now2) {
+  fs.mkdirSync(backupsDir, { recursive: true });
+  const stamp = new Date(now2()).toISOString().replace(/[:.]/g, "-");
+  const dest = path.join(backupsDir, `antbot-pre-v${toVersion}-${stamp}.db`);
+  db.prepare(`VACUUM INTO ?`).run(dest);
+  return dest;
+}
+function migrate(db, opts = {}) {
+  const migrations = opts.migrations ?? MIGRATIONS;
+  const now2 = opts.now ?? Date.now;
+  const { version: from, adopted } = readCurrentVersion(db);
+  const record = db.prepare(
+    `INSERT OR IGNORE INTO schema_version (version, name, applied_at) VALUES (?, ?, ?)`
+  );
+  if (adopted) {
+    const baseline = migrations.find((m) => m.version === BASELINE_VERSION);
+    record.run(BASELINE_VERSION, baseline?.name ?? "baseline", now2());
+  }
+  const pending = planMigrations(from, migrations);
+  if (pending.length === 0) return { from, to: from, applied: [] };
+  const target = pending[pending.length - 1].version;
+  let backupPath;
+  if (opts.backupsDir && from > 0) {
+    backupPath = snapshot(db, opts.backupsDir, target, now2);
+  }
+  const applied = [];
+  for (const m of pending) {
+    const run = db.transaction(() => {
+      db.exec(m.up);
+      record.run(m.version, m.name, now2());
+    });
+    try {
+      run();
+    } catch (err) {
+      throw new MigrationError(
+        "MIGRATION_FAILED",
+        `migration ${m.version} (${m.name}) failed: ${err.message}` + (backupPath ? `. The pre-migration database was saved to ${backupPath}` : "")
+      );
+    }
+    applied.push({ version: m.version, name: m.name });
+  }
+  return { from, to: target, applied, backupPath };
+}
+
+// packages/server/src/db/db.ts
+var log = logger("db");
+function openDb(file, opts = {}) {
+  if (file !== ":memory:") fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  const db = new Database(file);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  const backupsDir = file === ":memory:" ? void 0 : opts.backupsDir ?? path2.join(path2.dirname(file), "backups");
+  const result = migrate(db, { backupsDir });
+  if (result.from > 0 && result.applied.length) {
+    log.info(
+      `schema ${result.from} -> ${result.to}: ${result.applied.map((a) => a.name).join(", ")}` + (result.backupPath ? ` (snapshot: ${result.backupPath})` : "")
+    );
+  }
+  return db;
+}
+
+// packages/server/src/db/store.ts
+var b = (v) => v === 1 || v === true;
+var i = (v, d = false) => v ?? d ? 1 : 0;
+var toBot = (r) => ({
+  id: r.id,
+  slug: r.slug,
+  name: r.name,
+  title: r.title,
+  description: r.description,
+  avatarEmoji: r.avatar_emoji,
+  modelTier: r.model_tier,
+  pinned: b(r.pinned),
+  hidden: b(r.hidden),
+  notifications: b(r.notifications),
+  sessionId: r.session_id,
+  state: r.state,
+  attention: r.attention,
+  threadId: r.thread_id,
+  createdAt: r.created_at,
+  deletedAt: r.deleted_at
+});
+var toThread = (r) => ({
+  id: r.id,
+  kind: r.kind,
+  title: r.title,
+  memberBotIds: JSON.parse(r.member_bot_ids),
+  pinned: b(r.pinned),
+  hidden: b(r.hidden),
+  lastReadAt: r.last_read_at,
+  createdAt: r.created_at
+});
+var toMessage = (r) => ({
+  id: r.id,
+  threadId: r.thread_id,
+  authorKind: r.author_kind,
+  authorBotId: r.author_bot_id,
+  replyToId: r.reply_to_id,
+  contentMd: r.content_md,
+  cards: JSON.parse(r.cards),
+  streaming: b(r.streaming),
+  createdAt: r.created_at
+});
+var toApproval = (r) => ({
+  id: r.id,
+  botId: r.bot_id,
+  threadId: r.thread_id,
+  toolName: r.tool_name,
+  inputSummary: r.input_summary,
+  rawInput: JSON.parse(r.raw_input),
+  status: r.status,
+  decidedBy: r.decided_by,
+  reason: r.reason,
+  ruleId: r.rule_id,
+  createdAt: r.created_at,
+  decidedAt: r.decided_at
+});
+var toRule = (r) => ({
+  id: r.id,
+  kind: r.kind,
+  toolPattern: r.tool_pattern,
+  inputPattern: r.input_pattern,
+  scopeNote: r.scope_note,
+  builtin: b(r.builtin),
+  enabled: b(r.enabled),
+  createdAt: r.created_at
+});
+var toSkill = (r) => ({
+  id: r.id,
+  slug: r.slug,
+  name: r.name,
+  description: r.description,
+  path: r.path,
+  source: r.source,
+  createdAt: r.created_at
+});
+var toRoutine = (r) => ({
+  id: r.id,
+  botId: r.bot_id,
+  name: r.name,
+  cronExpr: r.cron_expr,
+  timezone: r.timezone,
+  instructionMd: r.instruction_md,
+  enabled: b(r.enabled),
+  lastRunAt: r.last_run_at,
+  nextRunAt: r.next_run_at,
+  createdAt: r.created_at
+});
+var toRun = (r) => ({
+  id: r.id,
+  routineId: r.routine_id,
+  startedAt: r.started_at,
+  finishedAt: r.finished_at,
+  status: r.status,
+  summary: r.summary,
+  threadId: r.thread_id,
+  isTest: b(r.is_test)
+});
+var toAttachment = (r) => ({
+  id: r.id,
+  messageId: r.message_id,
+  path: r.path,
+  name: r.name,
+  mime: r.mime,
+  bytes: r.bytes,
+  createdAt: r.created_at
+});
+var toMail = (r) => ({
+  id: r.id,
+  fromBotId: r.from_bot_id,
+  toBotId: r.to_bot_id,
+  contentMd: r.content_md,
+  hops: r.hops,
+  delivered: b(r.delivered),
+  createdAt: r.created_at
+});
+var toUsage = (r) => ({
+  id: r.id,
+  botId: r.bot_id,
+  turnId: r.turn_id,
+  model: r.model,
+  inputTokens: r.input_tokens,
+  outputTokens: r.output_tokens,
+  cacheReadTokens: r.cache_read_tokens,
+  costEstimate: r.cost_estimate,
+  createdAt: r.created_at
+});
+var Store = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /* ---- bots ---- */
+  countBotsAndGroups() {
+    const bots = this.db.prepare(`SELECT COUNT(*) c FROM bots WHERE deleted_at IS NULL`).get();
+    const groups = this.db.prepare(`SELECT COUNT(*) c FROM threads WHERE kind='group'`).get();
+    return bots.c + groups.c;
+  }
+  createBot(input) {
+    if (this.countBotsAndGroups() >= LIMITS.MAX_BOTS_AND_GROUPS)
+      throw new LimitError(LIMIT_ERROR.TOO_MANY_BOTS, `Limit of ${LIMITS.MAX_BOTS_AND_GROUPS} bots and groups reached`);
+    const existing = new Set(
+      this.db.prepare(`SELECT slug FROM bots`).all().map((r) => r.slug)
+    );
+    const id = newId();
+    const thread = this.createThread({ kind: "dm", title: input.name, memberBotIds: [id] });
+    this.db.prepare(
+      `INSERT INTO bots (id,slug,name,title,description,avatar_emoji,model_tier,pinned,hidden,notifications,session_id,state,attention,thread_id,created_at)
+         VALUES (@id,@slug,@name,@title,@description,@avatar_emoji,@model_tier,0,0,1,NULL,'idle','none',@thread_id,@created_at)`
+    ).run({
+      id,
+      slug: slugify(input.name, existing),
+      name: input.name,
+      title: input.title ?? "",
+      description: input.description ?? "",
+      avatar_emoji: input.avatarEmoji ?? "\u{1F916}",
+      model_tier: input.modelTier ?? "sonnet",
+      thread_id: thread.id,
+      created_at: now()
+    });
+    return this.getBot(id);
+  }
+  getBot(id) {
+    const r = this.db.prepare(`SELECT * FROM bots WHERE id=? AND deleted_at IS NULL`).get(id);
+    return r ? toBot(r) : null;
+  }
+  getBotBySlug(slug) {
+    const r = this.db.prepare(`SELECT * FROM bots WHERE slug=? AND deleted_at IS NULL`).get(slug);
+    return r ? toBot(r) : null;
+  }
+  listBots(includeHidden = true) {
+    const rows = this.db.prepare(`SELECT * FROM bots WHERE deleted_at IS NULL ${includeHidden ? "" : "AND hidden=0"} ORDER BY pinned DESC, created_at ASC`).all();
+    return rows.map(toBot);
+  }
+  updateBot(id, patch) {
+    const cur = this.getBot(id);
+    if (!cur) return null;
+    const m = {
+      name: patch.name ?? cur.name,
+      title: patch.title ?? cur.title,
+      description: patch.description ?? cur.description,
+      avatar_emoji: patch.avatarEmoji ?? cur.avatarEmoji,
+      model_tier: patch.modelTier ?? cur.modelTier,
+      pinned: i(patch.pinned, cur.pinned),
+      hidden: i(patch.hidden, cur.hidden),
+      notifications: i(patch.notifications, cur.notifications),
+      session_id: patch.sessionId !== void 0 ? patch.sessionId : cur.sessionId,
+      state: patch.state ?? cur.state,
+      attention: patch.attention ?? cur.attention,
+      id
+    };
+    this.db.prepare(
+      `UPDATE bots SET name=@name,title=@title,description=@description,avatar_emoji=@avatar_emoji,
+       model_tier=@model_tier,pinned=@pinned,hidden=@hidden,notifications=@notifications,
+       session_id=@session_id,state=@state,attention=@attention WHERE id=@id`
+    ).run(m);
+    return this.getBot(id);
+  }
+  deleteBot(id) {
+    const bot = this.getBot(id);
+    if (!bot) return;
+    this.db.prepare(`UPDATE bots SET deleted_at=? WHERE id=?`).run(now(), id);
+    this.db.prepare(`DELETE FROM routines WHERE bot_id=?`).run(id);
+    if (bot.threadId) this.db.prepare(`DELETE FROM threads WHERE id=?`).run(bot.threadId);
+  }
+  duplicateBot(id) {
+    const src = this.getBot(id);
+    if (!src) return null;
+    const copy = this.createBot({
+      name: `${src.name} copy`,
+      title: src.title,
+      description: src.description,
+      avatarEmoji: src.avatarEmoji,
+      modelTier: src.modelTier
+    });
+    for (const bs of this.db.prepare(`SELECT * FROM bot_skills WHERE bot_id=?`).all(id))
+      this.db.prepare(`INSERT OR REPLACE INTO bot_skills (bot_id,skill_id,enabled) VALUES (?,?,?)`).run(copy.id, bs.skill_id, bs.enabled);
+    for (const r of this.listRoutines(id))
+      this.createRoutine({ botId: copy.id, name: r.name, cronExpr: r.cronExpr, timezone: r.timezone, instructionMd: r.instructionMd, enabled: false });
+    return copy;
+  }
+  /* ---- threads & messages ---- */
+  createThread(input) {
+    if (input.kind === "group") {
+      const n = input.memberBotIds.length;
+      if (n < LIMITS.MIN_GROUP_MEMBERS || n > LIMITS.MAX_GROUP_MEMBERS)
+        throw new LimitError(LIMIT_ERROR.GROUP_SIZE, `A group needs ${LIMITS.MIN_GROUP_MEMBERS}\u2013${LIMITS.MAX_GROUP_MEMBERS} bots (got ${n})`);
+      if (this.countBotsAndGroups() >= LIMITS.MAX_BOTS_AND_GROUPS)
+        throw new LimitError(LIMIT_ERROR.TOO_MANY_BOTS, `Limit of ${LIMITS.MAX_BOTS_AND_GROUPS} bots and groups reached`);
+    }
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO threads (id,kind,title,member_bot_ids,pinned,hidden,last_read_at,created_at)
+       VALUES (?,?,?,?,0,0,0,?)`
+    ).run(id, input.kind, input.title ?? "", JSON.stringify(input.memberBotIds), now());
+    return this.getThread(id);
+  }
+  getThread(id) {
+    const r = this.db.prepare(`SELECT * FROM threads WHERE id=?`).get(id);
+    return r ? toThread(r) : null;
+  }
+  listThreads(kind) {
+    const rows = kind ? this.db.prepare(`SELECT * FROM threads WHERE kind=? ORDER BY created_at ASC`).all(kind) : this.db.prepare(`SELECT * FROM threads ORDER BY created_at ASC`).all();
+    return rows.map(toThread);
+  }
+  updateThread(id, patch) {
+    const cur = this.getThread(id);
+    if (!cur) return null;
+    this.db.prepare(
+      `UPDATE threads SET title=?, member_bot_ids=?, pinned=?, hidden=?, last_read_at=? WHERE id=?`
+    ).run(
+      patch.title ?? cur.title,
+      JSON.stringify(patch.memberBotIds ?? cur.memberBotIds),
+      i(patch.pinned, cur.pinned),
+      i(patch.hidden, cur.hidden),
+      patch.lastReadAt ?? cur.lastReadAt,
+      id
+    );
+    return this.getThread(id);
+  }
+  deleteThread(id) {
+    this.db.prepare(`DELETE FROM threads WHERE id=?`).run(id);
+    this.db.prepare(`DELETE FROM messages WHERE thread_id=?`).run(id);
+  }
+  createMessage(input) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO messages (id,thread_id,author_kind,author_bot_id,reply_to_id,content_md,cards,streaming,created_at)
+       VALUES (?,?,?,?,?,?,?,?,?)`
+    ).run(
+      id,
+      input.threadId,
+      input.authorKind,
+      input.authorBotId ?? null,
+      input.replyToId ?? null,
+      input.contentMd ?? "",
+      JSON.stringify(input.cards ?? []),
+      i(input.streaming),
+      now()
+    );
+    return this.getMessage(id);
+  }
+  getMessage(id) {
+    const r = this.db.prepare(`SELECT * FROM messages WHERE id=?`).get(id);
+    return r ? toMessage(r) : null;
+  }
+  listMessages(threadId, limit = 500) {
+    const rows = this.db.prepare(`SELECT * FROM messages WHERE thread_id=? ORDER BY created_at ASC LIMIT ?`).all(threadId, limit);
+    return rows.map(toMessage);
+  }
+  updateMessage(id, patch) {
+    const cur = this.getMessage(id);
+    if (!cur) return null;
+    this.db.prepare(`UPDATE messages SET content_md=?, cards=?, streaming=? WHERE id=?`).run(
+      patch.contentMd ?? cur.contentMd,
+      JSON.stringify(patch.cards ?? cur.cards),
+      i(patch.streaming, cur.streaming),
+      id
+    );
+    return this.getMessage(id);
+  }
+  appendCard(id, card) {
+    const cur = this.getMessage(id);
+    if (!cur) return -1;
+    const cards = [...cur.cards, card];
+    this.db.prepare(`UPDATE messages SET cards=? WHERE id=?`).run(JSON.stringify(cards), id);
+    return cards.length - 1;
+  }
+  updateCard(id, index, card) {
+    const cur = this.getMessage(id);
+    if (!cur || !cur.cards[index]) return;
+    const cards = [...cur.cards];
+    cards[index] = card;
+    this.db.prepare(`UPDATE messages SET cards=? WHERE id=?`).run(JSON.stringify(cards), id);
+  }
+  lastMessageAt(threadId) {
+    const r = this.db.prepare(`SELECT MAX(created_at) m FROM messages WHERE thread_id=?`).get(threadId);
+    return r?.m ?? 0;
+  }
+  /* ---- attachments ---- */
+  createAttachment(a) {
+    const isVideo = a.mime.startsWith("video/");
+    const cap = isVideo ? LIMITS.MAX_VIDEO_ATTACHMENT_BYTES : LIMITS.MAX_ATTACHMENT_BYTES;
+    if (a.bytes > cap)
+      throw new LimitError(LIMIT_ERROR.ATTACHMENT_TOO_LARGE, `${a.name} is ${(a.bytes / 1048576).toFixed(1)} MB; limit is ${cap / 1048576} MB`);
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO attachments (id,message_id,path,name,mime,bytes,created_at) VALUES (?,?,?,?,?,?,?)`
+    ).run(id, a.messageId ?? null, a.path, a.name, a.mime, a.bytes, now());
+    return toAttachment(this.db.prepare(`SELECT * FROM attachments WHERE id=?`).get(id));
+  }
+  getAttachment(id) {
+    const r = this.db.prepare(`SELECT * FROM attachments WHERE id=?`).get(id);
+    return r ? toAttachment(r) : null;
+  }
+  attachToMessage(ids, messageId) {
+    if (ids.length > LIMITS.MAX_ATTACHMENTS_PER_MESSAGE)
+      throw new LimitError(LIMIT_ERROR.TOO_MANY_ATTACHMENTS, `At most ${LIMITS.MAX_ATTACHMENTS_PER_MESSAGE} attachments per message`);
+    const stmt = this.db.prepare(`UPDATE attachments SET message_id=? WHERE id=?`);
+    for (const id of ids) stmt.run(messageId, id);
+  }
+  listAttachmentsForMessage(messageId) {
+    return this.db.prepare(`SELECT * FROM attachments WHERE message_id=?`).all(messageId).map(toAttachment);
+  }
+  /* ---- approvals ---- */
+  createApproval(a) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO approvals (id,bot_id,thread_id,tool_name,input_summary,raw_input,status,reason,created_at)
+       VALUES (?,?,?,?,?,?, 'pending', ?, ?)`
+    ).run(id, a.botId, a.threadId, a.toolName, a.inputSummary, JSON.stringify(a.rawInput ?? null), a.reason ?? "", now());
+    return this.getApproval(id);
+  }
+  getApproval(id) {
+    const r = this.db.prepare(`SELECT * FROM approvals WHERE id=?`).get(id);
+    return r ? toApproval(r) : null;
+  }
+  listPendingApprovals() {
+    return this.db.prepare(`SELECT * FROM approvals WHERE status='pending' ORDER BY created_at ASC`).all().map(toApproval);
+  }
+  resolveApproval(id, status, decidedBy, ruleId, reason) {
+    const cur = this.getApproval(id);
+    if (!cur) return null;
+    this.db.prepare(`UPDATE approvals SET status=?, decided_by=?, rule_id=?, reason=?, decided_at=? WHERE id=?`).run(status, decidedBy, ruleId ?? cur.ruleId, reason ?? cur.reason, now(), id);
+    return this.getApproval(id);
+  }
+  /* ---- rules ---- */
+  createRule(r) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO rules (id,kind,tool_pattern,input_pattern,scope_note,builtin,enabled,created_at) VALUES (?,?,?,?,?,?,1,?)`
+    ).run(id, r.kind, r.toolPattern, r.inputPattern ?? "", r.scopeNote ?? "", i(r.builtin), now());
+    return this.getRule(id);
+  }
+  getRule(id) {
+    const r = this.db.prepare(`SELECT * FROM rules WHERE id=?`).get(id);
+    return r ? toRule(r) : null;
+  }
+  listRules(onlyEnabled = false) {
+    return this.db.prepare(`SELECT * FROM rules ${onlyEnabled ? "WHERE enabled=1" : ""} ORDER BY kind ASC, created_at ASC`).all().map(toRule);
+  }
+  setRuleEnabled(id, enabled) {
+    this.db.prepare(`UPDATE rules SET enabled=? WHERE id=?`).run(i(enabled), id);
+  }
+  deleteRule(id) {
+    this.db.prepare(`DELETE FROM rules WHERE id=? AND builtin=0`).run(id);
+  }
+  /* ---- skills ---- */
+  createSkill(s) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO skills (id,slug,name,description,path,source,created_at) VALUES (?,?,?,?,?,?,?)`
+    ).run(id, s.slug, s.name, s.description ?? "", s.path, s.source ?? "user", now());
+    return this.getSkillBySlug(s.slug);
+  }
+  getSkill(id) {
+    const r = this.db.prepare(`SELECT * FROM skills WHERE id=?`).get(id);
+    return r ? toSkill(r) : null;
+  }
+  getSkillBySlug(slug) {
+    const r = this.db.prepare(`SELECT * FROM skills WHERE slug=?`).get(slug);
+    return r ? toSkill(r) : null;
+  }
+  listSkills() {
+    return this.db.prepare(`SELECT * FROM skills ORDER BY name ASC`).all().map(toSkill);
+  }
+  /**
+   * Update a skill's metadata in place, keeping its id so bot assignments survive a
+   * re-install. Returns null if the skill is gone.
+   */
+  updateSkill(id, patch) {
+    const existing = this.getSkill(id);
+    if (!existing) return null;
+    this.db.prepare(`UPDATE skills SET name=?, description=?, path=? WHERE id=?`).run(
+      patch.name ?? existing.name,
+      patch.description ?? existing.description,
+      patch.path ?? existing.path,
+      id
+    );
+    return this.getSkill(id);
+  }
+  deleteSkill(id) {
+    this.db.prepare(`DELETE FROM skills WHERE id=?`).run(id);
+    this.db.prepare(`DELETE FROM bot_skills WHERE skill_id=?`).run(id);
+  }
+  setBotSkills(botId, skillIds) {
+    this.db.prepare(`DELETE FROM bot_skills WHERE bot_id=?`).run(botId);
+    const stmt = this.db.prepare(`INSERT OR REPLACE INTO bot_skills (bot_id,skill_id,enabled) VALUES (?,?,1)`);
+    for (const s of skillIds) stmt.run(botId, s);
+  }
+  listBotSkills(botId) {
+    return this.db.prepare(
+      `SELECT s.* FROM skills s JOIN bot_skills bs ON bs.skill_id=s.id WHERE bs.bot_id=? AND bs.enabled=1`
+    ).all(botId).map(toSkill);
+  }
+  /* ---- routines ---- */
+  createRoutine(r) {
+    const count = this.db.prepare(`SELECT COUNT(*) c FROM routines WHERE bot_id=?`).get(r.botId).c;
+    if (count >= LIMITS.MAX_ROUTINES_PER_BOT)
+      throw new LimitError(LIMIT_ERROR.TOO_MANY_ROUTINES, `A bot can own at most ${LIMITS.MAX_ROUTINES_PER_BOT} routines`);
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO routines (id,bot_id,name,cron_expr,timezone,instruction_md,enabled,created_at) VALUES (?,?,?,?,?,?,?,?)`
+    ).run(id, r.botId, r.name, r.cronExpr, r.timezone ?? "UTC", r.instructionMd, i(r.enabled, true), now());
+    return this.getRoutine(id);
+  }
+  getRoutine(id) {
+    const r = this.db.prepare(`SELECT * FROM routines WHERE id=?`).get(id);
+    return r ? toRoutine(r) : null;
+  }
+  listRoutines(botId) {
+    const rows = botId ? this.db.prepare(`SELECT * FROM routines WHERE bot_id=? ORDER BY created_at ASC`).all(botId) : this.db.prepare(`SELECT * FROM routines ORDER BY created_at ASC`).all();
+    return rows.map(toRoutine);
+  }
+  updateRoutine(id, patch) {
+    const cur = this.getRoutine(id);
+    if (!cur) return null;
+    this.db.prepare(
+      `UPDATE routines SET name=?,cron_expr=?,timezone=?,instruction_md=?,enabled=?,last_run_at=?,next_run_at=? WHERE id=?`
+    ).run(
+      patch.name ?? cur.name,
+      patch.cronExpr ?? cur.cronExpr,
+      patch.timezone ?? cur.timezone,
+      patch.instructionMd ?? cur.instructionMd,
+      i(patch.enabled, cur.enabled),
+      patch.lastRunAt !== void 0 ? patch.lastRunAt : cur.lastRunAt,
+      patch.nextRunAt !== void 0 ? patch.nextRunAt : cur.nextRunAt,
+      id
+    );
+    return this.getRoutine(id);
+  }
+  deleteRoutine(id) {
+    this.db.prepare(`DELETE FROM routines WHERE id=?`).run(id);
+    this.db.prepare(`DELETE FROM routine_runs WHERE routine_id=?`).run(id);
+  }
+  startRun(routineId, isTest = false, threadId) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO routine_runs (id,routine_id,started_at,status,summary,thread_id,is_test) VALUES (?,?,?,'running','',?,?)`
+    ).run(id, routineId, now(), threadId ?? null, i(isTest));
+    return this.getRun(id);
+  }
+  finishRun(id, status, summary) {
+    this.db.prepare(`UPDATE routine_runs SET finished_at=?, status=?, summary=? WHERE id=?`).run(now(), status, summary, id);
+    const run = this.getRun(id);
+    if (run) this.pruneRuns(run.routineId);
+    return run;
+  }
+  getRun(id) {
+    const r = this.db.prepare(`SELECT * FROM routine_runs WHERE id=?`).get(id);
+    return r ? toRun(r) : null;
+  }
+  listRuns(routineId) {
+    return this.db.prepare(
+      `SELECT * FROM routine_runs WHERE routine_id=? ORDER BY started_at DESC LIMIT ?`
+    ).all(routineId, LIMITS.ROUTINE_RUNS_RETAINED).map(toRun);
+  }
+  /** Keep only the N most recent run records (outline §13). */
+  pruneRuns(routineId) {
+    this.db.prepare(
+      `DELETE FROM routine_runs WHERE routine_id=? AND id NOT IN
+       (SELECT id FROM routine_runs WHERE routine_id=? ORDER BY started_at DESC LIMIT ?)`
+    ).run(routineId, routineId, LIMITS.ROUTINE_RUNS_RETAINED);
+  }
+  /* ---- mailbox ---- */
+  createMail(m) {
+    const hops = m.hops ?? 1;
+    if (hops > LIMITS.MAX_BOT_TO_BOT_HOPS)
+      throw new LimitError(LIMIT_ERROR.HOP_LIMIT, `Bot-to-bot hop limit (${LIMITS.MAX_BOT_TO_BOT_HOPS}) reached; a human must take the next step`);
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO mailbox (id,from_bot_id,to_bot_id,content_md,hops,delivered,created_at) VALUES (?,?,?,?,?,0,?)`
+    ).run(id, m.fromBotId, m.toBotId, m.contentMd, hops, now());
+    return toMail(this.db.prepare(`SELECT * FROM mailbox WHERE id=?`).get(id));
+  }
+  markDelivered(id) {
+    this.db.prepare(`UPDATE mailbox SET delivered=1 WHERE id=?`).run(id);
+  }
+  listMail(toBotId, onlyUndelivered = true) {
+    return this.db.prepare(
+      `SELECT * FROM mailbox WHERE to_bot_id=? ${onlyUndelivered ? "AND delivered=0" : ""} ORDER BY created_at ASC`
+    ).all(toBotId).map(toMail);
+  }
+  /* ---- usage ---- */
+  recordUsage(u) {
+    const id = newId();
+    this.db.prepare(
+      `INSERT INTO usage (id,bot_id,turn_id,model,input_tokens,output_tokens,cache_read_tokens,cost_estimate,created_at)
+       VALUES (?,?,?,?,?,?,?,?,?)`
+    ).run(id, u.botId, u.turnId, u.model, u.inputTokens, u.outputTokens, u.cacheReadTokens, u.costEstimate, now());
+    return toUsage(this.db.prepare(`SELECT * FROM usage WHERE id=?`).get(id));
+  }
+  listUsage(sinceMs = 0) {
+    return this.db.prepare(`SELECT * FROM usage WHERE created_at>=? ORDER BY created_at DESC`).all(sinceMs).map(toUsage);
+  }
+  tokensToday() {
+    const start = /* @__PURE__ */ new Date();
+    start.setHours(0, 0, 0, 0);
+    const r = this.db.prepare(
+      `SELECT COALESCE(SUM(input_tokens+output_tokens),0) t FROM usage WHERE created_at>=?`
+    ).get(start.getTime());
+    return r.t;
+  }
+  /* ---- settings ---- */
+  getSettings() {
+    const rows = this.db.prepare(`SELECT * FROM settings`).all();
+    const obj = {};
+    for (const r of rows) obj[r.key] = JSON.parse(r.value);
+    return SettingsSchema.parse(obj);
+  }
+  patchSettings(patch) {
+    const stmt = this.db.prepare(`INSERT OR REPLACE INTO settings (key,value) VALUES (?,?)`);
+    for (const [k, v] of Object.entries(patch)) if (v !== void 0) stmt.run(k, JSON.stringify(v));
+    return this.getSettings();
+  }
+  /* ---- search ---- */
+  searchMessages(q, limit = 40) {
+    if (!q.trim()) return [];
+    const escaped = `"${q.replace(/"/g, '""')}"`;
+    try {
+      const rows = this.db.prepare(
+        `SELECT m.* FROM messages_fts f JOIN messages m ON m.rowid=f.rowid
+         WHERE messages_fts MATCH ? ORDER BY rank LIMIT ?`
+      ).all(escaped, limit);
+      return rows.map(toMessage);
+    } catch {
+      const rows = this.db.prepare(
+        `SELECT * FROM messages WHERE content_md LIKE ? ORDER BY created_at DESC LIMIT ?`
+      ).all(`%${q}%`, limit);
+      return rows.map(toMessage);
+    }
+  }
+};
+
+// packages/server/src/util/bus.ts
+import { EventEmitter } from "node:events";
+var EventBus = class {
+  emitter = new EventEmitter();
+  seq = 0;
+  ring = [];
+  ringMax = 500;
+  constructor() {
+    this.emitter.setMaxListeners(200);
+  }
+  publish(e) {
+    const full = { ...e, seq: ++this.seq };
+    this.ring.push(full);
+    if (this.ring.length > this.ringMax) this.ring.shift();
+    this.emitter.emit("event", full);
+    return full;
+  }
+  subscribe(fn) {
+    this.emitter.on("event", fn);
+    return () => this.emitter.off("event", fn);
+  }
+  /** Replay events after a given seq (client reconnect). */
+  since(seq) {
+    return this.ring.filter((e) => e.seq > seq);
+  }
+  get currentSeq() {
+    return this.seq;
+  }
+};
+
+// packages/server/src/permissions/rules.ts
+var log2 = logger("rules");
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function serializeInput(input) {
+  if (input == null) return "";
+  if (typeof input === "string") return input;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function buildMatchText(input) {
+  const lines = [];
+  const walk = (v, depth) => {
+    if (depth > 6) return;
+    if (typeof v === "string") lines.push(v);
+    else if (Array.isArray(v)) v.forEach((x) => walk(x, depth + 1));
+    else if (v && typeof v === "object") Object.values(v).forEach((x) => walk(x, depth + 1));
+    else if (typeof v === "number" || typeof v === "boolean") lines.push(String(v));
+  };
+  walk(input, 0);
+  const serialized = serializeInput(input);
+  if (serialized && !lines.includes(serialized)) lines.push(serialized);
+  return lines.join("\n");
+}
+function toolNameAliases(toolName) {
+  const m = /^mcp__.+?__(.+)$/.exec(toolName);
+  return m?.[1] ? [toolName, m[1]] : [toolName];
+}
+function ruleMatches(rule, toolName, inputText) {
+  if (!rule.enabled) return false;
+  const pattern = globToRegExp(rule.toolPattern);
+  if (!toolNameAliases(toolName).some((n) => pattern.test(n))) return false;
+  if (rule.inputPattern) {
+    let re;
+    try {
+      re = new RegExp(rule.inputPattern, "im");
+    } catch {
+      return false;
+    }
+    if (!re.test(inputText)) return false;
+  }
+  return true;
+}
+function evaluateRules(rules, toolName, input) {
+  const inputText = buildMatchText(input);
+  const required = rules.find((r) => r.kind === "require" && ruleMatches(r, toolName, inputText));
+  if (required) return { kind: "require", rule: required };
+  const allowed = rules.find((r) => r.kind === "allow" && ruleMatches(r, toolName, inputText));
+  if (allowed) return { kind: "allow", rule: allowed };
+  return { kind: "none" };
+}
+var BUILTIN_RULES = [
+  { kind: "require", toolPattern: "Bash", inputPattern: "\\bsudo\\b|\\bdoas\\b|\\bsu\\s+-", scopeNote: "Privilege escalation", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "rm\\s+(-[a-zA-Z]*\\s+)*-?[rf]|shred\\b|mkfs\\b|dd\\s+if=", scopeNote: "Destructive filesystem command", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "curl[^|]*\\|\\s*(ba)?sh|wget[^|]*\\|\\s*(ba)?sh", scopeNote: "Piping a download into a shell", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "\\b(npm|pnpm|yarn|pip|pip3|gem|cargo|apt|apt-get|dnf|brew|go)\\s+(i|install|add|get)\\b", scopeNote: "Package install", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "git\\s+(push|remote\\s+add)|gh\\s+(pr|release|repo)\\s+(create|merge)", scopeNote: "Publishing to a remote", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "\\b(mail|sendmail|mutt|msmtp)\\b", scopeNote: "Sending mail", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "Bash", inputPattern: "curl[^\\n]*(-X\\s*(POST|PUT|PATCH|DELETE)|--data|-d\\s)", scopeNote: "Outbound write request", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "WebFetch", inputPattern: ".", scopeNote: "Fetching an external URL", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "browser_click", inputPattern: "(buy|purchase|checkout|pay|order|subscribe|confirm|delete|send|publish)", scopeNote: "Consequential click", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "browser_type", inputPattern: "(password|passwd|secret|token|api[_-]?key|ssn|credit\\s*card)", scopeNote: "Typing a credential \u2014 use takeover instead", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "send_to_bot", inputPattern: "", scopeNote: "Handing work to another bot", builtin: false, enabled: false },
+  { kind: "require", toolPattern: "install_skill", inputPattern: "", scopeNote: "Installing a skill from an external source", builtin: true, enabled: true },
+  { kind: "require", toolPattern: "remove_skill", inputPattern: "", scopeNote: "Uninstalling a skill", builtin: true, enabled: true },
+  { kind: "allow", toolPattern: "Read", inputPattern: "", scopeNote: "Reading files is safe", builtin: true, enabled: true },
+  { kind: "allow", toolPattern: "Glob", inputPattern: "", scopeNote: "Listing files is safe", builtin: true, enabled: true },
+  { kind: "allow", toolPattern: "Grep", inputPattern: "", scopeNote: "Searching files is safe", builtin: true, enabled: true },
+  { kind: "allow", toolPattern: "TodoWrite", inputPattern: "", scopeNote: "Planning scratchpad", builtin: true, enabled: true },
+  { kind: "allow", toolPattern: "Bash", inputPattern: "^\\s*(git\\s+(status|diff|log|show|branch)|ls|pwd|cat|head|tail|wc|echo|date|which|grep|find|rg)\\b", scopeNote: "Read-only shell inspection", builtin: true, enabled: true }
+];
+function seedBuiltinRules(store) {
+  const key = (r) => `${r.kind}\0${r.toolPattern}\0${r.inputPattern}`;
+  const existing = new Set(store.listRules().map(key));
+  const added = [];
+  for (const r of BUILTIN_RULES) {
+    if (existing.has(key(r))) continue;
+    const rule = store.createRule(r);
+    if (!r.enabled) store.setRuleEnabled(rule.id, false);
+    added.push(r.toolPattern);
+  }
+  if (added.length) log2.info(`seeded ${added.length} builtin permission rule(s): ${added.join(", ")}`);
+}
+
+// packages/server/src/permissions/local.ts
+import path3 from "node:path";
+var HOME_ISH = /(^|[\s"'=:])(~|\$HOME)\//;
+var URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+function extractPaths(text) {
+  const out = [];
+  const cleaned = text.replace(URL_RE, " ");
+  for (const m of cleaned.matchAll(/(?<![\w\-.:/])((?:~|\.{1,2}\/|\.\.(?=\s|$)|\/)[^\s"';|&)]*)/g)) {
+    const p = m[1];
+    if (p && p.length > 1) out.push(p);
+  }
+  return out;
+}
+function assessLocalReach(toolName, input, workspace) {
+  const o = input ?? {};
+  const str = (k) => typeof o[k] === "string" ? o[k] : "";
+  const ws = path3.resolve(workspace);
+  const insideWorkspace = (p) => {
+    if (p.startsWith("~")) return false;
+    const abs = path3.isAbsolute(p) ? path3.resolve(p) : path3.resolve(ws, p);
+    const rel = path3.relative(ws, abs);
+    return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+  };
+  if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "NotebookEdit") {
+    const p = str("file_path") || str("notebook_path");
+    if (p && !insideWorkspace(p)) return { reaches: true, evidence: p };
+    return { reaches: false, evidence: "" };
+  }
+  if (toolName === "Bash") {
+    const cmd = str("command");
+    if (HOME_ISH.test(cmd)) {
+      const m = cmd.match(HOME_ISH);
+      return { reaches: true, evidence: m ? cmd.slice(Math.max(0, m.index ?? 0), (m.index ?? 0) + 60).trim() : "~" };
+    }
+    for (const p of extractPaths(cmd)) {
+      if (!insideWorkspace(p)) return { reaches: true, evidence: p };
+    }
+    return { reaches: false, evidence: "" };
+  }
+  return { reaches: false, evidence: "" };
+}
+function localDecision(policy, reach) {
+  if (!reach.reaches) return { action: "ignore" };
+  if (policy === "always") return { action: "ignore" };
+  if (policy === "never")
+    return {
+      action: "deny",
+      reason: `Blocked: this touches ${reach.evidence}, which is outside the shared workspace. "Execution on local computer" is set to Never in Settings.`
+    };
+  return { action: "require", reason: `Touches ${reach.evidence}, outside the shared workspace (your own machine)` };
+}
+
+// packages/server/src/permissions/gateway.ts
+var log3 = logger("gateway");
+function summarize(namespacedToolName, input) {
+  const o = input ?? {};
+  const s = (k) => typeof o[k] === "string" ? o[k] : "";
+  const aliases = toolNameAliases(namespacedToolName);
+  const toolName = aliases[aliases.length - 1];
+  switch (toolName) {
+    case "Bash":
+      return `Run: ${s("command").slice(0, 200)}`;
+    case "Write":
+      return `Write file ${s("file_path")}`;
+    case "Edit":
+      return `Edit file ${s("file_path")}`;
+    case "Read":
+      return `Read file ${s("file_path")}`;
+    case "WebFetch":
+      return `Fetch ${s("url")}`;
+    case "send_to_bot":
+      return `Hand work to @${s("bot_slug")}`;
+    // Scope is the whole decision here: one named skill, or every skill in a repository.
+    case "install_skill":
+      return describeSkillSource(s("source"));
+    case "remove_skill":
+      return `Uninstall the skill "${s("slug")}"`;
+    default: {
+      if (toolName.startsWith("browser_")) {
+        const bits = [s("url"), s("selector"), s("text")].filter(Boolean).join(" ");
+        return `${toolName.replace("browser_", "Browser ")}: ${bits}`.trim();
+      }
+      const flat = serializeInput(input);
+      return `${toolName}: ${flat.slice(0, 180)}`;
+    }
+  }
+}
+var PermissionGateway = class {
+  constructor(store, bus, autoReviewer) {
+    this.store = store;
+    this.bus = bus;
+    this.autoReviewer = autoReviewer;
+  }
+  store;
+  bus;
+  autoReviewer;
+  pending = /* @__PURE__ */ new Map();
+  /**
+   * Decide whether a proposed tool call may run.
+   * Order: deterministic rules → auto review (advisory) → human approval card.
+   * A matching `require` rule can never be satisfied by auto review (outline §9).
+   */
+  async check(args) {
+    const { toolName, input, settings } = args;
+    const rules = this.store.listRules(true);
+    const decision = evaluateRules(rules, toolName, input);
+    const local = localDecision(settings.localExecution, assessLocalReach(toolName, input, args.workspace));
+    if (local.action === "deny") {
+      return { behavior: "deny", message: local.reason, via: "rule" };
+    }
+    if (local.action === "require" && decision.kind !== "require") {
+      return this.askHuman({ ...args, reason: local.reason });
+    }
+    if (decision.kind === "allow") {
+      log3.debug(`allow by rule ${decision.rule.id}: ${toolName}`);
+      return { behavior: "allow", reason: decision.rule.scopeNote || "Matched an allow rule", via: "rule" };
+    }
+    const requiredBy = decision.kind === "require" ? decision.rule : null;
+    if (!requiredBy && settings.autoReviewEnabled && this.autoReviewer) {
+      try {
+        const verdict = await this.autoReviewer.classify(toolName, input, args.botDescription);
+        if (verdict.verdict === "allow_ok")
+          return { behavior: "allow", reason: verdict.reason, via: "auto_review" };
+        if (verdict.verdict === "deny_suggested")
+          return this.askHuman({ ...args, reason: `Auto review flagged this: ${verdict.reason}` });
+        return this.askHuman({ ...args, reason: verdict.reason });
+      } catch (err) {
+        log3.warn("auto review failed; falling back to human approval", err);
+      }
+    }
+    return this.askHuman({
+      ...args,
+      reason: requiredBy ? requiredBy.scopeNote || "Matched a require-approval rule" : "No rule covers this action",
+      ruleId: requiredBy?.id ?? null
+    });
+  }
+  askHuman(args) {
+    const approval = this.store.createApproval({
+      botId: args.botId,
+      threadId: args.threadId,
+      toolName: args.toolName,
+      inputSummary: summarize(args.toolName, args.input),
+      rawInput: args.input,
+      reason: args.reason
+    });
+    if (args.ruleId) this.store.db.prepare(`UPDATE approvals SET rule_id=? WHERE id=?`).run(args.ruleId, approval.id);
+    const fresh = this.store.getApproval(approval.id);
+    args.onPending?.(fresh);
+    this.bus.publish({
+      type: "approval.pending",
+      threadId: args.threadId,
+      botId: args.botId,
+      approval: fresh
+    });
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(approval.id);
+        this.store.resolveApproval(approval.id, "expired", "user", null, "No response in time");
+        this.bus.publish({
+          type: "approval.resolved",
+          threadId: args.threadId,
+          botId: args.botId,
+          approval: this.store.getApproval(approval.id)
+        });
+        resolve({ behavior: "deny", message: "Approval request expired without a decision.", via: "timeout" });
+      }, LIMITS.APPROVAL_TIMEOUT_MS);
+      this.pending.set(approval.id, { approvalId: approval.id, resolve, timer });
+      args.signal?.addEventListener("abort", () => {
+        const p = this.pending.get(approval.id);
+        if (!p) return;
+        clearTimeout(p.timer);
+        this.pending.delete(approval.id);
+        this.store.resolveApproval(approval.id, "denied", "user", null, "Turn interrupted");
+        resolve({ behavior: "deny", message: "Interrupted.", via: "user" });
+      });
+    });
+  }
+  /** Resolve a pending approval from the UI. Returns the updated row. */
+  decide(approvalId, decision, alwaysRule) {
+    const p = this.pending.get(approvalId);
+    const existing = this.store.getApproval(approvalId);
+    if (!existing) return null;
+    if (existing.status !== "pending") return existing;
+    let ruleId = null;
+    if (decision === "allow" && alwaysRule) {
+      const rule = this.store.createRule({
+        kind: "allow",
+        toolPattern: alwaysRule.toolPattern,
+        inputPattern: alwaysRule.inputPattern ?? "",
+        scopeNote: alwaysRule.scopeNote ?? "Saved from an approval"
+      });
+      ruleId = rule.id;
+    }
+    const updated = this.store.resolveApproval(
+      approvalId,
+      decision === "allow" ? "allowed" : "denied",
+      "user",
+      ruleId,
+      decision === "allow" ? "Approved by you" : "Denied by you"
+    );
+    this.bus.publish({
+      type: "approval.resolved",
+      threadId: existing.threadId,
+      botId: existing.botId,
+      approval: updated
+    });
+    if (p) {
+      clearTimeout(p.timer);
+      this.pending.delete(approvalId);
+      p.resolve(
+        decision === "allow" ? { behavior: "allow", reason: "Approved by you", via: "user" } : { behavior: "deny", message: "You denied this action.", via: "user" }
+      );
+    }
+    return updated;
+  }
+  hasPending(approvalId) {
+    return this.pending.has(approvalId);
+  }
+  /** Cancel any pending approvals for a bot (used when a turn is interrupted). */
+  cancelForBot(botId) {
+    for (const [id, p] of [...this.pending]) {
+      const a = this.store.getApproval(id);
+      if (a?.botId !== botId) continue;
+      clearTimeout(p.timer);
+      this.pending.delete(id);
+      this.store.resolveApproval(id, "denied", "user", null, "Turn interrupted");
+      p.resolve({ behavior: "deny", message: "Interrupted.", via: "user" });
+    }
+  }
+};
+
+// packages/server/src/permissions/autoreview.ts
+import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
+
+// packages/server/src/agent/session.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var log4 = logger("agent");
+function resolveModel(tier) {
+  return tier;
+}
+function buildEnv(settings, base = process.env) {
+  const env = { ...base };
+  if (settings.billingMode !== "api") {
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_AUTH_TOKEN;
+  }
+  return env;
+}
+async function* runTurn(req) {
+  const abort = req.abortController ?? new AbortController();
+  const options = {
+    model: resolveModel(req.modelTier),
+    systemPrompt: { type: "preset", preset: "claude_code", append: req.systemPrompt },
+    cwd: req.cwd,
+    additionalDirectories: req.additionalDirectories,
+    abortController: abort,
+    includePartialMessages: true,
+    permissionMode: "default",
+    canUseTool: req.canUseTool,
+    mcpServers: req.mcpServers,
+    env: buildEnv(req.settings),
+    // Do not inherit the user's own Claude Code project settings into bot turns.
+    settingSources: [],
+    maxTurns: 60
+  };
+  if (req.resumeSessionId) options.resume = req.resumeSessionId;
+  if (req.skillPluginPath) {
+    options.plugins = [{ type: "local", path: req.skillPluginPath }];
+    options.skills = req.enabledSkills ?? [];
+  }
+  let q;
+  try {
+    q = query({ prompt: req.prompt, options });
+  } catch (err) {
+    yield { kind: "error", message: err instanceof Error ? err.message : String(err) };
+    return;
+  }
+  const seenToolIds = /* @__PURE__ */ new Set();
+  try {
+    for await (const msg of q) {
+      const m = msg;
+      switch (m.type) {
+        case "system":
+          if (m.subtype === "init" && m.session_id) yield { kind: "session", sessionId: m.session_id };
+          break;
+        case "stream_event": {
+          const ev = m.event;
+          if (ev?.type === "content_block_delta" && ev.delta?.type === "text_delta" && ev.delta.text)
+            yield { kind: "text", text: ev.delta.text };
+          break;
+        }
+        case "assistant": {
+          for (const block of m.message?.content ?? []) {
+            if (block.type === "tool_use" && !seenToolIds.has(block.id)) {
+              seenToolIds.add(block.id);
+              yield { kind: "tool_start", toolName: block.name, toolInput: block.input, toolUseId: block.id };
+            }
+          }
+          break;
+        }
+        case "user": {
+          for (const block of m.message?.content ?? []) {
+            if (block.type === "tool_result") {
+              const content = Array.isArray(block.content) ? block.content.map((c) => typeof c?.text === "string" ? c.text : "").join("\n") : typeof block.content === "string" ? block.content : "";
+              yield {
+                kind: "tool_result",
+                toolUseId: block.tool_use_id,
+                result: content.slice(0, 4e3),
+                isError: Boolean(block.is_error)
+              };
+            }
+          }
+          break;
+        }
+        case "result": {
+          const u = m.usage ?? {};
+          yield {
+            kind: "done",
+            sessionId: m.session_id,
+            text: typeof m.result === "string" ? m.result : void 0,
+            isError: m.subtype !== "success",
+            usage: {
+              model: m.modelUsage ? Object.keys(m.modelUsage)[0] ?? resolveModel(req.modelTier) : resolveModel(req.modelTier),
+              inputTokens: u.input_tokens ?? 0,
+              outputTokens: u.output_tokens ?? 0,
+              cacheReadTokens: u.cache_read_input_tokens ?? 0,
+              costUsd: m.total_cost_usd ?? 0
+            }
+          };
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  } catch (err) {
+    if (abort.signal.aborted) {
+      yield { kind: "error", message: "Interrupted." };
+      return;
+    }
+    log4.error("turn failed", err);
+    yield { kind: "error", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// packages/server/src/permissions/autoreview.ts
+var log5 = logger("autoreview");
+var SYSTEM = `You are the automated action reviewer for a local AI-teammate system.
+You judge ONE proposed tool call and answer with a single JSON object.
+
+Answer "allow_ok" only when the action is clearly routine, reversible and
+low-consequence \u2014 reading files, inspecting state, searching, navigating to a
+normal public page, writing inside the bot's own workspace.
+
+Answer "needs_human" when the action is consequential or ambiguous: sending or
+publishing anything, contacting a person, spending money, changing permissions,
+touching production, deleting or overwriting data outside the workspace,
+installing software, or anything whose blast radius you cannot determine.
+
+Answer "deny_suggested" when the action looks actively unsafe or like an attempt
+to exfiltrate credentials.
+
+You are advisory only and you are NOT the last line of defence. When in doubt,
+choose needs_human.
+
+Reply with ONLY: {"verdict":"allow_ok|needs_human|deny_suggested","reason":"<12 words max>"}`;
+var HaikuAutoReviewer = class {
+  constructor(getSettings, cwd) {
+    this.getSettings = getSettings;
+    this.cwd = cwd;
+  }
+  getSettings;
+  cwd;
+  async classify(toolName, input, botDescription) {
+    const prompt = `Bot's standing job description:
+${botDescription.slice(0, 800) || "(none)"}
+
+Proposed tool call:
+tool: ${toolName}
+summary: ${summarize(toolName, input)}
+raw input: ${JSON.stringify(input).slice(0, 1500)}`;
+    const q = query2({
+      prompt,
+      options: {
+        model: "haiku",
+        systemPrompt: SYSTEM,
+        cwd: this.cwd,
+        settingSources: [],
+        env: buildEnv(this.getSettings()),
+        maxTurns: 1,
+        allowedTools: [],
+        permissionMode: "default"
+      }
+    });
+    let out = "";
+    for await (const m of q) {
+      const msg = m;
+      if (msg.type === "result" && typeof msg.result === "string") out = msg.result;
+    }
+    return parseVerdict(out);
+  }
+};
+function parseVerdict(text) {
+  const fallback = { verdict: "needs_human", reason: "Reviewer output was unreadable" };
+  if (!text) return fallback;
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) return fallback;
+  try {
+    const o = JSON.parse(match[0]);
+    if (o.verdict === "allow_ok" || o.verdict === "needs_human" || o.verdict === "deny_suggested")
+      return { verdict: o.verdict, reason: String(o.reason ?? "").slice(0, 200) };
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+var NullAutoReviewer = class {
+  async classify() {
+    return { verdict: "needs_human", reason: "Auto review disabled" };
+  }
+};
+function makeAutoReviewer(getSettings, cwd) {
+  try {
+    return new HaikuAutoReviewer(getSettings, cwd);
+  } catch (err) {
+    log5.warn("falling back to null reviewer", err);
+    return new NullAutoReviewer();
+  }
+}
+
+// packages/server/src/bots/manager.ts
+import path5 from "node:path";
+import fs4 from "node:fs";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+
+// packages/server/src/memory/memory.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+function memoryDir(workspace, slug) {
+  return path4.join(workspace, "bots", slug, "memory");
+}
+function ensureMemoryDir(workspace, slug) {
+  const dir = memoryDir(workspace, slug);
+  fs3.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function readMemory(workspace, slug) {
+  const dir = memoryDir(workspace, slug);
+  if (!fs3.existsSync(dir)) return [];
+  return fs3.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((name) => ({ name, content: fs3.readFileSync(path4.join(dir, name), "utf8") }));
+}
+function writeMemory(workspace, slug, name, content) {
+  const dir = ensureMemoryDir(workspace, slug);
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "-");
+  fs3.writeFileSync(path4.join(dir, safe.endsWith(".md") ? safe : `${safe}.md`), content);
+}
+function deleteMemory(workspace, slug, name) {
+  const f = path4.join(memoryDir(workspace, slug), name.replace(/[^a-zA-Z0-9._-]/g, "-"));
+  if (fs3.existsSync(f)) fs3.unlinkSync(f);
+}
+function renderMemoryBlock(files) {
+  if (!files.length) return "";
+  const body = files.map((f) => `### ${f.name}
+${f.content.trim()}`).join("\n\n");
+  return `
+
+## Your memory
+Stable preferences and facts you recorded earlier. Memory is a working
+note, not an authoritative source \u2014 re-check the source system before any
+consequential decision.
+
+${body}`;
+}
+
+// packages/server/src/bots/prompt.ts
+function buildSystemPrompt(ctx) {
+  const { bot, workspace } = ctx;
+  const parts = [];
+  parts.push(`You are **${bot.name}**${bot.title ? `, ${bot.title}` : ""} \u2014 a persistent AI teammate in ant-bot.
+
+You are not a general chat assistant. You own a job and finish work end to end,
+then report back with evidence. You keep working across turns; your files,
+memory and browser sessions persist.`);
+  if (bot.description.trim()) {
+    parts.push(`## Your standing job description
+These are durable rules for how you work. They outrank any single message.
+
+${bot.description.trim()}`);
+  }
+  parts.push(`## Your computer
+You share one computer with every other bot on this account.
+- Shared workspace: \`${workspace}\` \u2014 keep durable project files here.
+- Your own folder: \`${workspace}/bots/${bot.slug}/\`
+- Files, logins and installed tools are visible to all bots. Bots are **not** a
+  security boundary. Do not store anything here another bot should not see.`);
+  const mem = renderMemoryBlock(readMemory(workspace, bot.slug));
+  if (mem) parts.push(mem.trim());
+  if (ctx.skills.length) {
+    parts.push(`## Your skills
+${ctx.skills.map((s) => `- **${s.name}** (${s.slug}): ${s.description}`).join("\n")}
+Read the skill file before following it.`);
+  }
+  const others = ctx.roster.filter((r) => r.slug !== bot.slug);
+  if (others.length) {
+    parts.push(`## Your teammates
+${others.map((r) => `- @${r.slug} \u2014 ${r.name}${r.title ? `, ${r.title}` : ""}`).join("\n")}
+
+Use the \`send_to_bot\` tool to hand work to a teammate when the job genuinely
+belongs to their role. Keep one owner per stage \u2014 do not fan the same task out
+to several bots at once.`);
+  }
+  if (ctx.isGroup) {
+    parts.push(`## Group conversation
+You are in a group chat. Other bots can see and reply to these messages.
+Answer only when the request is yours to own, or when you were @-mentioned.
+Say who should take the next step. Keep replies short \u2014 the humans are reading.`);
+  }
+  parts.push(`## How to work
+- Lead with the result. Put evidence \u2014 links, file paths, quoted output \u2014 under it.
+- Separate: facts found, assumptions, actions taken, actions awaiting approval,
+  open questions.
+- Write deliverables as real files in the workspace, not as walls of chat text.
+- Never guess at a credential. If a step needs a password, 2FA code or CAPTCHA,
+  stop and ask the human to take over the computer.
+- Some actions pause for the human's approval. That is normal \u2014 propose the
+  action and wait. Approval covers only the proposed step; it does not undo
+  anything you already did.`);
+  return parts.join("\n\n");
+}
+
+// packages/server/src/bots/manager.ts
+var log6 = logger("bots");
+var BotManager = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  queue = [];
+  running = /* @__PURE__ */ new Map();
+  draining = false;
+  get runningCount() {
+    return this.running.size;
+  }
+  get queuedCount() {
+    return this.queue.length;
+  }
+  isBusy(botId) {
+    return this.running.has(botId) || this.queue.some((j) => j.botId === botId);
+  }
+  /** Enqueue a turn. Interactive work sorts ahead of routine work. */
+  enqueue(job) {
+    const full = {
+      ...job,
+      id: newId(),
+      priority: job.priority ?? (job.origin === "routine" ? 10 : 0)
+    };
+    this.queue.push(full);
+    this.queue.sort((a, b2) => a.priority - b2.priority);
+    this.setState(full.botId, "queued");
+    void this.drain();
+    return full;
+  }
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      const max = this.deps.getSettings().maxConcurrentSessions ?? LIMITS.DEFAULT_MAX_CONCURRENT_SESSIONS;
+      while (this.queue.length && this.running.size < max) {
+        const idx = this.queue.findIndex((j) => !this.running.has(j.botId));
+        if (idx === -1) break;
+        const [job] = this.queue.splice(idx, 1);
+        void this.execute(job);
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  setState(botId, state, attention) {
+    const bot = this.deps.store.updateBot(botId, { state, ...attention ? { attention } : {} });
+    if (!bot) return;
+    this.deps.bus.publish({
+      type: "bot.state",
+      botId,
+      threadId: bot.threadId,
+      state: bot.state,
+      attention: bot.attention
+    });
+  }
+  interrupt(botId) {
+    const r = this.running.get(botId);
+    this.queue = this.queue.filter((j) => j.botId !== botId);
+    this.deps.gateway.cancelForBot(botId);
+    if (!r) {
+      this.setState(botId, "idle");
+      return false;
+    }
+    r.abort.abort();
+    return true;
+  }
+  /** Custom tools exposed to every bot turn: handoff, memory, secrets-safe helpers. */
+  buildToolServer(bot, threadId, hops) {
+    const { store, workspace } = this.deps;
+    return createSdkMcpServer({
+      name: "antbot",
+      version: "1.0.0",
+      tools: [
+        tool(
+          "send_to_bot",
+          "Hand work to another bot on this account. The recipient wakes, handles the request in its own thread, and can reply later. Use when the job genuinely belongs to that role.",
+          { bot_slug: z.string().describe('slug of the teammate, e.g. "writer"'), message: z.string().describe("the request, with all context they need") },
+          async (args) => {
+            const target = store.getBotBySlug(args.bot_slug);
+            if (!target) return { content: [{ type: "text", text: `No bot with slug "${args.bot_slug}". Use one of: ${store.listBots().map((b2) => b2.slug).join(", ")}` }] };
+            if (target.id === bot.id) return { content: [{ type: "text", text: "You cannot hand work to yourthis." }] };
+            if (hops + 1 > LIMITS.MAX_BOT_TO_BOT_HOPS)
+              return { content: [{ type: "text", text: `Hop limit of ${LIMITS.MAX_BOT_TO_BOT_HOPS} reached. Stop and report back to the human instead.` }] };
+            store.createMail({ fromBotId: bot.id, toBotId: target.id, contentMd: args.message, hops: hops + 1 });
+            this.postSystemCard(threadId, bot.id, { type: "handoff", fromBotId: bot.id, toBotId: target.id, note: args.message.slice(0, 300) });
+            this.enqueue({
+              botId: target.id,
+              threadId: target.threadId,
+              origin: "bot",
+              hops: hops + 1,
+              prompt: `**Handoff from @${bot.slug} (${bot.name}):**
+
+${args.message}
+
+---
+Handle this, then reply. If it belongs to someone else, say so rather than guessing.`
+            });
+            return { content: [{ type: "text", text: `Handed to @${target.slug}. They will pick it up and reply in their own thread.` }] };
+          }
+        ),
+        tool(
+          "remember",
+          "Save a durable preference or fact to your memory so it survives future turns. Use only for stable things, never for changing data.",
+          { title: z.string().describe("short kebab-case file name"), note: z.string().describe("the fact, in markdown") },
+          async (args) => {
+            const dir = ensureMemoryDir(workspace, bot.slug);
+            const file = path5.join(dir, `${args.title.replace(/[^a-zA-Z0-9._-]/g, "-")}.md`);
+            fs4.writeFileSync(file, args.note);
+            return { content: [{ type: "text", text: `Saved to memory: ${path5.basename(file)}` }] };
+          }
+        ),
+        tool(
+          "list_skills",
+          "List every skill installed on this account, with its slug. Check here before installing something that may already be present, and to find the exact slug to pass to remove_skill.",
+          {},
+          async () => {
+            const skills = this.deps.listSkills?.() ?? [];
+            if (!skills.length)
+              return { content: [{ type: "text", text: "No skills are installed." }] };
+            const lines = skills.map((sk) => `- ${sk.slug} \u2014 ${sk.name}${sk.description ? `: ${sk.description}` : ""}`);
+            return { content: [{ type: "text", text: `${skills.length} skill(s) installed:
+${lines.join("\n")}` }] };
+          }
+        ),
+        tool(
+          "install_skill",
+          "Install a skill so you (and other bots) can use it. This always stops for the human's approval first, because a skill is instructions that will steer future work and may ship scripts. Check list_skills before installing something you already have.\nInstall the NARROWEST source that covers the request. Accepted forms:\n  github.com/owner/repo/tree/<ref>/<dir>  one skill inside a repository \u2014 prefer this\n  https://host/path/SKILL.md              one skill, direct link\n  ./path/to/skill                         a local directory\n  owner/repo, github.com/owner/repo       EVERY skill in the repository\nA bare owner/repo pointing at a collection installs all of it. If the human asked for one named skill, point at that skill's directory instead; if you only have a link to the repo root, call this anyway and the error will list what is inside so you can narrow it.",
+          {
+            source: z.string().describe("prefer owner/repo/tree/<ref>/<dir> or a /SKILL.md link; owner/repo installs the whole repository"),
+            reason: z.string().describe("why you need this skill for the task at hand"),
+            install_all: z.boolean().optional().describe("set true only when the human has asked for every skill in a multi-skill source")
+          },
+          async (args) => {
+            if (!this.deps.installSkill)
+              return { content: [{ type: "text", text: "Skill installation is unavailable on this server." }] };
+            try {
+              const installed = await this.deps.installSkill(args.source, { allowMultiple: args.install_all === true });
+              if (!installed.length)
+                return { content: [{ type: "text", text: `No skill found at "${args.source}".` }] };
+              const names = installed.map((i2) => i2.name).join(", ");
+              const scripts = installed.flatMap((i2) => i2.executables);
+              const note = scripts.length ? ` Note for the human: this shipped ${scripts.length} script(s): ${scripts.join(", ")}.` : "";
+              return {
+                content: [{
+                  type: "text",
+                  text: `Installed: ${names}.${note} A skill must still be assigned to you in Bot settings before you can invoke it \u2014 ask the human to enable it, then retry.`
+                }]
+              };
+            } catch (err) {
+              const e = err;
+              if (e.name === "MultipleSkillsError" && Array.isArray(e.names)) {
+                const listed = e.names.slice(0, 40).join(", ");
+                const more = e.names.length > 40 ? `, and ${e.names.length - 40} more` : "";
+                return {
+                  content: [{
+                    type: "text",
+                    text: `Nothing was installed. "${args.source}" holds ${e.names.length} skills: ${listed}${more}.
+Pick the one you need and install just it, e.g. ${args.source.replace(/^https?:\/\//, "").replace(/\/$/, "")}/tree/main/<skill-directory>. Only pass install_all if the human has asked for all of them.`
+                  }]
+                };
+              }
+              return { content: [{ type: "text", text: `Install failed: ${e.message}` }] };
+            }
+          }
+        ),
+        tool(
+          "remove_skill",
+          "Uninstall a skill by slug \u2014 deletes its directory and its registration together. Use this rather than deleting skill directories with Bash, which would leave the registry pointing at files that no longer exist. Stops for the human's approval.",
+          {
+            slug: z.string().describe("the skill slug, exactly as list_skills reports it"),
+            reason: z.string().describe("why this skill should be removed")
+          },
+          async (args) => {
+            if (!this.deps.removeSkill)
+              return { content: [{ type: "text", text: "Skill removal is unavailable on this server." }] };
+            try {
+              const res = await this.deps.removeSkill(args.slug);
+              if (!res.removed) {
+                const known = (this.deps.listSkills?.() ?? []).map((sk) => sk.slug).join(", ");
+                return { content: [{ type: "text", text: `No skill with slug "${args.slug}". Installed: ${known || "none"}.` }] };
+              }
+              return { content: [{ type: "text", text: `Removed "${args.slug}"${res.name ? ` (${res.name})` : ""}.` }] };
+            } catch (err) {
+              return { content: [{ type: "text", text: `Remove failed: ${err.message}` }] };
+            }
+          }
+        ),
+        tool(
+          "request_secret",
+          "Ask the human for a secret value (API key, token). The value goes straight to the keychain and is never shown to you. Never ask for passwords in chat \u2014 ask for computer takeover instead.",
+          { name: z.string().describe("identifier, e.g. STRIPE_API_KEY"), reason: z.string() },
+          async (args) => {
+            this.deps.bus.publish({ type: "secret.request", botId: bot.id, threadId, requestId: newId(), name: args.name, reason: args.reason });
+            return { content: [{ type: "text", text: `Asked the human for "${args.name}". It will be injected into your environment as that variable name; you will never see the value. Continue once they confirm.` }] };
+          }
+        )
+      ]
+    });
+  }
+  postSystemCard(threadId, botId, card) {
+    const msg = this.deps.store.createMessage({ threadId, authorKind: "system", authorBotId: botId, cards: [card] });
+    this.deps.bus.publish({ type: "message.created", threadId, botId, message: msg });
+  }
+  async execute(job) {
+    const { store, bus, gateway, workspace, getSettings } = this.deps;
+    const bot = store.getBot(job.botId);
+    if (!bot) return;
+    const abort = new AbortController();
+    this.running.set(job.botId, { job, abort });
+    this.setState(job.botId, "running", "none");
+    const settings = getSettings();
+    const msg = store.createMessage({
+      threadId: job.threadId,
+      authorKind: "bot",
+      authorBotId: bot.id,
+      contentMd: "",
+      streaming: true
+    });
+    bus.publish({ type: "message.created", threadId: job.threadId, botId: bot.id, message: msg });
+    const thread = store.getThread(job.threadId);
+    const isGroup = thread?.kind === "group";
+    const botDir = path5.join(workspace, "bots", bot.slug);
+    fs4.mkdirSync(botDir, { recursive: true });
+    const botSkills = store.listBotSkills(bot.id);
+    const systemPrompt = buildSystemPrompt({
+      bot,
+      workspace,
+      skills: botSkills,
+      roster: store.listBots().map((x) => ({ slug: x.slug, name: x.name, title: x.title })),
+      isGroup
+    });
+    let text = "";
+    let ok = true;
+    let errorMessage = "";
+    const toolCards = /* @__PURE__ */ new Map();
+    const mcpServers = { antbot: this.buildToolServer(bot, job.threadId, job.hops) };
+    const browser = this.deps.browserTools?.(bot.id);
+    if (browser) mcpServers.browser = browser;
+    try {
+      for await (const ev of runTurn({
+        prompt: job.prompt,
+        resumeSessionId: bot.sessionId,
+        modelTier: bot.modelTier,
+        systemPrompt,
+        cwd: workspace,
+        settings,
+        abortController: abort,
+        mcpServers,
+        skillPluginPath: this.deps.skillPluginPath?.(),
+        // Skill names come from SKILL.md frontmatter, which is what the SDK matches on.
+        enabledSkills: botSkills.map((s) => s.name),
+        canUseTool: async (toolName, input) => {
+          this.setState(job.botId, "waiting_approval", "needs_attention");
+          const d = await gateway.check({
+            botId: bot.id,
+            threadId: job.threadId,
+            toolName,
+            input,
+            botDescription: bot.description,
+            settings,
+            signal: abort.signal,
+            workspace,
+            // Render the approval inline in the transcript so the human can act on it
+            // where the work is happening, not only in a global queue.
+            onPending: (approval) => {
+              const card = { type: "approval", approvalId: approval.id };
+              const idx = store.appendCard(msg.id, card);
+              bus.publish({
+                type: "message.card",
+                threadId: job.threadId,
+                botId: bot.id,
+                messageId: msg.id,
+                card,
+                cardIndex: idx
+              });
+            }
+          });
+          if (!abort.signal.aborted) this.setState(job.botId, "running");
+          return d.behavior === "allow" ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: d.message };
+        }
+      })) {
+        await this.applyEvent(ev, { job, bot, msgId: msg.id, toolCards });
+        if (ev.kind === "text" && ev.text) text += ev.text;
+        if (ev.kind === "done") {
+          if (ev.text && !text.trim()) text = ev.text;
+          ok = !ev.isError;
+        }
+        if (ev.kind === "error") {
+          ok = false;
+          errorMessage = ev.message ?? "Unknown error";
+        }
+      }
+    } catch (err) {
+      ok = false;
+      errorMessage = err instanceof Error ? err.message : String(err);
+      log6.error("turn crashed", err);
+    } finally {
+      this.running.delete(job.botId);
+    }
+    if (errorMessage) {
+      const idx = store.appendCard(msg.id, { type: "error", message: errorMessage });
+      bus.publish({ type: "message.card", threadId: job.threadId, botId: bot.id, messageId: msg.id, card: { type: "error", message: errorMessage }, cardIndex: idx });
+    }
+    const final = text.trim();
+    store.updateMessage(msg.id, { contentMd: final, streaming: false });
+    bus.publish({ type: "message.done", threadId: job.threadId, botId: bot.id, messageId: msg.id, contentMd: final });
+    const interrupted = abort.signal.aborted;
+    this.setState(job.botId, interrupted ? "interrupted" : "idle", "unread");
+    if (interrupted) this.setState(job.botId, "idle", "unread");
+    job.onDone?.(final || errorMessage, ok && !interrupted);
+    void this.drain();
+  }
+  async applyEvent(ev, ctx) {
+    const { store, bus } = this.deps;
+    const { job, bot, msgId, toolCards } = ctx;
+    switch (ev.kind) {
+      case "session":
+        if (ev.sessionId) store.updateBot(bot.id, { sessionId: ev.sessionId });
+        break;
+      case "text":
+        if (ev.text) {
+          const cur = store.getMessage(msgId);
+          store.updateMessage(msgId, { contentMd: (cur?.contentMd ?? "") + ev.text });
+          bus.publish({ type: "message.delta", threadId: job.threadId, botId: bot.id, messageId: msgId, delta: ev.text });
+        }
+        break;
+      case "tool_start": {
+        const card = {
+          type: "tool",
+          toolName: ev.toolName ?? "tool",
+          summary: summarizeTool(ev.toolName ?? "", ev.toolInput),
+          input: ev.toolInput,
+          status: "running"
+        };
+        const idx = store.appendCard(msgId, card);
+        if (ev.toolUseId) toolCards.set(ev.toolUseId, idx);
+        bus.publish({ type: "message.card", threadId: job.threadId, botId: bot.id, messageId: msgId, card, cardIndex: idx });
+        break;
+      }
+      case "tool_result": {
+        const idx = ev.toolUseId ? toolCards.get(ev.toolUseId) : void 0;
+        if (idx === void 0) break;
+        const cur = store.getMessage(msgId);
+        const existing = cur?.cards[idx];
+        if (!existing || existing.type !== "tool") break;
+        const denied = ev.isError && /denied|approval/i.test(ev.result ?? "");
+        const card = {
+          ...existing,
+          status: denied ? "denied" : ev.isError ? "error" : "ok",
+          result: (ev.result ?? "").slice(0, 2e3)
+        };
+        store.updateCard(msgId, idx, card);
+        bus.publish({ type: "message.card", threadId: job.threadId, botId: bot.id, messageId: msgId, card, cardIndex: idx });
+        break;
+      }
+      case "done":
+        if (ev.sessionId) store.updateBot(bot.id, { sessionId: ev.sessionId });
+        if (ev.usage) {
+          store.recordUsage({
+            botId: bot.id,
+            turnId: job.id,
+            model: ev.usage.model,
+            inputTokens: ev.usage.inputTokens,
+            outputTokens: ev.usage.outputTokens,
+            cacheReadTokens: ev.usage.cacheReadTokens,
+            costEstimate: ev.usage.costUsd
+          });
+          bus.publish({
+            type: "usage.tick",
+            threadId: job.threadId,
+            botId: bot.id,
+            inputTokens: ev.usage.inputTokens,
+            outputTokens: ev.usage.outputTokens,
+            model: ev.usage.model
+          });
+        }
+        break;
+      default:
+        break;
+    }
+  }
+};
+function summarizeTool(name, input) {
+  const o = input ?? {};
+  const s = (k) => typeof o[k] === "string" ? o[k] : "";
+  if (name === "Bash") return s("command").slice(0, 160);
+  if (name === "Read" || name === "Write" || name === "Edit") return s("file_path");
+  if (name === "WebFetch") return s("url");
+  if (name.includes("send_to_bot")) return `\u2192 @${s("bot_slug")}`;
+  if (name.includes("install_skill")) return describeSkillSource(s("source"));
+  if (name.includes("remove_skill")) return `remove skill: ${s("slug")}`;
+  if (name.includes("list_skills")) return "list installed skills";
+  if (name.includes("remember")) return `memory: ${s("title")}`;
+  if (name.startsWith("browser_") || name.includes("browser")) return [s("url"), s("selector"), s("text")].filter(Boolean).join(" ").slice(0, 160);
+  const j = JSON.stringify(input ?? {});
+  return j.length > 160 ? `${j.slice(0, 160)}\u2026` : j;
+}
+
+// packages/server/src/config/config.ts
+import fs6 from "node:fs";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+// packages/server/src/config/paths.ts
+import os from "node:os";
+import path6 from "node:path";
+import fs5 from "node:fs";
+function resolvePaths(root) {
+  const base = root ?? process.env.ANTBOT_HOME ?? path6.join(os.homedir(), ".ant-bot");
+  return {
+    root: base,
+    db: path6.join(base, "antbot.db"),
+    config: path6.join(base, "config.toml"),
+    workspace: path6.join(base, "workspace"),
+    attachments: path6.join(base, "attachments"),
+    skills: path6.join(base, "skills"),
+    browserProfile: path6.join(base, "browser-profile"),
+    backups: path6.join(base, "backups"),
+    secrets: path6.join(base, "secrets.json"),
+    logs: path6.join(base, "logs")
+  };
+}
+function ensureDirs(p) {
+  for (const d of [
+    p.root,
+    p.workspace,
+    p.attachments,
+    p.skills,
+    p.backups,
+    p.logs,
+    path6.join(p.workspace, "projects"),
+    path6.join(p.workspace, "bots")
+  ]) {
+    fs5.mkdirSync(d, { recursive: true });
+  }
+}
+
+// packages/server/src/config/config.ts
+var DEFAULT_PORT = 4780;
+var DEFAULT_HOST = "127.0.0.1";
+function loadConfig(root) {
+  const paths = resolvePaths(root);
+  ensureDirs(paths);
+  let raw = {};
+  if (fs6.existsSync(paths.config)) {
+    try {
+      raw = parseToml(fs6.readFileSync(paths.config, "utf8"));
+    } catch {
+      raw = {};
+    }
+  }
+  const server = raw.server ?? {};
+  const settings = SettingsSchema.parse({
+    ...typeof raw.settings === "object" && raw.settings ? raw.settings : {},
+    timezone: raw.settings?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC"
+  });
+  const cfg = {
+    paths,
+    settings,
+    port: Number(process.env.ANTBOT_PORT ?? server.port ?? DEFAULT_PORT),
+    host: String(server.host ?? DEFAULT_HOST)
+  };
+  if (!fs6.existsSync(paths.config)) writeConfig(cfg);
+  return cfg;
+}
+function writeConfig(cfg) {
+  fs6.writeFileSync(
+    cfg.paths.config,
+    stringifyToml({ server: { port: cfg.port, host: cfg.host }, settings: cfg.settings })
+  );
+}
+
+// packages/server/src/permissions/secrets.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+import crypto from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+var log7 = logger("secrets");
+var SERVICE = "ant-bot";
+var SecretToolBackend = class {
+  name = "libsecret (secret-tool)";
+  async set(key, value) {
+    await new Promise((resolve, reject) => {
+      const p = execFile(
+        "secret-tool",
+        ["store", "--label", `${SERVICE}: ${key}`, "service", SERVICE, "account", key],
+        (err) => err ? reject(err) : resolve()
+      );
+      p.stdin?.end(value);
+    });
+  }
+  async get(key) {
+    try {
+      const { stdout } = await exec("secret-tool", ["lookup", "service", SERVICE, "account", key]);
+      return stdout;
+    } catch {
+      return null;
+    }
+  }
+  async delete(key) {
+    try {
+      await exec("secret-tool", ["clear", "service", SERVICE, "account", key]);
+    } catch {
+    }
+  }
+  async list() {
+    return [];
+  }
+  // secret-tool has no reliable enumeration
+};
+var MacKeychainBackend = class {
+  name = "macOS Keychain";
+  async set(key, value) {
+    await exec("security", ["add-generic-password", "-U", "-s", SERVICE, "-a", key, "-w", value]);
+  }
+  async get(key) {
+    try {
+      const { stdout } = await exec("security", ["find-generic-password", "-s", SERVICE, "-a", key, "-w"]);
+      return stdout.replace(/\n$/, "");
+    } catch {
+      return null;
+    }
+  }
+  async delete(key) {
+    try {
+      await exec("security", ["delete-generic-password", "-s", SERVICE, "-a", key]);
+    } catch {
+    }
+  }
+  async list() {
+    return [];
+  }
+};
+var EncryptedFileBackend = class {
+  constructor(file) {
+    this.file = file;
+    this.keyFile = `${file}.key`;
+  }
+  file;
+  name = "encrypted file (weaker than a system keychain)";
+  keyFile;
+  key() {
+    if (!fs7.existsSync(this.keyFile)) {
+      fs7.mkdirSync(path7.dirname(this.keyFile), { recursive: true });
+      fs7.writeFileSync(this.keyFile, crypto.randomBytes(32), { mode: 384 });
+    }
+    return fs7.readFileSync(this.keyFile);
+  }
+  read() {
+    if (!fs7.existsSync(this.file)) return {};
+    try {
+      const raw = JSON.parse(fs7.readFileSync(this.file, "utf8"));
+      const key = this.key();
+      const out = {};
+      for (const [k, v] of Object.entries(raw)) {
+        const d = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(v.iv, "base64"));
+        d.setAuthTag(Buffer.from(v.tag, "base64"));
+        out[k] = Buffer.concat([d.update(Buffer.from(v.data, "base64")), d.final()]).toString("utf8");
+      }
+      return out;
+    } catch {
+      return {};
+    }
+  }
+  write(values) {
+    const key = this.key();
+    const out = {};
+    for (const [k, v] of Object.entries(values)) {
+      const iv = crypto.randomBytes(12);
+      const c = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const data = Buffer.concat([c.update(v, "utf8"), c.final()]);
+      out[k] = { iv: iv.toString("base64"), tag: c.getAuthTag().toString("base64"), data: data.toString("base64") };
+    }
+    fs7.mkdirSync(path7.dirname(this.file), { recursive: true });
+    fs7.writeFileSync(this.file, JSON.stringify(out), { mode: 384 });
+  }
+  async set(key, value) {
+    const v = this.read();
+    v[key] = value;
+    this.write(v);
+  }
+  async get(key) {
+    return this.read()[key] ?? null;
+  }
+  async delete(key) {
+    const v = this.read();
+    delete v[key];
+    this.write(v);
+  }
+  async list() {
+    return Object.keys(this.read());
+  }
+};
+async function pickBackend(fallbackFile) {
+  const has = async (bin, args) => {
+    try {
+      await exec(bin, args);
+      return true;
+    } catch (err) {
+      return err.code !== "ENOENT";
+    }
+  };
+  if (process.platform === "darwin" && await has("security", ["-h"])) return new MacKeychainBackend();
+  if (process.platform === "linux" && await has("secret-tool", ["--version"])) return new SecretToolBackend();
+  log7.warn("no system keychain available; using the encrypted-file fallback");
+  return new EncryptedFileBackend(fallbackFile);
+}
+var SecretsService = class {
+  constructor(backend, indexFile) {
+    this.backend = backend;
+    this.indexFile = indexFile;
+    if (fs7.existsSync(indexFile)) {
+      try {
+        this.names = new Set(JSON.parse(fs7.readFileSync(indexFile, "utf8")));
+      } catch {
+      }
+    }
+  }
+  backend;
+  indexFile;
+  names = /* @__PURE__ */ new Set();
+  persist() {
+    fs7.mkdirSync(path7.dirname(this.indexFile), { recursive: true });
+    fs7.writeFileSync(this.indexFile, JSON.stringify([...this.names]), { mode: 384 });
+  }
+  get backendName() {
+    return this.backend.name;
+  }
+  async set(name, value) {
+    await this.backend.set(name, value);
+    this.names.add(name);
+    this.persist();
+  }
+  async remove(name) {
+    await this.backend.delete(name);
+    this.names.delete(name);
+    this.persist();
+  }
+  /** Names only — values are never returned to the API surface. */
+  list() {
+    return [...this.names];
+  }
+  /** Build an env overlay for a tool subprocess. Values never touch the transcript. */
+  async envOverlay() {
+    const out = {};
+    for (const n of this.names) {
+      const v = await this.backend.get(n);
+      if (v !== null) out[n] = v;
+    }
+    return out;
+  }
+};
+
+// packages/server/src/app.ts
+var log8 = logger("app");
+async function optionalImport(name, load) {
+  try {
+    return await load();
+  } catch (err) {
+    log8.warn(`${name} module could not be loaded`, err.message);
+    return null;
+  }
+}
+async function createApp(opts = {}) {
+  const cfg = loadConfig(opts.root);
+  const db = openDb(cfg.paths.db, { backupsDir: cfg.paths.backups });
+  const store = new Store(db);
+  const persisted = store.getSettings();
+  const settingsCount = store.db.prepare(`SELECT COUNT(*) c FROM settings`).get();
+  if (!settingsCount.c) {
+    store.patchSettings(cfg.settings);
+  }
+  const getSettings = () => store.getSettings();
+  void persisted;
+  seedBuiltinRules(store);
+  const bus = new EventBus();
+  const reviewer = opts.withAgent === false ? new NullAutoReviewer() : makeAutoReviewer(getSettings, cfg.paths.workspace);
+  const gateway = new PermissionGateway(store, bus, reviewer);
+  const app = {
+    cfg,
+    db,
+    store,
+    bus,
+    gateway,
+    getSettings,
+    manager: void 0,
+    lastUserActivity: { at: Date.now() },
+    shutdown: async () => {
+    }
+  };
+  app.manager = new BotManager({
+    store,
+    bus,
+    gateway,
+    workspace: cfg.paths.workspace,
+    getSettings,
+    skillPluginPath: () => app.skillPluginPath,
+    installSkill: async (source, opts2) => {
+      if (!app.skills?.installFromSource) throw new Error("Skill installation is unavailable.");
+      const installed = await app.skills.installFromSource(source, opts2 ?? {});
+      return installed.map((i2) => ({
+        name: i2.skill.name,
+        executables: i2.executables
+      }));
+    },
+    listSkills: () => store.listSkills().map((sk) => ({ slug: sk.slug, name: sk.name, description: sk.description })),
+    // Routed through SkillStore so the directory and the registration go together — a bot
+    // deleting directories with Bash is what leaves the registry pointing at nothing.
+    removeSkill: async (slug) => {
+      if (!app.skills?.deleteSkill) throw new Error("Skill removal is unavailable.");
+      const skill = store.getSkillBySlug(slug);
+      if (!skill) return { removed: false };
+      app.skills.deleteSkill(skill.id);
+      return { removed: true, name: skill.name };
+    },
+    browserTools: (botId) => {
+      if (!app.browser?.toolServerFor) return void 0;
+      try {
+        return app.browser.toolServerFor(botId);
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  try {
+    app.secrets = new SecretsService(
+      await pickBackend(cfg.paths.secrets),
+      `${cfg.paths.secrets}.index`
+    );
+    log8.info(`secrets backend: ${app.secrets.backendName}`);
+  } catch (err) {
+    log8.warn("secrets backend unavailable", err.message);
+  }
+  await wireSkills(app);
+  await wireBrowser(app);
+  await wireScheduler(app);
+  app.shutdown = async () => {
+    try {
+      app.scheduler?.stop?.();
+    } catch {
+    }
+    try {
+      await app.browser?.shutdown?.();
+    } catch {
+    }
+    try {
+      db.close();
+    } catch {
+    }
+  };
+  return app;
+}
+async function wireSkills(app) {
+  try {
+    const mod = await optionalImport("skills", () => import("./skills-66WRX64H.js"));
+    const pluginMod = await optionalImport("skill plugin", () => import("./plugin-POMHVGD4.js"));
+    const Ctor = mod?.SkillStore ?? mod?.default;
+    if (!Ctor) return void log8.warn("skills subsystem unavailable: no SkillStore export");
+    const pluginRoot = app.cfg.paths.skills;
+    if (pluginMod?.ensureSkillPlugin) {
+      pluginMod.ensureSkillPlugin(pluginRoot);
+      const moved = pluginMod.migrateLegacyLayout?.(pluginRoot) ?? [];
+      if (moved.length) log8.info(`migrated ${moved.length} skill(s) into the plugin layout: ${moved.join(", ")}`);
+      app.skillPluginPath = pluginRoot;
+    }
+    const filesDir = pluginMod?.skillFilesDir?.(pluginRoot) ?? pluginRoot;
+    app.skills = new Ctor(app.store, filesDir);
+    const bundledMod = await optionalImport("bundled skills", () => import("./bundled-46DUK5PG.js"));
+    if (bundledMod?.syncBundledSkills) {
+      try {
+        const decisions = bundledMod.syncBundledSkills(filesDir);
+        const took = (action) => decisions.filter((d) => d.action === action).map((d) => d.slug);
+        const installed = took("install");
+        const updated = took("update");
+        const kept = [...took("skip-modified"), ...took("skip-foreign")];
+        if (installed.length) log8.info(`installed ${installed.length} bundled skill(s): ${installed.join(", ")}`);
+        if (updated.length) log8.info(`updated ${updated.length} bundled skill(s): ${updated.join(", ")}`);
+        if (kept.length) log8.info(`left ${kept.length} locally-modified skill(s) alone: ${kept.join(", ")}`);
+        const written = [...installed, ...updated, ...took("adopt")];
+        const renamed = app.skills?.refreshFromDisk?.(written) ?? [];
+        if (renamed.length) log8.info(`refreshed metadata for ${renamed.length} skill(s): ${renamed.join(", ")}`);
+      } catch (e) {
+        log8.warn("bundled skills not synced", e.message);
+      }
+    }
+    app.skills.syncFromDisk?.();
+    const fixed = app.skills.reconcile?.();
+    if (fixed?.repaired.length) log8.info(`repaired ${fixed.repaired.length} skill path(s): ${fixed.repaired.join(", ")}`);
+    if (fixed?.removed.length) log8.info(`dropped ${fixed.removed.length} skill row(s) with no files on disk`);
+    log8.info(`skills ready (${app.store.listSkills().length} registered)`);
+  } catch (err) {
+    log8.warn("skills subsystem unavailable", err.message);
+  }
+}
+async function wireBrowser(app) {
+  try {
+    const mod = await optionalImport("browser", () => import("./browser-OHRD7YI3.js"));
+    const Ctor = mod?.BrowserService ?? mod?.default;
+    if (!Ctor) return void log8.warn("browser subsystem unavailable: no BrowserService export");
+    const svc = new Ctor({ profileDir: app.cfg.paths.browserProfile, bus: app.bus, headless: true });
+    let toolsMod = null;
+    toolsMod = await optionalImport("browser tools", () => import("./tools-P5537ASX.js"));
+    const cache = /* @__PURE__ */ new Map();
+    svc.toolServerFor = (botId) => {
+      if (!toolsMod?.createBrowserToolServer) return void 0;
+      let s = cache.get(botId);
+      if (!s) {
+        s = toolsMod.createBrowserToolServer(svc, botId, app.cfg.paths.workspace);
+        cache.set(botId, s);
+      }
+      return s;
+    };
+    app.browser = svc;
+    log8.info("browser computer service ready");
+  } catch (err) {
+    log8.warn("browser subsystem unavailable", err.message);
+  }
+}
+async function wireScheduler(app) {
+  try {
+    const mod = await optionalImport("scheduler", () => import("./scheduler-Q7OHNGP6.js"));
+    const Ctor = mod?.Scheduler ?? mod?.default;
+    if (!Ctor) return void log8.warn("scheduler subsystem unavailable: no Scheduler export");
+    app.scheduler = new Ctor({
+      store: app.store,
+      bus: app.bus,
+      manager: app.manager,
+      getSettings: app.getSettings
+    });
+    app.scheduler.start?.();
+    log8.info(`scheduler started (${app.store.listRoutines().filter((r) => r.enabled).length} active routines)`);
+  } catch (err) {
+    log8.warn("scheduler subsystem unavailable", err.message);
+  }
+}
+function drainMailbox(app) {
+  let n = 0;
+  for (const bot of app.store.listBots()) {
+    for (const m of app.store.listMail(bot.id)) {
+      const from = app.store.getBot(m.fromBotId);
+      app.manager.enqueue({
+        botId: bot.id,
+        threadId: bot.threadId,
+        origin: "bot",
+        hops: m.hops,
+        prompt: `**Handoff from @${from?.slug ?? "unknown"}:**
+
+${m.contentMd}`
+      });
+      app.store.markDelivered(m.id);
+      n++;
+    }
+  }
+  return n;
+}
+function workspaceRelative(root, p) {
+  const resolved = path8.resolve(root, p);
+  const rel = path8.relative(root, resolved);
+  if (rel.startsWith("..") || path8.isAbsolute(rel)) return null;
+  return resolved;
+}
+
+// packages/server/src/bots/groups.ts
+import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
+var log9 = logger("groups");
+async function routeGroupMessage(args) {
+  const { text, members, mentionBotIds, mentionEveryone, settings, cwd } = args;
+  if (mentionEveryone) return members;
+  if (mentionBotIds?.length) {
+    const picked = members.filter((m) => mentionBotIds.includes(m.id));
+    if (picked.length) return picked;
+  }
+  const inline = members.filter((m) => new RegExp(`@${m.slug}\\b`, "i").test(text));
+  if (inline.length) return inline;
+  try {
+    const roster = members.map((m) => `- ${m.slug}: ${m.name}${m.title ? `, ${m.title}` : ""}. ${m.description.slice(0, 200)}`).join("\n");
+    const q = query3({
+      prompt: `Team:
+${roster}
+
+Message:
+${text.slice(0, 2e3)}
+
+Which single teammate should own this? Reply with only the slug.`,
+      options: {
+        model: "haiku",
+        systemPrompt: "You route work to the right teammate. Reply with exactly one slug from the list and nothing else.",
+        cwd,
+        settingSources: [],
+        env: buildEnv(settings),
+        maxTurns: 1,
+        allowedTools: []
+      }
+    });
+    let out = "";
+    for await (const m of q) {
+      const msg = m;
+      if (msg.type === "result" && typeof msg.result === "string") out = msg.result;
+    }
+    const slug = out.trim().toLowerCase().replace(/[^a-z0-9-]/g, "");
+    const found = members.find((m) => m.slug === slug);
+    if (found) return [found];
+  } catch (err) {
+    log9.warn("group router failed; defaulting to first member", err);
+  }
+  return members.slice(0, 1);
+}
+function parseMentions(text, members) {
+  const everyone = /@everyone\b/i.test(text);
+  const botIds = members.filter((m) => new RegExp(`@${m.slug}\\b`, "i").test(text)).map((m) => m.id);
+  return { botIds, everyone };
+}
+
+// packages/server/src/api/routes-core.ts
+import fs8 from "node:fs";
+import path9 from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVER_VERSION = readPackageVersion(
+  path9.dirname(fileURLToPath(import.meta.url)),
+  (p) => fs8.existsSync(p),
+  (p) => fs8.readFileSync(p, "utf8")
+);
+function registerCoreRoutes(f, app) {
+  const { store, bus, manager } = app;
+  f.get("/api/health", async () => ({
+    ok: true,
+    seq: bus.currentSeq,
+    version: SERVER_VERSION,
+    bots: store.listBots().length
+  }));
+  f.get(
+    "/api/bots",
+    async () => store.listBots().map((bot) => ({
+      bot,
+      thread: bot.threadId ? store.getThread(bot.threadId) : null,
+      lastMessageAt: bot.threadId ? store.lastMessageAt(bot.threadId) : 0
+    }))
+  );
+  f.post("/api/bots", async (req, reply) => {
+    const parsed = CreateBotRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: parsed.error.issues[0]?.message ?? "Invalid body" });
+    try {
+      return store.createBot(parsed.data);
+    } catch (err) {
+      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
+      throw err;
+    }
+  });
+  f.get("/api/bots/:id", async (req, reply) => {
+    const bot = store.getBot(req.params.id);
+    return bot ?? reply.code(404).send({ error: "No such bot" });
+  });
+  f.patch("/api/bots/:id", async (req, reply) => {
+    const parsed = UpdateBotRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    const bot = store.updateBot(req.params.id, parsed.data);
+    if (!bot) return reply.code(404).send({ error: "No such bot" });
+    bus.publish({ type: "bot.state", botId: bot.id, threadId: bot.threadId, state: bot.state, attention: bot.attention });
+    return bot;
+  });
+  f.delete("/api/bots/:id", async (req, reply) => {
+    if (!store.getBot(req.params.id)) return reply.code(404).send({ error: "No such bot" });
+    manager.interrupt(req.params.id);
+    store.deleteBot(req.params.id);
+    return { ok: true };
+  });
+  f.post("/api/bots/:id/duplicate", async (req, reply) => {
+    try {
+      const copy = store.duplicateBot(req.params.id);
+      return copy ?? reply.code(404).send({ error: "No such bot" });
+    } catch (err) {
+      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
+      throw err;
+    }
+  });
+  f.post("/api/bots/:id/stop", async (req) => ({
+    stopped: manager.interrupt(req.params.id)
+  }));
+  f.get("/api/bots/:id/memory", async (req, reply) => {
+    const bot = store.getBot(req.params.id);
+    if (!bot) return reply.code(404).send({ error: "No such bot" });
+    return readMemory(app.cfg.paths.workspace, bot.slug);
+  });
+  f.put("/api/bots/:id/memory", async (req, reply) => {
+    const bot = store.getBot(req.params.id);
+    if (!bot) return reply.code(404).send({ error: "No such bot" });
+    const { name, content } = req.body ?? {};
+    if (!name || typeof content !== "string") return reply.code(400).send({ error: "name and content are required" });
+    writeMemory(app.cfg.paths.workspace, bot.slug, name, content);
+    return { ok: true };
+  });
+  f.delete("/api/bots/:id/memory/:name", async (req, reply) => {
+    const bot = store.getBot(req.params.id);
+    if (!bot) return reply.code(404).send({ error: "No such bot" });
+    deleteMemory(app.cfg.paths.workspace, bot.slug, req.params.name);
+    return { ok: true };
+  });
+  f.get("/api/bots/:id/skills", async (req, reply) => {
+    if (!store.getBot(req.params.id)) return reply.code(404).send({ error: "No such bot" });
+    return store.listBotSkills(req.params.id);
+  });
+  f.put("/api/bots/:id/skills", async (req, reply) => {
+    if (!store.getBot(req.params.id)) return reply.code(404).send({ error: "No such bot" });
+    store.setBotSkills(req.params.id, req.body?.skillIds ?? []);
+    return { ok: true };
+  });
+  f.get("/api/threads", async () => store.listThreads());
+  f.post("/api/threads", async (req, reply) => {
+    const parsed = CreateThreadRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    try {
+      const members = parsed.data.memberBotIds.map((id) => store.getBot(id)).filter(Boolean);
+      if (members.length !== parsed.data.memberBotIds.length)
+        return reply.code(400).send({ error: "One or more bots do not exist" });
+      const title = parsed.data.title || members.map((m) => m.name).join(", ");
+      return store.createThread({ ...parsed.data, title });
+    } catch (err) {
+      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
+      throw err;
+    }
+  });
+  f.get("/api/threads/:id", async (req, reply) => {
+    const thread = store.getThread(req.params.id);
+    if (!thread) return reply.code(404).send({ error: "No such thread" });
+    const payload = { thread, messages: store.listMessages(thread.id) };
+    return payload;
+  });
+  f.delete("/api/threads/:id", async (req) => {
+    store.deleteThread(req.params.id);
+    return { ok: true };
+  });
+  f.post("/api/threads/:id/read", async (req, reply) => {
+    const thread = store.getThread(req.params.id);
+    if (!thread) return reply.code(404).send({ error: "No such thread" });
+    store.updateThread(thread.id, { lastReadAt: Date.now() });
+    for (const id of thread.memberBotIds) {
+      const bot = store.getBot(id);
+      if (bot && bot.attention !== "needs_attention") {
+        store.updateBot(id, { attention: "none" });
+        bus.publish({ type: "bot.state", botId: id, threadId: thread.id, state: bot.state, attention: "none" });
+      }
+    }
+    return { ok: true };
+  });
+  f.post("/api/threads/:id/messages", async (req, reply) => {
+    const parsed = PostMessageRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    const thread = store.getThread(req.params.id);
+    if (!thread) return reply.code(404).send({ error: "No such thread" });
+    app.lastUserActivity.at = Date.now();
+    const msg = store.createMessage({
+      threadId: thread.id,
+      authorKind: "user",
+      contentMd: parsed.data.contentMd,
+      replyToId: parsed.data.replyToId ?? null
+    });
+    if (parsed.data.attachmentIds?.length) {
+      try {
+        store.attachToMessage(parsed.data.attachmentIds, msg.id);
+      } catch (err) {
+        if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
+        throw err;
+      }
+    }
+    bus.publish({ type: "message.created", threadId: thread.id, botId: null, message: store.getMessage(msg.id) });
+    const attachments = store.listAttachmentsForMessage(msg.id);
+    const attachNote = attachments.length ? `
+
+Attached files (read them from disk):
+${attachments.map((a) => `- ${a.name} \u2192 ${a.path}`).join("\n")}` : "";
+    const prompt = parsed.data.contentMd + attachNote;
+    const members = thread.memberBotIds.map((id) => store.getBot(id)).filter(Boolean);
+    if (!members.length) return msg;
+    if (thread.kind === "dm") {
+      manager.enqueue({ botId: members[0].id, threadId: thread.id, prompt, origin: "user", hops: 0 });
+    } else {
+      const inline = parseMentions(parsed.data.contentMd, members);
+      const targets = await routeGroupMessage({
+        text: parsed.data.contentMd,
+        members,
+        mentionBotIds: parsed.data.mentionBotIds ?? inline.botIds,
+        mentionEveryone: parsed.data.mentionEveryone ?? inline.everyone,
+        settings: app.getSettings(),
+        cwd: app.cfg.paths.workspace
+      });
+      for (const t of targets)
+        manager.enqueue({ botId: t.id, threadId: thread.id, prompt, origin: "user", hops: 0 });
+    }
+    return msg;
+  });
+}
+
+// packages/server/src/api/routes-ops.ts
+import fs9 from "node:fs";
+import path10 from "node:path";
+function registerOpsRoutes(f, app) {
+  const { store, gateway, bus } = app;
+  f.get("/api/approvals", async () => store.listPendingApprovals());
+  f.post("/api/approvals/:id", async (req, reply) => {
+    const parsed = ApprovalDecisionRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    const updated = gateway.decide(req.params.id, parsed.data.decision, parsed.data.alwaysRule);
+    return updated ?? reply.code(404).send({ error: "No such approval" });
+  });
+  f.get("/api/rules", async () => store.listRules());
+  f.post("/api/rules", async (req, reply) => {
+    const parsed = CreateRuleRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    try {
+      new RegExp(parsed.data.inputPattern || "");
+    } catch {
+      return reply.code(400).send({ error: "inputPattern is not a valid regular expression" });
+    }
+    return store.createRule(parsed.data);
+  });
+  f.patch("/api/rules/:id", async (req, reply) => {
+    const rule = store.getRule(req.params.id);
+    if (!rule) return reply.code(404).send({ error: "No such rule" });
+    store.setRuleEnabled(rule.id, Boolean(req.body?.enabled));
+    return store.getRule(rule.id);
+  });
+  f.delete("/api/rules/:id", async (req, reply) => {
+    const rule = store.getRule(req.params.id);
+    if (!rule) return reply.code(404).send({ error: "No such rule" });
+    if (rule.builtin) return reply.code(400).send({ error: "Built-in rules cannot be deleted; disable it instead." });
+    store.deleteRule(rule.id);
+    return { ok: true };
+  });
+  f.get("/api/skills", async () => store.listSkills());
+  f.post("/api/skills", async (req, reply) => {
+    const parsed = CreateSkillRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    if (!app.skills?.writeSkill) return reply.code(503).send({ error: "Skills subsystem unavailable" });
+    return app.skills.writeSkill(parsed.data);
+  });
+  f.post("/api/skills/install", async (req, reply) => {
+    const source = (req.body?.source ?? "").trim();
+    if (!source) return reply.code(400).send({ error: 'A "source" is required' });
+    if (!app.skills?.installFromSource) return reply.code(503).send({ error: "Skills subsystem unavailable" });
+    try {
+      const installed = await app.skills.installFromSource(source, { allowMultiple: true });
+      return {
+        installed: installed.map((i2) => ({
+          skill: i2.skill,
+          executables: i2.executables,
+          manifest: i2.manifestText,
+          replaced: i2.replaced
+        }))
+      };
+    } catch (err) {
+      return reply.code(400).send({ error: err.message });
+    }
+  });
+  f.get("/api/skills/:id", async (req, reply) => {
+    const skill = store.getSkill(req.params.id);
+    if (!skill) return reply.code(404).send({ error: "No such skill" });
+    if (app.skills?.readSkill) return app.skills.readSkill(skill.id);
+    return { ...skill, bodyMd: "" };
+  });
+  f.delete("/api/skills/:id", async (req, reply) => {
+    const skill = store.getSkill(req.params.id);
+    if (!skill) return reply.code(404).send({ error: "No such skill" });
+    if (app.skills?.deleteSkill) app.skills.deleteSkill(skill.id);
+    else store.deleteSkill(skill.id);
+    return { ok: true };
+  });
+  f.get("/api/secrets", async () => ({
+    backend: app.secrets?.backendName ?? "unavailable",
+    names: app.secrets?.list() ?? []
+  }));
+  f.post("/api/secrets", async (req, reply) => {
+    if (!app.secrets) return reply.code(503).send({ error: "Secrets backend unavailable" });
+    const name = (req.body?.name ?? "").trim();
+    const value = req.body?.value ?? "";
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+      return reply.code(400).send({ error: "Name must be a valid environment-variable identifier" });
+    if (!value) return reply.code(400).send({ error: "A value is required" });
+    await app.secrets.set(name, value);
+    return { ok: true, names: app.secrets.list() };
+  });
+  f.delete("/api/secrets/:name", async (req, reply) => {
+    if (!app.secrets) return reply.code(503).send({ error: "Secrets backend unavailable" });
+    await app.secrets.remove(req.params.name);
+    return { ok: true, names: app.secrets.list() };
+  });
+  f.get("/api/routines", async (req) => store.listRoutines(req.query.botId));
+  f.post("/api/routines", async (req, reply) => {
+    const parsed = CreateRoutineRequest.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid body" });
+    if (!store.getBot(parsed.data.botId)) return reply.code(400).send({ error: "No such bot" });
+    try {
+      const routine = store.createRoutine({ ...parsed.data, timezone: parsed.data.timezone ?? app.getSettings().timezone });
+      app.scheduler?.reload?.(routine.id);
+      return routine;
+    } catch (err) {
+      if (err instanceof LimitError) return reply.code(409).send({ error: err.message, code: err.code });
+      throw err;
+    }
+  });
+  f.patch("/api/routines/:id", async (req, reply) => {
+    const routine = store.updateRoutine(req.params.id, req.body ?? {});
+    if (!routine) return reply.code(404).send({ error: "No such routine" });
+    app.scheduler?.reload?.(routine.id);
+    return routine;
+  });
+  f.delete("/api/routines/:id", async (req, reply) => {
+    if (!store.getRoutine(req.params.id)) return reply.code(404).send({ error: "No such routine" });
+    store.deleteRoutine(req.params.id);
+    app.scheduler?.reload?.(req.params.id);
+    return { ok: true };
+  });
+  f.get("/api/routines/:id/runs", async (req) => store.listRuns(req.params.id));
+  f.post("/api/routines/:id/test-run", async (req, reply) => {
+    const routine = store.getRoutine(req.params.id);
+    if (!routine) return reply.code(404).send({ error: "No such routine" });
+    if (!app.scheduler?.testRun) return reply.code(503).send({ error: "Scheduler unavailable" });
+    const runId = await app.scheduler.testRun(routine.id);
+    return { runId };
+  });
+  f.post("/api/attachments", async (req, reply) => {
+    const anyReq = req;
+    if (typeof anyReq.file !== "function") return reply.code(400).send({ error: "Expected a multipart upload" });
+    const part = await anyReq.file();
+    if (!part) return reply.code(400).send({ error: "No file in request" });
+    const buf = await part.toBuffer();
+    const safe = String(part.filename ?? "file").replace(/[^a-zA-Z0-9._-]/g, "_");
+    const dest = path10.join(app.cfg.paths.attachments, `${Date.now()}-${safe}`);
+    fs9.mkdirSync(path10.dirname(dest), { recursive: true });
+    fs9.writeFileSync(dest, buf);
+    try {
+      return store.createAttachment({
+        messageId: null,
+        path: dest,
+        name: safe,
+        mime: part.mimetype ?? "application/octet-stream",
+        bytes: buf.byteLength
+      });
+    } catch (err) {
+      fs9.unlinkSync(dest);
+      if (err instanceof LimitError) return reply.code(413).send({ error: err.message, code: err.code });
+      throw err;
+    }
+  });
+  f.get("/api/attachments/:id", async (req, reply) => {
+    const a = store.getAttachment(req.params.id);
+    if (!a || !fs9.existsSync(a.path)) return reply.code(404).send({ error: "No such attachment" });
+    return reply.type(a.mime).send(fs9.createReadStream(a.path));
+  });
+  f.get("/api/usage", async () => {
+    const rows = store.listUsage(0);
+    const totals = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+    const byBot = /* @__PURE__ */ new Map();
+    const byDay = /* @__PURE__ */ new Map();
+    const byModel = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      totals.inputTokens += r.inputTokens;
+      totals.outputTokens += r.outputTokens;
+      totals.cacheReadTokens += r.cacheReadTokens;
+      const day = new Date(r.createdAt).toISOString().slice(0, 10);
+      for (const [map, key] of [[byBot, r.botId], [byDay, day], [byModel, r.model]]) {
+        const cur = map.get(key) ?? { inputTokens: 0, outputTokens: 0 };
+        cur.inputTokens += r.inputTokens;
+        cur.outputTokens += r.outputTokens;
+        map.set(key, cur);
+      }
+    }
+    return {
+      totals,
+      byBot: [...byBot].map(([botId, v]) => ({ botId, botName: store.getBot(botId)?.name ?? "deleted", ...v })),
+      byDay: [...byDay].map(([day, v]) => ({ day, ...v })).sort((a, b2) => a.day.localeCompare(b2.day)),
+      byModel: [...byModel].map(([model, v]) => ({ model, ...v }))
+    };
+  });
+  f.get("/api/search", async (req) => {
+    const q = (req.query.q ?? "").trim();
+    if (!q) return [];
+    const out = [];
+    for (const b2 of store.listBots()) {
+      if (b2.name.toLowerCase().includes(q.toLowerCase()) || b2.title.toLowerCase().includes(q.toLowerCase()))
+        out.push({ kind: "bot", id: b2.id, threadId: b2.threadId, botId: b2.id, title: b2.name, snippet: b2.title || b2.description.slice(0, 120), createdAt: b2.createdAt });
+    }
+    for (const m of store.searchMessages(q)) {
+      const idx = m.contentMd.toLowerCase().indexOf(q.toLowerCase());
+      const start = Math.max(0, idx - 60);
+      out.push({
+        kind: "message",
+        id: m.id,
+        threadId: m.threadId,
+        botId: m.authorBotId,
+        title: m.authorKind === "user" ? "You" : store.getBot(m.authorBotId ?? "")?.name ?? "Bot",
+        snippet: `${start > 0 ? "\u2026" : ""}${m.contentMd.slice(start, start + 180)}`,
+        createdAt: m.createdAt
+      });
+    }
+    for (const r of store.listRoutines()) {
+      if (r.name.toLowerCase().includes(q.toLowerCase()))
+        out.push({ kind: "routine", id: r.id, threadId: null, botId: r.botId, title: r.name, snippet: r.cronExpr, createdAt: r.createdAt });
+    }
+    return out.slice(0, 50);
+  });
+  f.get("/api/settings", async () => store.getSettings());
+  f.patch("/api/settings", async (req, reply) => {
+    const parsed = SettingsPatchSchema.safeParse(req.body);
+    if (!parsed.success) return reply.code(400).send({ error: "Invalid settings" });
+    const next = store.patchSettings(parsed.data);
+    app.scheduler?.syncAll?.();
+    bus.publish({ type: "notify", botId: null, threadId: null, title: "Settings updated", body: "", level: "info" });
+    return next;
+  });
+  f.get("/api/workspace/tree", async (req, reply) => {
+    const root = app.cfg.paths.workspace;
+    const target = workspaceRelative(root, req.query.path ?? ".");
+    if (!target) return reply.code(400).send({ error: "Path is outside the workspace" });
+    if (!fs9.existsSync(target)) return [];
+    return fs9.readdirSync(target, { withFileTypes: true }).map((d) => {
+      const full = path10.join(target, d.name);
+      let bytes = 0;
+      try {
+        bytes = d.isFile() ? fs9.statSync(full).size : 0;
+      } catch {
+      }
+      return { name: d.name, path: path10.relative(root, full), dir: d.isDirectory(), bytes };
+    }).sort((a, b2) => a.dir === b2.dir ? a.name.localeCompare(b2.name) : a.dir ? -1 : 1);
+  });
+  f.get("/api/workspace/file", async (req, reply) => {
+    const root = app.cfg.paths.workspace;
+    const target = workspaceRelative(root, req.query.path ?? "");
+    if (!target || !fs9.existsSync(target) || !fs9.statSync(target).isFile())
+      return reply.code(404).send({ error: "No such file" });
+    const ext = path10.extname(target).toLowerCase();
+    const mime = {
+      ".md": "text/markdown",
+      ".txt": "text/plain",
+      ".json": "application/json",
+      ".csv": "text/csv",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".html": "text/html"
+    };
+    return reply.type(mime[ext] ?? "application/octet-stream").send(fs9.createReadStream(target));
+  });
+  f.get("/api/computer/status", async () => {
+    if (!app.browser?.status) return { available: false, reason: "Browser service not built", mode: "host", headless: true, pages: [] };
+    try {
+      return await app.browser.status();
+    } catch (err) {
+      return { available: false, reason: err.message, mode: "host", headless: true, pages: [] };
+    }
+  });
+  f.post("/api/computer/takeover", async (req, reply) => {
+    if (!app.browser?.takeOver) return reply.code(503).send({ error: "Browser service unavailable" });
+    return app.browser.takeOver(req.body?.botId ?? "shared");
+  });
+  f.delete("/api/computer/takeover", async (req, reply) => {
+    if (!app.browser?.returnControl) return reply.code(503).send({ error: "Browser service unavailable" });
+    await app.browser.returnControl(req.body?.botId ?? "shared");
+    return { ok: true };
+  });
+}
+
+// packages/server/src/api/server.ts
+var log10 = logger("server");
+var require_ = createRequire(import.meta.url);
+function resolveWebDist() {
+  return findWebDist(
+    nodeLocateDeps(path11.dirname(fileURLToPath2(import.meta.url)), (spec) => {
+      try {
+        return require_.resolve(spec);
+      } catch {
+        return null;
+      }
+    })
+  );
+}
+async function startServer(opts = {}) {
+  const app = await createApp({ root: opts.root, withAgent: opts.withAgent });
+  const fastify = Fastify({ logger: false, bodyLimit: LIMITS.MAX_VIDEO_ATTACHMENT_BYTES });
+  fastify.addHook("onRequest", (req, _reply, done) => {
+    const len = req.headers["content-length"];
+    const ct = req.headers["content-type"];
+    if ((len === "0" || len === void 0) && ct?.includes("application/json")) {
+      delete req.headers["content-type"];
+    }
+    done();
+  });
+  await fastify.register(cors, { origin: true });
+  await fastify.register(multipart, {
+    limits: { fileSize: LIMITS.MAX_VIDEO_ATTACHMENT_BYTES, files: LIMITS.MAX_ATTACHMENTS_PER_MESSAGE }
+  });
+  await fastify.register(websocket);
+  registerCoreRoutes(fastify, app);
+  registerOpsRoutes(fastify, app);
+  fastify.register(async (scope) => {
+    scope.get("/api/events", { websocket: true }, (socket) => {
+      const send = (payload) => {
+        try {
+          if (socket.readyState === 1) socket.send(JSON.stringify(payload));
+        } catch {
+        }
+      };
+      const unsubscribe = app.bus.subscribe(send);
+      send({ type: "hello", seq: app.bus.currentSeq, threadId: null, botId: null });
+      socket.on("message", (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString());
+          if (msg.type === "resume" && typeof msg.seq === "number")
+            for (const e of app.bus.since(msg.seq)) send(e);
+        } catch {
+        }
+      });
+      socket.on("close", unsubscribe);
+      socket.on("error", unsubscribe);
+    });
+    scope.get("/api/computer/screencast/:botId", { websocket: true }, async (socket, req) => {
+      const botId = req.params.botId;
+      if (!app.browser?.startScreencast) {
+        try {
+          socket.send(JSON.stringify({ type: "error", message: "Browser service unavailable" }));
+        } catch {
+        }
+        socket.close();
+        return;
+      }
+      let stop;
+      try {
+        stop = await app.browser.startScreencast(botId, (data, w, h) => {
+          try {
+            if (socket.readyState === 1) socket.send(JSON.stringify({ type: "frame", data, w, h }));
+          } catch {
+          }
+        });
+      } catch (err) {
+        try {
+          socket.send(JSON.stringify({ type: "error", message: err.message }));
+        } catch {
+        }
+        socket.close();
+        return;
+      }
+      socket.on("close", () => stop?.());
+      socket.on("error", () => stop?.());
+    });
+  });
+  if (opts.serveStatic !== false) {
+    const dist = resolveWebDist();
+    if (dist) {
+      await fastify.register(fastifyStatic, { root: dist, prefix: "/" });
+      fastify.setNotFoundHandler((req, reply) => {
+        if (req.url.startsWith("/api")) return reply.code(404).send({ error: "Not found" });
+        return reply.sendFile("index.html");
+      });
+      log10.info(`serving UI from ${dist}`);
+    } else {
+      log10.warn("web UI not built \u2014 run `pnpm --filter @antbot/web build`");
+      fastify.setNotFoundHandler((req, reply) => {
+        if (req.url.startsWith("/api")) return reply.code(404).send({ error: "Not found" });
+        return reply.type("text/html").send(
+          `<!doctype html><meta charset=utf-8><title>ant-bot</title>
+           <body style="font-family:system-ui;background:#0b0d10;color:#e6e8eb;padding:3rem">
+           <h1>ant-bot daemon is running</h1>
+           <p>The web UI has not been built yet. Run:</p>
+           <pre style="background:#151922;padding:1rem;border-radius:8px">pnpm --filter @antbot/web build</pre>
+           <p>The API is live at <code>/api/health</code>.</p>`
+        );
+      });
+    }
+  }
+  fastify.setErrorHandler((err, _req, reply) => {
+    log10.error("request failed", err);
+    const e = err;
+    const code = e.statusCode && e.statusCode >= 400 ? e.statusCode : 500;
+    reply.code(code).send({ error: e.message ?? "Internal error" });
+  });
+  const port = opts.port ?? app.cfg.port;
+  const host = opts.host ?? app.cfg.host;
+  await fastify.listen({ port, host });
+  const url = `http://${host}:${port}`;
+  const delivered = drainMailbox(app);
+  if (delivered) log10.info(`redelivered ${delivered} queued handoff message(s)`);
+  const stale = app.store.listBots().filter((b2) => b2.state === "running" || b2.state === "queued");
+  for (const b2 of stale) app.store.updateBot(b2.id, { state: "idle" });
+  app.db.prepare(`UPDATE messages SET streaming=0 WHERE streaming=1`).run();
+  app.db.prepare(`UPDATE approvals SET status='expired', reason='Daemon restarted' WHERE status='pending'`).run();
+  app.db.prepare(`UPDATE routine_runs SET status='interrupted', finished_at=? WHERE status='running'`).run(Date.now());
+  log10.info(`ant-bot listening on ${url}`);
+  return {
+    fastify,
+    app,
+    url,
+    close: async () => {
+      await fastify.close();
+      await app.shutdown();
+    }
+  };
+}
+export {
+  BUILTIN_RULES,
+  BotManager,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  EventBus,
+  PermissionGateway,
+  Store,
+  buildEnv,
+  buildSystemPrompt,
+  createApp,
+  ensureDirs,
+  evaluateRules,
+  globToRegExp,
+  loadConfig,
+  openDb,
+  parseVerdict,
+  resolveModel,
+  resolvePaths,
+  ruleMatches,
+  runTurn,
+  serializeInput,
+  startServer,
+  summarize
+};
+//# sourceMappingURL=server.js.map