botinabox 0.1.0

package/dist/index.js

@@ -0,0 +1,2965 @@
+// src/shared/constants.ts
+var EVENTS = {
+  // Cost
+  COST_RECORDED: "cost.recorded",
+  // Agent
+  AGENT_CREATED: "agent.created",
+  AGENT_STATUS_CHANGED: "agent.status_changed",
+  BUDGET_EXCEEDED: "budget.exceeded",
+  // Task
+  TASK_CREATED: "task.created",
+  TASK_COMPLETED: "task.completed",
+  TASK_FAILED: "task.failed",
+  TASK_CANCELLED: "task.cancelled",
+  // Run
+  RUN_STARTED: "run.started",
+  RUN_COMPLETED: "run.completed",
+  RUN_FAILED: "run.failed",
+  // Message pipeline
+  MESSAGE_INBOUND: "message.inbound",
+  MESSAGE_ROUTED: "message.routed",
+  MESSAGE_PROCESSED: "message.processed",
+  MESSAGE_OUTBOUND: "message.outbound",
+  MESSAGE_SENT: "message.sent",
+  // Updates
+  UPDATE_AVAILABLE: "update.available",
+  UPDATE_STARTED: "update.started",
+  UPDATE_COMPLETED: "update.completed",
+  UPDATE_FAILED: "update.failed",
+  // Workflow
+  WORKFLOW_STARTED: "workflow.started",
+  WORKFLOW_STEP_COMPLETED: "workflow.step_completed",
+  WORKFLOW_COMPLETED: "workflow.completed",
+  WORKFLOW_FAILED: "workflow.failed"
+};
+var DEFAULTS = {
+  TASK_POLL_INTERVAL_MS: 3e4,
+  NOTIFICATION_POLL_INTERVAL_MS: 5e3,
+  HEARTBEAT_INTERVAL_MS: 3e5,
+  // 5 minutes
+  ORPHAN_REAP_INTERVAL_MS: 3e5,
+  // 5 minutes
+  STALE_RUN_THRESHOLD_MS: 18e5,
+  // 30 minutes
+  STALE_TASK_AGE_MS: 72e5,
+  // 2 hours
+  MAX_CHAIN_DEPTH: 5,
+  MAX_NOTIFICATION_RETRIES: 3,
+  UPDATE_CHECK_INTERVAL_MS: 864e5,
+  // 24 hours
+  RENDER_WATCH_INTERVAL_MS: 3e4,
+  DATA_PATH: "./data/bot.db",
+  RENDER_OUTPUT_DIR: "./context",
+  LOG_PATH_TEMPLATE: "./data/runs/{runId}.ndjson",
+  BUDGET_WARN_PERCENT: 80
+};
+var TASK_STATUSES = [
+  "backlog",
+  "todo",
+  "in_progress",
+  "in_review",
+  "done",
+  "blocked",
+  "cancelled"
+];
+var AGENT_STATUSES = [
+  "idle",
+  "running",
+  "paused",
+  "terminated",
+  "error"
+];
+var RUN_STATUSES = [
+  "queued",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled"
+];
+
+// src/core/hooks/hook-bus.ts
+var HookBus = class {
+  registrations = /* @__PURE__ */ new Map();
+  nextId = 0;
+  register(event, handler, opts) {
+    const reg = {
+      event,
+      handler,
+      priority: opts?.priority ?? 50,
+      once: opts?.once ?? false,
+      filter: opts?.filter,
+      id: this.nextId++
+    };
+    const list = this.registrations.get(event) ?? [];
+    list.push(reg);
+    list.sort((a, b) => a.priority - b.priority || a.id - b.id);
+    this.registrations.set(event, list);
+    return () => {
+      const arr = this.registrations.get(event);
+      if (!arr) return;
+      const idx = arr.indexOf(reg);
+      if (idx !== -1) arr.splice(idx, 1);
+    };
+  }
+  async emit(event, context) {
+    const list = this.registrations.get(event);
+    if (!list || list.length === 0) return;
+    const snapshot = [...list];
+    const toRemove = [];
+    for (const reg of snapshot) {
+      if (reg.filter) {
+        const matches = Object.entries(reg.filter).every(([k, v]) => context[k] === v);
+        if (!matches) continue;
+      }
+      try {
+        await reg.handler(context);
+      } catch (err) {
+        console.error(`[HookBus] Handler error on event "${event}":`, err);
+      }
+      if (reg.once) toRemove.push(reg);
+    }
+    for (const r of toRemove) {
+      const arr = this.registrations.get(event);
+      if (!arr) continue;
+      const idx = arr.indexOf(r);
+      if (idx !== -1) arr.splice(idx, 1);
+    }
+  }
+  /** Emit synchronously (use only when async is not needed) */
+  emitSync(event, context) {
+    const list = this.registrations.get(event);
+    if (!list || list.length === 0) return;
+    const snapshot = [...list];
+    const toRemove = [];
+    for (const reg of snapshot) {
+      if (reg.filter) {
+        const matches = Object.entries(reg.filter).every(([k, v]) => context[k] === v);
+        if (!matches) continue;
+      }
+      try {
+        const result = reg.handler(context);
+        if (result instanceof Promise) {
+          result.catch((err) => console.error(`[HookBus] Async handler error on event "${event}":`, err));
+        }
+      } catch (err) {
+        console.error(`[HookBus] Handler error on event "${event}":`, err);
+      }
+      if (reg.once) toRemove.push(reg);
+    }
+    for (const r of toRemove) {
+      const arr = this.registrations.get(event);
+      if (!arr) continue;
+      const idx = arr.indexOf(r);
+      if (idx !== -1) arr.splice(idx, 1);
+    }
+  }
+  hasListeners(event) {
+    return (this.registrations.get(event)?.length ?? 0) > 0;
+  }
+  listRegistered() {
+    const result = [];
+    for (const [k, v] of this.registrations) {
+      if (v.length > 0) result.push(k);
+    }
+    return result;
+  }
+  /** Remove all handlers for an event, or all handlers if no event given */
+  clear(event) {
+    if (event) {
+      this.registrations.delete(event);
+    } else {
+      this.registrations.clear();
+    }
+  }
+};
+
+// src/core/config/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/core/config/defaults.ts
+var DEFAULT_CONFIG = {
+  data: {
+    path: "./data/bot.db",
+    walMode: true
+  },
+  channels: {},
+  agents: [],
+  providers: {},
+  models: {
+    aliases: {
+      fast: "claude-haiku-4-5",
+      smart: "claude-opus-4-6",
+      balanced: "claude-sonnet-4-6"
+    },
+    default: "smart",
+    routing: {
+      conversation: "fast",
+      task_execution: "smart",
+      classification: "fast"
+    },
+    fallbackChain: []
+  },
+  entities: {},
+  security: {
+    fieldLengthLimits: { default: 65535 }
+  },
+  render: {
+    outputDir: "./context",
+    watchIntervalMs: 3e4
+  },
+  updates: {
+    policy: "auto-compatible",
+    checkIntervalMs: 864e5
+  },
+  budget: {
+    warnPercent: 80
+  }
+};
+
+// src/core/config/interpolate.ts
+function interpolateEnv(value, env = process.env) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => {
+      const envVal = env[name];
+      if (envVal === void 0) {
+        return `\${${name}}`;
+      }
+      return envVal;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateEnv(item, env));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = interpolateEnv(v, env);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/core/config/loader.ts
+function deepMerge(base, override) {
+  if (override === void 0 || override === null) return base;
+  if (base === void 0 || base === null) return override;
+  if (typeof base !== "object" || typeof override !== "object") return override;
+  if (Array.isArray(override)) return override;
+  const result = { ...base };
+  for (const [k, v] of Object.entries(override)) {
+    if (v !== void 0) {
+      result[k] = deepMerge(result[k], v);
+    }
+  }
+  return result;
+}
+function loadConfig(opts) {
+  const configPath = opts?.configPath ?? "botinabox.config.yml";
+  const errors = [];
+  let fileConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      const parsed = parseYaml(raw);
+      fileConfig = interpolateEnv(parsed, opts?.env ?? process.env);
+    } catch (err) {
+      errors.push({ field: "configPath", message: `Failed to parse ${configPath}: ${String(err)}` });
+    }
+  }
+  const merged = deepMerge(
+    deepMerge(DEFAULT_CONFIG, fileConfig),
+    opts?.overrides ?? {}
+  );
+  return { config: Object.freeze(merged), errors };
+}
+var _config = null;
+function getConfig() {
+  if (!_config) throw new Error("Config not loaded \u2014 call loadConfig() first");
+  return _config;
+}
+function initConfig(opts) {
+  const { config, errors } = loadConfig(opts);
+  _config = config;
+  return errors;
+}
+function _resetConfig() {
+  _config = null;
+}
+
+// src/core/config/schema.ts
+import Ajv from "ajv";
+var ajv = new Ajv({ allErrors: true, coerceTypes: false });
+var BOT_CONFIG_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  properties: {
+    data: {
+      type: "object",
+      required: ["path", "walMode"],
+      properties: {
+        path: { type: "string", minLength: 1 },
+        walMode: { type: "boolean" },
+        backupDir: { type: "string" }
+      }
+    },
+    models: {
+      type: "object",
+      required: ["aliases", "default", "routing", "fallbackChain"],
+      properties: {
+        aliases: { type: "object", additionalProperties: { type: "string" } },
+        default: { type: "string", minLength: 1 },
+        routing: { type: "object", additionalProperties: { type: "string" } },
+        fallbackChain: { type: "array", items: { type: "string" } },
+        costLimit: {
+          type: "object",
+          properties: {
+            perRunCents: { type: "number", minimum: 0 }
+          }
+        }
+      }
+    },
+    security: {
+      type: "object",
+      properties: {
+        fieldLengthLimits: { type: "object", additionalProperties: { type: "number" } },
+        allowedFilePrefixes: { type: "array", items: { type: "string" } }
+      }
+    },
+    render: {
+      type: "object",
+      required: ["outputDir", "watchIntervalMs"],
+      properties: {
+        outputDir: { type: "string", minLength: 1 },
+        watchIntervalMs: { type: "number", minimum: 1e3 }
+      }
+    },
+    updates: {
+      type: "object",
+      required: ["policy", "checkIntervalMs"],
+      properties: {
+        policy: { type: "string", enum: ["auto-all", "auto-compatible", "auto-patch", "notify", "manual"] },
+        checkIntervalMs: { type: "number", minimum: 6e4 }
+      }
+    },
+    budget: {
+      type: "object",
+      required: ["warnPercent"],
+      properties: {
+        warnPercent: { type: "number", minimum: 1, maximum: 100 },
+        globalMonthlyCents: { type: "number", minimum: 0 }
+      }
+    },
+    agents: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["slug", "name", "adapter"],
+        properties: {
+          slug: { type: "string", minLength: 1, pattern: "^[a-z0-9-]+$" },
+          name: { type: "string", minLength: 1 },
+          adapter: { type: "string", minLength: 1 },
+          model: { type: "string" },
+          workdir: { type: "string" },
+          maxConcurrentRuns: { type: "number", minimum: 1 },
+          budgetMonthlyCents: { type: "number", minimum: 0 },
+          canCreateAgents: { type: "boolean" },
+          skipPermissions: { type: "boolean" }
+        }
+      }
+    },
+    channels: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        required: ["enabled"],
+        properties: {
+          enabled: { type: "boolean" }
+        }
+      }
+    },
+    providers: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        required: ["enabled"],
+        properties: {
+          enabled: { type: "boolean" }
+        }
+      }
+    }
+  }
+};
+var _validate = null;
+function getValidator() {
+  if (!_validate) {
+    _validate = ajv.compile(BOT_CONFIG_SCHEMA);
+  }
+  return _validate;
+}
+function validateConfig(config) {
+  const validate = getValidator();
+  const valid = validate(config);
+  if (valid) return [];
+  return (validate.errors ?? []).map((err) => ({
+    path: err.instancePath || "/",
+    message: err.message ?? "invalid"
+  }));
+}
+
+// src/core/llm/provider-registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    if (this.providers.has(provider.id)) {
+      throw new Error(`Provider already registered: ${provider.id}`);
+    }
+    this.providers.set(provider.id, provider);
+  }
+  unregister(id) {
+    this.providers.delete(id);
+  }
+  get(id) {
+    return this.providers.get(id);
+  }
+  list() {
+    return Array.from(this.providers.values());
+  }
+  listModels() {
+    const models = [];
+    for (const provider of this.providers.values()) {
+      models.push(...provider.models);
+    }
+    return models;
+  }
+};
+
+// src/core/llm/model-router.ts
+var ModelRouter = class {
+  constructor(registry, config) {
+    this.registry = registry;
+    this.config = config;
+  }
+  registry;
+  config;
+  /**
+   * Resolve a model ID or alias to a ResolvedModel.
+   * 1. Look up alias in config.aliases (or use as-is)
+   * 2. Search all registered providers for a model with that id
+   */
+  resolve(modelIdOrAlias) {
+    const modelId = this.config.aliases[modelIdOrAlias] ?? modelIdOrAlias;
+    for (const provider of this.registry.list()) {
+      const found = provider.models.find((m) => m.id === modelId);
+      if (found) {
+        return { provider: provider.id, model: found.id };
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Try primary model, then each in config.fallbackChain.
+   * Throws if none found.
+   */
+  resolveWithFallback(modelIdOrAlias) {
+    const primary = this.resolve(modelIdOrAlias);
+    if (primary) return primary;
+    for (const fallback of this.config.fallbackChain) {
+      const resolved = this.resolve(fallback);
+      if (resolved) return resolved;
+    }
+    throw new Error(
+      `No available model found for "${modelIdOrAlias}" and fallback chain [${this.config.fallbackChain.join(", ")}]`
+    );
+  }
+  /**
+   * Use config.routing[purpose] ?? config.default, then resolveWithFallback.
+   */
+  resolveForPurpose(purpose) {
+    const modelIdOrAlias = this.config.routing[purpose] ?? this.config.default;
+    return this.resolveWithFallback(modelIdOrAlias);
+  }
+  /** Returns all models from all registered providers. */
+  listAvailable() {
+    return this.registry.listModels();
+  }
+};
+
+// src/core/llm/auto-discovery.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+async function discoverProviders(nodeModulesPath, importer = (name) => import(name)) {
+  const scopeDir = join(nodeModulesPath, "@botinabox");
+  let entries;
+  try {
+    entries = await readdir(scopeDir);
+  } catch {
+    return [];
+  }
+  const providers = [];
+  for (const entry of entries) {
+    const pkgPath = join(scopeDir, entry, "package.json");
+    let pkg;
+    try {
+      const raw = await readFile(pkgPath, "utf8");
+      pkg = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const botinabox = pkg.botinabox;
+    if (botinabox?.type !== "provider") {
+      continue;
+    }
+    const packageName = pkg.name;
+    if (!packageName) {
+      continue;
+    }
+    try {
+      const mod = await importer(packageName);
+      const provider = "default" in mod && mod.default ? mod.default : mod;
+      providers.push(provider);
+    } catch {
+    }
+  }
+  return providers;
+}
+
+// src/core/chat/channel-registry.ts
+var ChannelRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChannelRegistryError";
+  }
+};
+var ChannelRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  started = false;
+  /**
+   * Register a channel adapter.
+   * Throws if an adapter with the same id is already registered.
+   * If registry is already started, immediately connects the adapter.
+   */
+  register(adapter, config) {
+    if (this.adapters.has(adapter.id)) {
+      throw new ChannelRegistryError(`Channel adapter already registered: ${adapter.id}`);
+    }
+    this.adapters.set(adapter.id, { adapter, config });
+    if (this.started) {
+      void adapter.connect(config ?? {});
+    }
+  }
+  /**
+   * Unregister a channel adapter.
+   * Disconnects the adapter if it exists.
+   */
+  async unregister(id) {
+    const entry = this.adapters.get(id);
+    if (!entry) return;
+    await entry.adapter.disconnect();
+    this.adapters.delete(id);
+  }
+  /**
+   * Reconfigure an adapter: disconnect, update config, reconnect.
+   */
+  async reconfigure(id, config) {
+    const entry = this.adapters.get(id);
+    if (!entry) {
+      throw new ChannelRegistryError(`Channel adapter not found: ${id}`);
+    }
+    await entry.adapter.disconnect();
+    entry.config = config;
+    await entry.adapter.connect(config ?? {});
+  }
+  /**
+   * Run health checks on all registered adapters.
+   */
+  async healthCheck() {
+    const results = {};
+    for (const [id, entry] of this.adapters) {
+      try {
+        results[id] = await entry.adapter.healthCheck();
+      } catch (err) {
+        results[id] = { ok: false, error: String(err) };
+      }
+    }
+    return results;
+  }
+  /** Get an adapter by ID. */
+  get(id) {
+    return this.adapters.get(id)?.adapter;
+  }
+  /** List all registered adapters. */
+  list() {
+    return Array.from(this.adapters.values()).map((e) => e.adapter);
+  }
+  /**
+   * Start: connect all registered adapters and mark registry as started.
+   */
+  async start() {
+    this.started = true;
+    for (const entry of this.adapters.values()) {
+      await entry.adapter.connect(entry.config ?? {});
+    }
+  }
+  /**
+   * Stop: disconnect all registered adapters.
+   */
+  async stop() {
+    for (const entry of this.adapters.values()) {
+      await entry.adapter.disconnect();
+    }
+    this.started = false;
+  }
+};
+
+// src/core/chat/auto-discovery.ts
+import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function discoverChannels(nodeModulesPath, importer = (name) => import(name)) {
+  const scopeDir = join2(nodeModulesPath, "@botinabox");
+  let entries;
+  try {
+    entries = await readdir2(scopeDir);
+  } catch {
+    return [];
+  }
+  const adapters = [];
+  for (const entry of entries) {
+    const pkgPath = join2(scopeDir, entry, "package.json");
+    let pkg;
+    try {
+      const raw = await readFile2(pkgPath, "utf8");
+      pkg = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const botinabox = pkg.botinabox;
+    if (botinabox?.type !== "channel") {
+      continue;
+    }
+    const packageName = pkg.name;
+    if (!packageName) {
+      continue;
+    }
+    try {
+      const mod = await importer(packageName);
+      const adapter = "default" in mod && mod.default ? mod.default : mod;
+      adapters.push(adapter);
+    } catch {
+    }
+  }
+  return adapters;
+}
+
+// src/core/chat/routing.ts
+function buildAgentBindings(agents) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    const agentId = agent.slug;
+    const cfg = agent.config ?? {};
+    const channels = [];
+    if (typeof cfg["channel"] === "string") {
+      channels.push(cfg["channel"]);
+    }
+    if (Array.isArray(cfg["channels"])) {
+      for (const ch of cfg["channels"]) {
+        channels.push(ch);
+      }
+    }
+    for (const ch of channels) {
+      bindings.set(ch, agentId);
+    }
+  }
+  return bindings;
+}
+
+// src/core/chat/policies.ts
+function checkAllowlist(allowFrom, senderId) {
+  if (allowFrom.length === 0) return true;
+  return allowFrom.includes(senderId);
+}
+function checkMentionGate(msg, botId) {
+  const body = msg.body ?? "";
+  return body.includes(`@${botId}`) || body.includes(botId);
+}
+
+// src/core/chat/pipeline.ts
+var MessagePipeline = class {
+  constructor(hooks, agentRegistry, taskQueue, config) {
+    this.hooks = hooks;
+    this.agentRegistry = agentRegistry;
+    this.taskQueue = taskQueue;
+    this.config = config;
+    this.agentBindings = buildAgentBindings(config.agents);
+  }
+  hooks;
+  agentRegistry;
+  taskQueue;
+  config;
+  agentBindings;
+  /**
+   * Process an inbound message end-to-end.
+   * 1. Emit 'message.inbound'
+   * 2. Resolve agent
+   * 3. Check policy (allowlist / mention gate)
+   * 4. Create task
+   * 5. Emit 'message.processed'
+   */
+  async processInbound(msg) {
+    await this.hooks.emit("message.inbound", { message: msg, channel: msg.channel });
+    const agentId = this.resolveAgent(msg);
+    if (agentId !== void 0) {
+      const allowed = this.evaluatePolicy(msg, agentId);
+      if (allowed) {
+        await this.taskQueue.create({
+          title: `Message from ${msg.from} on ${msg.channel}`,
+          description: msg.body,
+          assignee_id: agentId,
+          context: JSON.stringify({ message: msg })
+        });
+      }
+    }
+    await this.hooks.emit("message.processed", {
+      message: msg,
+      channel: msg.channel,
+      agentId: agentId ?? null
+    });
+  }
+  /**
+   * Resolve the best agent for a given inbound message.
+   * Returns agentId (slug) or undefined if no match.
+   */
+  resolveAgent(msg) {
+    const bound = this.agentBindings.get(msg.channel);
+    if (bound) return bound;
+    const first = this.config.agents[0];
+    return first?.slug;
+  }
+  /**
+   * Evaluate messaging policy for the given agent.
+   * Returns false if the message is blocked.
+   */
+  evaluatePolicy(msg, agentId) {
+    const channelConfig = this.config.channels[msg.channel];
+    const allowFrom = channelConfig?.["allowFrom"] ?? [];
+    if (!checkAllowlist(allowFrom, msg.from)) {
+      return false;
+    }
+    const mentionGated = channelConfig?.["requireMention"] ?? false;
+    if (mentionGated) {
+      if (!checkMentionGate(msg, agentId)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/core/chat/session-key.ts
+var SessionKey = class _SessionKey {
+  constructor(agentId, channel, scope) {
+    this.agentId = agentId;
+    this.channel = channel;
+    this.scope = scope;
+  }
+  agentId;
+  channel;
+  scope;
+  toString() {
+    return `agent:${this.agentId}:${this.channel}:${this.scope}`;
+  }
+  toJSON() {
+    return {
+      agentId: this.agentId,
+      channel: this.channel,
+      scope: this.scope
+    };
+  }
+  static fromString(key) {
+    const parts = key.split(":");
+    if (parts.length < 4 || parts[0] !== "agent") {
+      throw new Error(`Invalid SessionKey format: ${key}`);
+    }
+    const [, agentId, channel, scope] = parts;
+    if (!agentId || !channel || !scope) {
+      throw new Error(`Invalid SessionKey format: ${key}`);
+    }
+    return new _SessionKey(agentId, channel, scope);
+  }
+  /**
+   * Build a session key from structured parameters.
+   *
+   * @param agentId      - The agent identifier
+   * @param channel      - The channel identifier
+   * @param chatType     - 'dm' or 'group'
+   * @param peerId       - The peer/user ID
+   * @param dmScope      - DM scoping strategy
+   *   - 'main'               → single session per agent+channel regardless of peer
+   *   - 'per-peer'           → one session per (agent, peer)
+   *   - 'per-channel-peer'   → one session per (agent, channel, peer)
+   */
+  static build(agentId, channel, chatType, peerId, dmScope) {
+    if (chatType === "group") {
+      return new _SessionKey(agentId, channel, channel);
+    }
+    switch (dmScope) {
+      case "main":
+        return new _SessionKey(agentId, channel, "main");
+      case "per-peer":
+        return new _SessionKey(agentId, channel, peerId);
+      case "per-channel-peer":
+        return new _SessionKey(agentId, channel, `${channel}:${peerId}`);
+    }
+  }
+};
+
+// src/core/orchestrator/session-manager.ts
+var SessionManager = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async save(agentId, channelId, peerId, params) {
+    const existing = await this._find(agentId, channelId, peerId);
+    if (existing) {
+      await this.db.update("sessions", { id: existing["id"] }, {
+        context: JSON.stringify(params),
+        last_message_at: (/* @__PURE__ */ new Date()).toISOString(),
+        message_count: (existing["message_count"] ?? 0) + 1
+      });
+      return existing["id"];
+    } else {
+      const row = await this.db.insert("sessions", {
+        agent_id: agentId,
+        channel: channelId,
+        peer_id: peerId,
+        context: JSON.stringify(params),
+        last_message_at: (/* @__PURE__ */ new Date()).toISOString(),
+        message_count: 1
+      });
+      return row["id"];
+    }
+  }
+  async load(agentId, channelId, peerId) {
+    const session = await this._find(agentId, channelId, peerId);
+    if (!session) return void 0;
+    const context = session["context"] ? JSON.parse(session["context"]) : {};
+    return { ...session, ...context };
+  }
+  async clear(agentId, channelId, peerId) {
+    const session = await this._find(agentId, channelId, peerId);
+    if (session) {
+      await this.db.delete("sessions", { id: session["id"] });
+    }
+  }
+  async shouldClear(session, opts) {
+    if (opts.maxRuns !== void 0) {
+      const messageCount = session["message_count"] ?? 0;
+      if (messageCount > opts.maxRuns) return true;
+    }
+    if (opts.maxAgeHours !== void 0) {
+      const createdAt = session["created_at"];
+      if (createdAt) {
+        const ageMs = Date.now() - new Date(createdAt).getTime();
+        const ageHours = ageMs / (1e3 * 60 * 60);
+        if (ageHours > opts.maxAgeHours) return true;
+      }
+    }
+    return false;
+  }
+  async _find(agentId, channelId, peerId) {
+    const rows = await this.db.query("sessions", {
+      where: { agent_id: agentId, channel: channelId, peer_id: peerId }
+    });
+    return rows[0] ?? void 0;
+  }
+};
+
+// src/core/chat/session-manager.ts
+var ChatSessionManager = class {
+  inner;
+  constructor(db) {
+    this.inner = new SessionManager(db);
+  }
+  async save(key, params) {
+    return this.inner.save(key.agentId, key.channel, key.scope, params);
+  }
+  async load(key) {
+    return this.inner.load(key.agentId, key.channel, key.scope);
+  }
+  async clear(key) {
+    return this.inner.clear(key.agentId, key.channel, key.scope);
+  }
+  async shouldClear(session, opts) {
+    return this.inner.shouldClear(session, opts);
+  }
+};
+
+// src/core/chat/notification-queue.ts
+var NotificationQueue = class {
+  constructor(db, hooks, channelRegistry, opts) {
+    this.db = db;
+    this.hooks = hooks;
+    this.channelRegistry = channelRegistry;
+    this.maxRetries = opts?.maxRetries ?? 3;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 5e3;
+  }
+  db;
+  hooks;
+  channelRegistry;
+  maxRetries;
+  pollIntervalMs;
+  timer = null;
+  /**
+   * Enqueue a notification for delivery.
+   * Returns the notification ID.
+   */
+  async enqueue(channel, recipient, payload) {
+    const row = await this.db.insert("notifications", {
+      channel,
+      recipient_id: recipient,
+      message: JSON.stringify(payload),
+      status: "pending",
+      retries: 0
+    });
+    await this.hooks.emit("notification.enqueued", {
+      notificationId: row["id"],
+      channel,
+      recipient
+    });
+    return row["id"];
+  }
+  /** Start the background worker polling for pending notifications. */
+  startWorker() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      void this.processNext();
+    }, this.pollIntervalMs);
+  }
+  /** Stop the background worker. */
+  stopWorker() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async processNext() {
+    const rows = await this.db.query("notifications", {
+      where: { status: "pending" },
+      limit: 10
+    });
+    for (const row of rows) {
+      const id = row["id"];
+      const channel = row["channel"];
+      const recipient = row["recipient_id"];
+      const retries = row["retries"] ?? 0;
+      let payload;
+      try {
+        payload = JSON.parse(row["message"]);
+      } catch {
+        await this.db.update("notifications", { id }, { status: "failed", error: "Invalid payload" });
+        continue;
+      }
+      const adapter = this.channelRegistry.get(channel);
+      if (!adapter) {
+        await this.db.update("notifications", { id }, {
+          status: "failed",
+          error: `No adapter for channel: ${channel}`
+        });
+        continue;
+      }
+      try {
+        await adapter.send({ peerId: recipient, threadId: payload.threadId }, payload);
+        await this.db.update("notifications", { id }, {
+          status: "sent",
+          sent_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await this.hooks.emit("notification.sent", { notificationId: id, channel, recipient });
+      } catch (err) {
+        const newRetries = retries + 1;
+        if (newRetries >= this.maxRetries) {
+          await this.db.update("notifications", { id }, {
+            status: "failed",
+            retries: newRetries,
+            error: String(err)
+          });
+          await this.hooks.emit("notification.failed", { notificationId: id, channel, recipient, error: String(err) });
+        } else {
+          await this.db.update("notifications", { id }, {
+            status: "pending",
+            retries: newRetries,
+            error: String(err)
+          });
+        }
+      }
+    }
+  }
+};
+
+// src/core/chat/text-chunker.ts
+function chunkText(text, maxLen) {
+  if (maxLen <= 0) throw new Error("maxLen must be > 0");
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  function splitInto(segment) {
+    if (segment.length <= maxLen) {
+      if (segment.length > 0) chunks.push(segment);
+      return;
+    }
+    const paraIdx = segment.lastIndexOf("\n\n", maxLen);
+    if (paraIdx > 0) {
+      chunks.push(segment.slice(0, paraIdx));
+      splitInto(segment.slice(paraIdx + 2).trimStart());
+      return;
+    }
+    const sentIdx = segment.lastIndexOf(". ", maxLen);
+    if (sentIdx > 0) {
+      chunks.push(segment.slice(0, sentIdx + 1));
+      splitInto(segment.slice(sentIdx + 2).trimStart());
+      return;
+    }
+    const wordIdx = segment.lastIndexOf(" ", maxLen);
+    if (wordIdx > 0) {
+      chunks.push(segment.slice(0, wordIdx));
+      splitInto(segment.slice(wordIdx + 1));
+      return;
+    }
+    chunks.push(segment.slice(0, maxLen));
+    splitInto(segment.slice(maxLen));
+  }
+  splitInto(text);
+  return chunks;
+}
+
+// src/core/chat/formatter.ts
+function formatText(text, mode) {
+  switch (mode) {
+    case "mrkdwn":
+      return toMrkdwn(text);
+    case "html":
+      return toHtml(text);
+    case "plain":
+      return toPlain(text);
+  }
+}
+function toMrkdwn(text) {
+  let result = text.replace(/\*\*(.+?)\*\*/g, "*$1*");
+  result = result.replace(/__(.+?)__/g, "*$1*");
+  return result;
+}
+function toHtml(text) {
+  let result = text.replace(/```([\s\S]*?)```/g, "<pre><code>$1</code></pre>");
+  result = result.replace(/`(.+?)`/g, "<code>$1</code>");
+  result = result.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  result = result.replace(/__(.+?)__/g, "<strong>$1</strong>");
+  result = result.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  result = result.replace(/_(.+?)_/g, "<em>$1</em>");
+  return result;
+}
+function toPlain(text) {
+  let result = text.replace(/```[\s\S]*?```/g, (m) => m.replace(/```/g, "").trim());
+  result = result.replace(/`(.+?)`/g, "$1");
+  result = result.replace(/\*\*(.+?)\*\*/g, "$1");
+  result = result.replace(/__(.+?)__/g, "$1");
+  result = result.replace(/\*(.+?)\*/g, "$1");
+  result = result.replace(/_(.+?)_/g, "$1");
+  return result;
+}
+
+// src/core/data/data-store.ts
+import { Lattice } from "latticesql";
+var DataStoreError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DataStoreError";
+  }
+};
+var DataStore = class {
+  lattice;
+  hooks;
+  outputDir;
+  _initialized = false;
+  deferredStatements = [];
+  constructor(opts) {
+    this.lattice = new Lattice(opts.dbPath, {
+      wal: opts.wal ?? true
+    });
+    this.outputDir = opts.outputDir;
+    this.hooks = opts.hooks;
+  }
+  /**
+   * Register a table definition. Must be called before init().
+   *
+   * tableConstraints may contain both inline constraints (FOREIGN KEY, UNIQUE)
+   * and standalone SQL statements (CREATE INDEX). Standalone statements are
+   * deferred and executed after init() creates the tables.
+   */
+  define(name, def) {
+    if (this._initialized) {
+      throw new DataStoreError("Cannot define tables after init()");
+    }
+    const inlineConstraints = [];
+    for (const stmt of def.tableConstraints ?? []) {
+      const upper = stmt.trimStart().toUpperCase();
+      if (upper.startsWith("CREATE ") || upper.startsWith("DROP ") || upper.startsWith("ALTER ")) {
+        this.deferredStatements.push(stmt);
+      } else {
+        inlineConstraints.push(stmt);
+      }
+    }
+    this.lattice.define(name, {
+      columns: def.columns,
+      primaryKey: def.primaryKey,
+      tableConstraints: inlineConstraints.length ? inlineConstraints : void 0,
+      relations: def.relations,
+      filter: def.filter,
+      render: def.render,
+      outputFile: def.outputFile
+    });
+  }
+  /**
+   * Register an entity context definition for per-entity file rendering.
+   */
+  defineEntityContext(name, def) {
+    this.lattice.defineEntityContext(name, {
+      slug: (row) => row[def.slugColumn],
+      directoryRoot: def.directory,
+      files: def.files,
+      protectedFiles: def.protectedFiles,
+      index: def.indexFile ? { outputFile: def.indexFile, render: (rows) => "" } : void 0
+    });
+  }
+  async init(opts) {
+    await this.lattice.init({ migrations: opts?.migrations });
+    for (const stmt of this.deferredStatements) {
+      this.lattice.db.exec(stmt);
+    }
+    this._initialized = true;
+  }
+  assertInitialized() {
+    if (!this._initialized) {
+      throw new DataStoreError("DataStore not initialized \u2014 call init() first");
+    }
+  }
+  // --- CRUD -----------------------------------------------------------
+  async insert(table, row) {
+    this.assertInitialized();
+    return this.lattice.insertReturning(table, row);
+  }
+  async upsert(table, row) {
+    this.assertInitialized();
+    const id = await this.lattice.upsert(table, row);
+    const result = await this.lattice.get(table, id);
+    return result ?? { ...row, id };
+  }
+  async update(table, pk, changes) {
+    this.assertInitialized();
+    return this.lattice.updateReturning(table, pk, changes);
+  }
+  async delete(table, pk) {
+    this.assertInitialized();
+    await this.lattice.delete(table, pk);
+  }
+  /**
+   * Get a single row by primary key.
+   * Returns undefined if not found (Lattice returns null).
+   */
+  async get(table, pk) {
+    this.assertInitialized();
+    const result = await this.lattice.get(table, pk);
+    return result ?? void 0;
+  }
+  async query(table, opts) {
+    this.assertInitialized();
+    return this.lattice.query(table, opts);
+  }
+  async count(table, opts) {
+    this.assertInitialized();
+    return this.lattice.count(table, opts);
+  }
+  // --- Junctions ------------------------------------------------------
+  async link(junctionTable, row) {
+    this.assertInitialized();
+    await this.lattice.link(junctionTable, row);
+  }
+  async unlink(junctionTable, row) {
+    this.assertInitialized();
+    await this.lattice.unlink(junctionTable, row);
+  }
+  // --- Migrations -----------------------------------------------------
+  async migrate(migrations) {
+    this.assertInitialized();
+    await this.lattice.migrate(migrations);
+  }
+  // --- Seed -----------------------------------------------------------
+  async seed(items) {
+    this.assertInitialized();
+    for (const item of items) {
+      const naturalKey = Array.isArray(item.naturalKey) ? item.naturalKey[0] : item.naturalKey ?? "id";
+      await this.lattice.seed({
+        table: item.table,
+        data: item.rows,
+        naturalKey,
+        softDeleteMissing: item.softDeleteMissing
+      });
+      if (item.junctions) {
+        for (const junc of item.junctions) {
+          for (const linkRow of junc.items) {
+            await this.lattice.link(junc.table, linkRow);
+          }
+        }
+      }
+    }
+  }
+  // --- Rendering ------------------------------------------------------
+  async render() {
+    this.assertInitialized();
+    if (this.outputDir) {
+      await this.lattice.render(this.outputDir);
+    }
+  }
+  async reconcile() {
+    this.assertInitialized();
+    if (this.outputDir) {
+      await this.lattice.reconcile(this.outputDir);
+    }
+  }
+  // --- Schema introspection ------------------------------------------
+  tableInfo(table) {
+    this.assertInitialized();
+    return this.lattice.db.pragma(`table_info(${table})`);
+  }
+  // --- Lifecycle ------------------------------------------------------
+  close() {
+    this.lattice.close();
+    this._initialized = false;
+  }
+  on(event, handler) {
+    this.hooks?.register(event, handler);
+  }
+};
+
+// src/core/data/core-schema.ts
+function defineCoreTables(db) {
+  db.define("agents", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      slug: "TEXT UNIQUE NOT NULL",
+      name: "TEXT NOT NULL",
+      role: "TEXT NOT NULL DEFAULT 'general'",
+      status: "TEXT NOT NULL DEFAULT 'idle'",
+      adapter: "TEXT NOT NULL",
+      adapter_config: "TEXT NOT NULL DEFAULT '{}'",
+      heartbeat_config: "TEXT NOT NULL DEFAULT '{}'",
+      budget_monthly_cents: "INTEGER NOT NULL DEFAULT 0",
+      spent_monthly_cents: "INTEGER NOT NULL DEFAULT 0",
+      reports_to: "TEXT",
+      cwd: "TEXT",
+      instructions_file: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    }
+  });
+  db.define("tasks", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      title: "TEXT NOT NULL",
+      description: "TEXT",
+      status: "TEXT NOT NULL DEFAULT 'backlog'",
+      priority: "INTEGER NOT NULL DEFAULT 5",
+      assignee_id: "TEXT",
+      created_by: "TEXT",
+      parent_id: "TEXT",
+      chain_origin_id: "TEXT",
+      chain_depth: "INTEGER NOT NULL DEFAULT 0",
+      workflow_run_id: "TEXT",
+      workflow_step_id: "TEXT",
+      tags: "TEXT NOT NULL DEFAULT '[]'",
+      context: "TEXT",
+      result: "TEXT",
+      retry_count: "INTEGER NOT NULL DEFAULT 0",
+      max_retries: "INTEGER NOT NULL DEFAULT 0",
+      next_retry_at: "TEXT",
+      followup_agent_id: "TEXT",
+      followup_template: "TEXT",
+      execution_run_id: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_tasks_status_assignee ON tasks(status, assignee_id)",
+      "CREATE INDEX IF NOT EXISTS idx_tasks_chain_origin ON tasks(chain_origin_id)"
+    ]
+  });
+  db.define("runs", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      task_id: "TEXT NOT NULL",
+      agent_id: "TEXT NOT NULL",
+      status: "TEXT NOT NULL DEFAULT 'queued'",
+      model: "TEXT",
+      adapter: "TEXT",
+      log_path: "TEXT",
+      exit_code: "INTEGER",
+      error_message: "TEXT",
+      cost_cents: "INTEGER NOT NULL DEFAULT 0",
+      input_tokens: "INTEGER NOT NULL DEFAULT 0",
+      output_tokens: "INTEGER NOT NULL DEFAULT 0",
+      started_at: "TEXT",
+      completed_at: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_runs_task_id ON runs(task_id)",
+      "CREATE INDEX IF NOT EXISTS idx_runs_agent_id ON runs(agent_id)",
+      "CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)"
+    ]
+  });
+  db.define("wakeups", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT NOT NULL",
+      scheduled_at: "TEXT NOT NULL",
+      fired_at: "TEXT",
+      run_id: "TEXT",
+      context: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_wakeups_agent_scheduled ON wakeups(agent_id, scheduled_at)"
+    ]
+  });
+  db.define("sessions", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT NOT NULL",
+      channel: "TEXT NOT NULL",
+      peer_id: "TEXT NOT NULL",
+      last_message_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      message_count: "INTEGER NOT NULL DEFAULT 0",
+      context: "TEXT NOT NULL DEFAULT '{}'",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      expires_at: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_channel_peer ON sessions(agent_id, channel, peer_id)"
+    ]
+  });
+  db.define("skills", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      slug: "TEXT UNIQUE NOT NULL",
+      name: "TEXT NOT NULL",
+      description: "TEXT",
+      category: "TEXT",
+      definition: "TEXT",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    }
+  });
+  db.define("agent_skills", {
+    columns: {
+      agent_id: "TEXT NOT NULL",
+      skill_id: "TEXT NOT NULL",
+      granted_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    primaryKey: ["agent_id", "skill_id"],
+    tableConstraints: [
+      "FOREIGN KEY (agent_id) REFERENCES agents(id)",
+      "FOREIGN KEY (skill_id) REFERENCES skills(id)"
+    ]
+  });
+  db.define("cost_events", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT",
+      run_id: "TEXT",
+      model: "TEXT NOT NULL",
+      provider: "TEXT NOT NULL",
+      input_tokens: "INTEGER NOT NULL DEFAULT 0",
+      output_tokens: "INTEGER NOT NULL DEFAULT 0",
+      cost_cents: "INTEGER NOT NULL DEFAULT 0",
+      recorded_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_cost_events_agent ON cost_events(agent_id, recorded_at)"
+    ]
+  });
+  db.define("budget_policies", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT",
+      scope: "TEXT NOT NULL DEFAULT 'global'",
+      monthly_limit_cents: "INTEGER NOT NULL",
+      warn_percent: "INTEGER NOT NULL DEFAULT 80",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    }
+  });
+  db.define("activity_log", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      agent_id: "TEXT",
+      event_type: "TEXT NOT NULL",
+      payload: "TEXT NOT NULL DEFAULT '{}'",
+      recorded_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_activity_log_recorded ON activity_log(recorded_at)",
+      "CREATE INDEX IF NOT EXISTS idx_activity_log_agent ON activity_log(agent_id, recorded_at)"
+    ]
+  });
+  db.define("notifications", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      channel: "TEXT NOT NULL",
+      recipient_id: "TEXT NOT NULL",
+      message: "TEXT NOT NULL",
+      status: "TEXT NOT NULL DEFAULT 'pending'",
+      retries: "INTEGER NOT NULL DEFAULT 0",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      sent_at: "TEXT",
+      error: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_notifications_pending ON notifications(status, created_at)"
+    ]
+  });
+  db.define("config_revisions", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      version: "INTEGER NOT NULL",
+      config_yaml: "TEXT NOT NULL",
+      applied_by: "TEXT",
+      applied_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      notes: "TEXT"
+    }
+  });
+  db.define("workflows", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      slug: "TEXT UNIQUE NOT NULL",
+      name: "TEXT NOT NULL",
+      description: "TEXT",
+      definition: "TEXT NOT NULL DEFAULT '{}'",
+      created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      deleted_at: "TEXT"
+    }
+  });
+  db.define("workflow_runs", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      workflow_id: "TEXT NOT NULL",
+      trigger_task_id: "TEXT",
+      status: "TEXT NOT NULL DEFAULT 'running'",
+      current_step: "TEXT",
+      step_results: "TEXT NOT NULL DEFAULT '{}'",
+      error: "TEXT",
+      started_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      completed_at: "TEXT"
+    },
+    tableConstraints: [
+      "CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow_id, status)"
+    ]
+  });
+  db.define("update_history", {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      from_version: "TEXT NOT NULL",
+      to_version: "TEXT NOT NULL",
+      status: "TEXT NOT NULL DEFAULT 'pending'",
+      migration_log: "TEXT",
+      applied_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+      rolled_back_at: "TEXT"
+    }
+  });
+}
+
+// src/core/data/core-migrations.ts
+var CORE_MIGRATIONS = [
+  {
+    version: "001_initial_schema",
+    sql: `-- Initial schema is applied via DataStore.define() + init().
+          -- This migration is a no-op placeholder for version tracking.
+          SELECT 1;`
+  },
+  {
+    version: "002_activity_log_indexes",
+    sql: `CREATE INDEX IF NOT EXISTS idx_activity_log_type ON activity_log(event_type, recorded_at);`
+  },
+  {
+    version: "003_runs_cost_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_runs_cost ON runs(agent_id, completed_at) WHERE cost_cents > 0;`
+  }
+];
+
+// src/core/security/sanitizer.ts
+import { Buffer as Buffer2 } from "buffer";
+var DEFAULT_FIELD_LIMIT = 65535;
+var DEFAULT_SUFFIX = "[truncated]";
+function sanitize(row, opts) {
+  const limits = opts?.fieldLengthLimits ?? {};
+  const suffix = opts?.truncateSuffix ?? DEFAULT_SUFFIX;
+  const result = {};
+  for (const [col, val] of Object.entries(row)) {
+    if (typeof val !== "string") {
+      result[col] = val;
+      continue;
+    }
+    let s = val.replace(/\x00/g, "");
+    s = s.replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+    const limit = limits[col] ?? DEFAULT_FIELD_LIMIT;
+    if (Buffer2.byteLength(s) > limit) {
+      const suffixBytes = Buffer2.byteLength(suffix);
+      const maxContentBytes = limit - suffixBytes;
+      const buf = Buffer2.from(s);
+      s = buf.slice(0, maxContentBytes).toString() + suffix;
+    }
+    result[col] = s;
+  }
+  return result;
+}
+
+// src/core/security/column-validator.ts
+var ColumnValidatorImpl = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  getValidColumns(table) {
+    const rows = this.db.tableInfo(table);
+    return new Set(rows.map((r) => r.name));
+  }
+  validateWrite(table, row) {
+    const valid = this.getValidColumns(table);
+    const result = {};
+    for (const [col, val] of Object.entries(row)) {
+      if (valid.has(col)) {
+        result[col] = val;
+      }
+    }
+    return result;
+  }
+  validateRead(table, columns) {
+    const valid = this.getValidColumns(table);
+    for (const col of columns) {
+      if (!valid.has(col)) {
+        throw new Error(`Unknown column: ${col} in table ${table}`);
+      }
+    }
+  }
+  invalidateCache(_table) {
+  }
+};
+
+// src/core/security/audit.ts
+var AuditEmitter = class {
+  hooks;
+  auditTables;
+  constructor(hooks, opts) {
+    this.hooks = hooks;
+    this.auditTables = opts?.auditTables ?? [];
+  }
+  shouldAudit(table) {
+    return this.auditTables.includes("*") || this.auditTables.includes(table);
+  }
+  emit(event) {
+    try {
+      const context = event;
+      if (typeof this.hooks.emitSync === "function") {
+        this.hooks.emitSync("audit", context);
+      } else {
+        void this.hooks.emit("audit", context);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/core/update/version-utils.ts
+function parseVersion(v) {
+  const cleaned = v.replace(/^v/, "").split("-")[0] ?? v;
+  const parts = cleaned.split(".");
+  const major = parseInt(parts[0] ?? "0", 10) || 0;
+  const minor = parseInt(parts[1] ?? "0", 10) || 0;
+  const patch = parseInt(parts[2] ?? "0", 10) || 0;
+  return [major, minor, patch];
+}
+function compareVersions(a, b) {
+  const [aMaj, aMin, aPat] = parseVersion(a);
+  const [bMaj, bMin, bPat] = parseVersion(b);
+  if (aMaj !== bMaj) return aMaj < bMaj ? -1 : 1;
+  if (aMin !== bMin) return aMin < bMin ? -1 : 1;
+  if (aPat !== bPat) return aPat < bPat ? -1 : 1;
+  return 0;
+}
+function classifyUpdate(from, to) {
+  const [fMaj, fMin] = parseVersion(from);
+  const [tMaj, tMin] = parseVersion(to);
+  if (compareVersions(from, to) === 0) return "none";
+  if (tMaj !== fMaj) return "major";
+  if (tMin !== fMin) return "minor";
+  return "patch";
+}
+
+// src/core/update/update-checker.ts
+import { readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join3 } from "path";
+var UpdateChecker = class {
+  constructor(nodeModulesPath, opts) {
+    this.nodeModulesPath = nodeModulesPath;
+    this.opts = opts;
+    this.fetchFn = opts?.fetch ?? globalThis.fetch;
+  }
+  nodeModulesPath;
+  opts;
+  fetchFn;
+  getInstalledPackages() {
+    try {
+      const botinaboxPath = join3(this.nodeModulesPath, "@botinabox");
+      const entries = readdirSync(botinaboxPath, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+  async check(packageNames) {
+    const installed = packageNames ?? this.getInstalledPackages();
+    const updates = [];
+    for (const pkg of installed) {
+      try {
+        const pkgJsonPath = join3(this.nodeModulesPath, "@botinabox", pkg, "package.json");
+        const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+        const installedVersion = pkgJson.version ?? "0.0.0";
+        const response = await this.fetchFn(
+          `https://registry.npmjs.org/@botinabox/${pkg}`
+        );
+        if (!response.ok) continue;
+        const data = await response.json();
+        const latestVersion = data["dist-tags"]?.["latest"];
+        if (!latestVersion) continue;
+        if (compareVersions(latestVersion, installedVersion) > 0) {
+          const updateType = classifyUpdate(installedVersion, latestVersion);
+          if (updateType !== "none") {
+            updates.push({
+              name: `@botinabox/${pkg}`,
+              installedVersion,
+              latestVersion,
+              updateType
+            });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      packages: updates,
+      hasUpdates: updates.length > 0
+    };
+  }
+};
+
+// src/core/update/backup-manager.ts
+import { copyFileSync, mkdirSync } from "fs";
+import { join as join4 } from "path";
+import { rmSync } from "fs";
+var BackupManager = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  projectRoot;
+  async backup() {
+    const backupDir = join4(this.projectRoot, ".botinabox-backup");
+    mkdirSync(backupDir, { recursive: true });
+    const src = join4(this.projectRoot, "pnpm-lock.yaml");
+    const dest = join4(backupDir, "pnpm-lock.yaml.bak");
+    copyFileSync(src, dest);
+    return dest;
+  }
+  async restore(backupPath) {
+    const dest = join4(this.projectRoot, "pnpm-lock.yaml");
+    copyFileSync(backupPath, dest);
+  }
+  async cleanup(backupPath) {
+    rmSync(backupPath, { force: true });
+  }
+};
+
+// src/core/update/update-manager.ts
+import { execSync } from "child_process";
+var UpdateManager = class {
+  constructor(checker, db, hooks, opts) {
+    this.checker = checker;
+    this.db = db;
+    this.hooks = hooks;
+    this.opts = opts;
+    this.backupManager = new BackupManager(opts?.projectRoot ?? process.cwd());
+  }
+  checker;
+  db;
+  hooks;
+  opts;
+  backupManager;
+  async checkAndNotify() {
+    const manifest = await this.checker.check();
+    if (manifest.hasUpdates) {
+      await this.hooks.emit("update.available", { manifest });
+    }
+    return manifest;
+  }
+  async applyUpdates(updates) {
+    const filtered = this.filterByPolicy(updates);
+    if (filtered.length === 0) return;
+    if (!this.isInMaintenanceWindow()) {
+      await this.hooks.emit("update.deferred", { reason: "outside maintenance window" });
+      return;
+    }
+    let backupPath;
+    const historyIds = [];
+    try {
+      backupPath = await this.backupManager.backup();
+      for (const update of filtered) {
+        const row = await this.db.insert("update_history", {
+          from_version: update.installedVersion,
+          to_version: update.latestVersion,
+          status: "pending"
+        });
+        historyIds.push(row["id"]);
+      }
+      execSync("pnpm install", {
+        cwd: this.opts?.projectRoot ?? process.cwd(),
+        stdio: "ignore"
+      });
+      for (const id of historyIds) {
+        await this.db.update("update_history", { id }, { status: "succeeded" });
+      }
+      await this.backupManager.cleanup(backupPath);
+      await this.hooks.emit("update.completed", { updates: filtered });
+    } catch (err) {
+      for (const id of historyIds) {
+        await this.db.update("update_history", { id }, {
+          status: "failed",
+          migration_log: String(err)
+        });
+      }
+      if (backupPath) {
+        try {
+          await this.backupManager.restore(backupPath);
+          await this.backupManager.cleanup(backupPath);
+        } catch {
+        }
+      }
+      await this.hooks.emit("update.failed", { updates: filtered, error: String(err) });
+    }
+  }
+  isInMaintenanceWindow() {
+    const window = this.opts?.maintenanceWindow;
+    if (!window) return true;
+    const nowHour = (/* @__PURE__ */ new Date()).getUTCHours();
+    const { utcHourStart, utcHourEnd } = window;
+    if (utcHourStart <= utcHourEnd) {
+      return nowHour >= utcHourStart && nowHour < utcHourEnd;
+    } else {
+      return nowHour >= utcHourStart || nowHour < utcHourEnd;
+    }
+  }
+  filterByPolicy(updates) {
+    const policy = this.opts?.policy ?? "notify";
+    switch (policy) {
+      case "auto-all":
+        return updates;
+      case "auto-compatible":
+        return updates.filter((u) => u.updateType !== "major");
+      case "auto-patch":
+        return updates.filter((u) => u.updateType === "patch");
+      case "notify":
+      case "manual":
+      default:
+        return [];
+    }
+  }
+};
+
+// src/core/update/migration-hooks.ts
+async function runPackageMigrations(db, migrations) {
+  await db.migrate(
+    migrations.map((m) => ({
+      version: `${m.package}:${m.version}`,
+      sql: m.sql
+    }))
+  );
+}
+
+// src/core/orchestrator/config-revisions.ts
+async function createConfigRevision(db, agentId, before, after) {
+  const existing = await db.query("config_revisions", {
+    where: { notes: agentId }
+  });
+  const version = existing.length + 1;
+  await db.insert("config_revisions", {
+    version,
+    config_yaml: JSON.stringify({ agentId, before, after }),
+    applied_by: agentId,
+    notes: agentId
+  });
+}
+
+// src/core/orchestrator/agent-registry.ts
+var VALID_TRANSITIONS = {
+  idle: ["running", "paused"],
+  running: ["idle", "paused", "terminated"],
+  paused: ["idle", "terminated"],
+  terminated: []
+};
+var WRITE_ACTIVITY_LOG_STATUSES = /* @__PURE__ */ new Set(["paused", "terminated"]);
+var AgentRegistry = class {
+  constructor(db, hooks) {
+    this.db = db;
+    this.hooks = hooks;
+  }
+  db;
+  hooks;
+  async register(agent, opts) {
+    if (!agent.slug || !agent.name || !agent.adapter) {
+      throw new Error("Agent must have slug, name, and adapter");
+    }
+    if (opts?.actorAgentId) {
+      const actor = await this.db.get("agents", { id: opts.actorAgentId });
+      if (!actor) throw new Error(`Actor agent not found: ${opts.actorAgentId}`);
+      let canCreate = false;
+      try {
+        const cfg = JSON.parse(actor["adapter_config"] ?? "{}");
+        canCreate = cfg["canCreateAgents"] === true;
+      } catch {
+        canCreate = false;
+      }
+      if (!canCreate) {
+        throw new Error(`Agent ${opts.actorAgentId} does not have permission to create agents`);
+      }
+    }
+    const row = await this.db.insert("agents", {
+      slug: agent.slug,
+      name: agent.name,
+      adapter: agent.adapter,
+      role: agent.role ?? "general",
+      ...Object.fromEntries(
+        Object.entries(agent).filter(([k]) => !["slug", "name", "adapter", "role"].includes(k))
+      )
+    });
+    const newAgentId = row["id"];
+    if (opts?.actorAgentId) {
+      await this.db.insert("activity_log", {
+        agent_id: opts.actorAgentId,
+        event_type: "agent_created_by_agent",
+        payload: JSON.stringify({
+          actorAgentId: opts.actorAgentId,
+          newAgentId,
+          slug: agent.slug
+        })
+      });
+    }
+    await this.hooks.emit("agent.created", { agentId: newAgentId, slug: agent.slug });
+    return newAgentId;
+  }
+  async getById(id) {
+    return await this.db.get("agents", { id }) ?? void 0;
+  }
+  async getBySlug(slug) {
+    const rows = await this.db.query("agents", { where: { slug } });
+    return rows[0] ?? void 0;
+  }
+  async list(filter) {
+    const where = {};
+    if (filter?.status) where["status"] = filter.status;
+    if (filter?.role) where["role"] = filter.role;
+    return await this.db.query("agents", Object.keys(where).length ? { where } : void 0);
+  }
+  async update(id, changes) {
+    const existing = await this.db.get("agents", { id });
+    if (!existing) throw new Error(`Agent not found: ${id}`);
+    const before = { ...existing };
+    await createConfigRevision(this.db, id, before, { ...before, ...changes });
+    await this.db.update("agents", { id }, {
+      ...changes,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async setStatus(id, newStatus) {
+    const agent = await this.db.get("agents", { id });
+    if (!agent) throw new Error(`Agent not found: ${id}`);
+    const currentStatus = agent["status"];
+    const allowed = VALID_TRANSITIONS[currentStatus] ?? [];
+    if (!allowed.includes(newStatus)) {
+      throw new Error(
+        `Invalid status transition: ${currentStatus} \u2192 ${newStatus}`
+      );
+    }
+    await this.db.update("agents", { id }, {
+      status: newStatus,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (WRITE_ACTIVITY_LOG_STATUSES.has(newStatus)) {
+      await this.db.insert("activity_log", {
+        agent_id: id,
+        event_type: `agent.${newStatus}`,
+        payload: JSON.stringify({ agentId: id, status: newStatus })
+      });
+    }
+  }
+  async terminate(id) {
+    const agent = await this.db.get("agents", { id });
+    if (!agent) throw new Error(`Agent not found: ${id}`);
+    const currentStatus = agent["status"];
+    if (currentStatus === "terminated") {
+      return;
+    }
+    await this.db.update("agents", { id }, {
+      status: "terminated",
+      deleted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.db.insert("activity_log", {
+      agent_id: id,
+      event_type: "agent.terminated",
+      payload: JSON.stringify({ agentId: id })
+    });
+  }
+  async seedFromConfig(agentConfigs) {
+    for (const config of agentConfigs) {
+      const existing = await this.getBySlug(config.slug);
+      if (existing) continue;
+      await this.register(config);
+    }
+  }
+};
+
+// src/core/orchestrator/chain-guard.ts
+var MAX_CHAIN_DEPTH = 5;
+function checkChainDepth(depth, max = MAX_CHAIN_DEPTH) {
+  if (depth > max) {
+    throw new Error(`Chain depth limit exceeded (max ${max})`);
+  }
+}
+function buildChainOrigin(parentTaskId, parentOriginId, parentDepth) {
+  if (!parentTaskId) {
+    return { chain_depth: 0 };
+  }
+  return {
+    chain_origin_id: parentOriginId ?? parentTaskId,
+    chain_depth: (parentDepth ?? 0) + 1
+  };
+}
+
+// src/core/orchestrator/task-queue.ts
+var TaskQueue = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.config = config;
+    this.pollIntervalMs = config?.pollIntervalMs ?? 3e4;
+    this.staleThresholdMs = config?.staleThresholdMs ?? 5 * 60 * 1e3;
+  }
+  db;
+  hooks;
+  config;
+  pollTimer = null;
+  pollIntervalMs;
+  staleThresholdMs;
+  async create(task) {
+    const depth = task.chain_depth ?? 0;
+    checkChainDepth(depth, MAX_CHAIN_DEPTH);
+    const row = await this.db.insert("tasks", {
+      title: task.title,
+      description: task.description,
+      assignee_id: task.assignee_id,
+      priority: task.priority ?? 5,
+      chain_depth: depth,
+      chain_origin_id: task.chain_origin_id,
+      status: "todo",
+      ...Object.fromEntries(
+        Object.entries(task).filter(
+          ([k]) => !["title", "description", "assignee_id", "priority", "chain_depth", "chain_origin_id", "status"].includes(k)
+        )
+      )
+    });
+    await this.hooks.emit("task.created", { taskId: row["id"], title: task.title });
+    return row["id"];
+  }
+  async update(id, changes) {
+    await this.db.update("tasks", { id }, {
+      ...changes,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async get(id) {
+    return await this.db.get("tasks", { id }) ?? void 0;
+  }
+  async list(filter) {
+    const where = {};
+    if (filter?.status) where["status"] = filter.status;
+    if (filter?.assignee_id) where["assignee_id"] = filter.assignee_id;
+    return await this.db.query("tasks", Object.keys(where).length ? { where } : void 0);
+  }
+  startPolling() {
+    if (this.pollTimer) return;
+    this.pollTimer = setInterval(() => {
+      void this.poll();
+    }, this.pollIntervalMs);
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  async poll() {
+    const todoTasks = (await this.db.query("tasks", { where: { status: "todo" } })).filter((t) => t["assignee_id"] != null);
+    const activeTasks = new Set(
+      (await this.db.query("runs", { where: { status: "running" } })).map((r) => r["task_id"])
+    );
+    const eligible = todoTasks.filter((t) => !activeTasks.has(t["id"])).sort((a, b) => a["priority"] - b["priority"]);
+    for (const task of eligible) {
+      await this.hooks.emit("agent.wakeup", {
+        agentId: task["assignee_id"],
+        taskId: task["id"],
+        source: "poll"
+      });
+    }
+  }
+};
+
+// src/core/orchestrator/template-interpolate.ts
+function interpolate(template, context) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (_match, path) => {
+    const parts = path.trim().split(".");
+    let value = context;
+    for (const part of parts) {
+      if (value == null || typeof value !== "object") return "";
+      value = value[part];
+    }
+    if (value == null) return "";
+    return String(value);
+  });
+}
+
+// src/core/orchestrator/run-manager.ts
+var DEFAULT_STALE_THRESHOLD_MS = 30 * 60 * 1e3;
+var BASE_BACKOFF_MS = 5e3;
+var DEFAULT_MAX_BACKOFF_MS = 5 * 60 * 1e3;
+var RunManager = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.config = config;
+    this.staleThresholdMs = config?.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+  }
+  db;
+  hooks;
+  config;
+  locks = /* @__PURE__ */ new Map();
+  // agentId → runId
+  orphanTimer = null;
+  staleThresholdMs;
+  isLocked(agentId) {
+    return this.locks.has(agentId);
+  }
+  async startRun(agentId, taskId, adapter) {
+    if (this.locks.has(agentId)) {
+      throw new Error(`Agent already has an active run`);
+    }
+    const row = await this.db.insert("runs", {
+      agent_id: agentId,
+      task_id: taskId,
+      adapter,
+      status: "running",
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const runId = row["id"];
+    this.locks.set(agentId, runId);
+    return runId;
+  }
+  async finishRun(runId, result) {
+    const run = await this.db.get("runs", { id: runId });
+    if (!run) throw new Error(`Run not found: ${runId}`);
+    const succeeded = result.exitCode === 0;
+    const status = succeeded ? "succeeded" : "failed";
+    const usage = result.usage;
+    await this.db.update("runs", { id: runId }, {
+      status,
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      exit_code: result.exitCode,
+      cost_cents: result.costCents ?? 0,
+      input_tokens: usage?.["inputTokens"] ?? 0,
+      output_tokens: usage?.["outputTokens"] ?? 0,
+      error_message: result.exitCode !== 0 ? result.output : void 0
+    });
+    const agentId = run["agent_id"];
+    this.locks.delete(agentId);
+    const taskId = run["task_id"];
+    if (!succeeded) {
+      const task = await this.db.get("tasks", { id: taskId });
+      if (task) {
+        const retryCount = task["retry_count"] ?? 0;
+        const maxRetries = task["max_retries"] ?? 0;
+        if (retryCount < maxRetries) {
+          const maxBackoff = this.config?.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+          const backoffMs = Math.min(BASE_BACKOFF_MS * Math.pow(2, retryCount), maxBackoff);
+          const nextRetryAt = new Date(Date.now() + backoffMs).toISOString();
+          await this.db.update("tasks", { id: taskId }, {
+            retry_count: retryCount + 1,
+            next_retry_at: nextRetryAt,
+            status: "todo",
+            execution_run_id: null,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } else {
+          await this.db.update("tasks", { id: taskId }, {
+            status: "failed",
+            updated_at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+    } else {
+      const task = await this.db.get("tasks", { id: taskId });
+      if (task && task["followup_agent_id"]) {
+        const chainDepth = (task["chain_depth"] ?? 0) + 1;
+        checkChainDepth(chainDepth, MAX_CHAIN_DEPTH);
+        const followupAgentId = task["followup_agent_id"];
+        const followupTemplate = task["followup_template"] ?? "Followup: {{output}}";
+        const context = { output: result.output ?? "" };
+        const title = interpolate(followupTemplate, context);
+        const chainOriginId = task["chain_origin_id"] ?? taskId;
+        await this.db.insert("tasks", {
+          title,
+          description: title,
+          assignee_id: followupAgentId,
+          status: "todo",
+          priority: task["priority"] ?? 5,
+          chain_depth: chainDepth,
+          chain_origin_id: chainOriginId
+        });
+        await this.hooks.emit("task.followup.created", {
+          originTaskId: taskId,
+          followupAgentId,
+          chainDepth
+        });
+      }
+    }
+    await this.hooks.emit("run.completed", {
+      runId,
+      agentId,
+      taskId,
+      status,
+      exitCode: result.exitCode
+    });
+  }
+  async reapOrphans() {
+    const cutoff = new Date(Date.now() - this.staleThresholdMs).toISOString();
+    const staleRuns = (await this.db.query("runs", { where: { status: "running" } })).filter((r) => {
+      const startedAt = r["started_at"];
+      return startedAt != null && startedAt < cutoff;
+    });
+    for (const run of staleRuns) {
+      await this.db.update("runs", { id: run["id"] }, {
+        status: "failed",
+        completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        error_message: "Orphaned run reaped by RunManager"
+      });
+      const agentId = run["agent_id"];
+      if (this.locks.get(agentId) === run["id"]) {
+        this.locks.delete(agentId);
+      }
+    }
+  }
+  startOrphanReaper(intervalMs = 6e4) {
+    if (this.orphanTimer) return;
+    this.orphanTimer = setInterval(() => {
+      void this.reapOrphans();
+    }, intervalMs);
+  }
+  stopOrphanReaper() {
+    if (this.orphanTimer) {
+      clearInterval(this.orphanTimer);
+      this.orphanTimer = null;
+    }
+  }
+};
+
+// src/core/orchestrator/budget-controller.ts
+var BudgetController = class {
+  constructor(db, hooks) {
+    this.db = db;
+    this.hooks = hooks;
+  }
+  db;
+  hooks;
+  async checkBudget(agentId) {
+    const agent = await this.db.get("agents", { id: agentId });
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+    const limitCents = agent["budget_monthly_cents"] ?? 0;
+    const currentSpendCents = agent["spent_monthly_cents"] ?? 0;
+    if (limitCents <= 0) {
+      return { allowed: true, currentSpendCents, limitCents };
+    }
+    if (currentSpendCents >= limitCents) {
+      return {
+        allowed: false,
+        reason: "Monthly budget exceeded",
+        currentSpendCents,
+        limitCents
+      };
+    }
+    let warnPercent = 80;
+    const agentPolicies = await this.db.query("budget_policies", {
+      where: { agent_id: agentId }
+    });
+    if (agentPolicies.length > 0) {
+      warnPercent = agentPolicies[0]["warn_percent"] ?? 80;
+    }
+    const warnThreshold = limitCents * (warnPercent / 100);
+    if (currentSpendCents >= warnThreshold) {
+      await this.hooks.emit("budget.exceeded", {
+        agentId,
+        currentSpendCents,
+        limitCents,
+        warnPercent,
+        message: `Budget warning: ${currentSpendCents} of ${limitCents} cents used (${warnPercent}% threshold)`
+      });
+    }
+    return { allowed: true, currentSpendCents, limitCents };
+  }
+  async resetMonthlySpend(agentId) {
+    await this.db.update("agents", { id: agentId }, {
+      spent_monthly_cents: 0,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async globalCheck() {
+    const agents = await this.db.query("agents");
+    const totalSpentCents = agents.reduce(
+      (sum, a) => sum + (a["spent_monthly_cents"] ?? 0),
+      0
+    );
+    const globalPolicies = await this.db.query("budget_policies", {
+      where: { scope: "global" }
+    });
+    if (globalPolicies.length === 0) {
+      return { allowed: true, totalSpentCents, limitCents: 0 };
+    }
+    const limitCents = globalPolicies[0]["monthly_limit_cents"] ?? 0;
+    if (limitCents <= 0) {
+      return { allowed: true, totalSpentCents, limitCents };
+    }
+    return {
+      allowed: totalSpentCents < limitCents,
+      totalSpentCents,
+      limitCents
+    };
+  }
+};
+
+// src/core/orchestrator/dependency-resolver.ts
+function detectCycle(steps) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    deps.set(s.id, s.dependsOn ?? []);
+  }
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  for (const s of steps) color.set(s.id, WHITE);
+  function dfs(node) {
+    color.set(node, GRAY);
+    for (const dep of deps.get(node) ?? []) {
+      const c = color.get(dep);
+      if (c === GRAY) return true;
+      if (c === WHITE && dfs(dep)) return true;
+    }
+    color.set(node, BLACK);
+    return false;
+  }
+  for (const s of steps) {
+    if (color.get(s.id) === WHITE && dfs(s.id)) return true;
+  }
+  return false;
+}
+function topologicalSort(steps) {
+  if (detectCycle(steps)) {
+    throw new Error("Cycle detected in step dependencies");
+  }
+  const deps = /* @__PURE__ */ new Map();
+  for (const s of steps) {
+    deps.set(s.id, s.dependsOn ?? []);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(id) {
+    if (visited.has(id)) return;
+    visited.add(id);
+    for (const dep of deps.get(id) ?? []) {
+      visit(dep);
+    }
+    result.push(id);
+  }
+  for (const s of steps) {
+    visit(s.id);
+  }
+  return result;
+}
+function areDependenciesMet(taskDepsJson, completedTaskIds) {
+  if (!taskDepsJson) return true;
+  let deps;
+  try {
+    deps = JSON.parse(taskDepsJson);
+  } catch {
+    return true;
+  }
+  if (!Array.isArray(deps) || deps.length === 0) return true;
+  return deps.every((id) => completedTaskIds.has(id));
+}
+
+// src/core/orchestrator/workflow-engine.ts
+var WorkflowEngine = class {
+  constructor(db, hooks, taskQueue) {
+    this.db = db;
+    this.hooks = hooks;
+    this.taskQueue = taskQueue;
+    this.hooks.register("task.completed", async (ctx) => {
+      const taskId = ctx["taskId"];
+      const output = ctx["output"] ?? "";
+      if (taskId) {
+        await this.onStepCompleted(taskId, output);
+      }
+    });
+  }
+  db;
+  hooks;
+  taskQueue;
+  /**
+   * Define/register a workflow.
+   */
+  async define(slug, def) {
+    const ids = def.steps.map((s) => s.id);
+    const unique = new Set(ids);
+    if (unique.size !== ids.length) {
+      throw new Error("Workflow has duplicate step IDs");
+    }
+    for (const step of def.steps) {
+      for (const dep of step.dependsOn ?? []) {
+        if (!unique.has(dep)) {
+          throw new Error(`Step "${step.id}" depends on unknown step "${dep}"`);
+        }
+      }
+    }
+    if (detectCycle(def.steps)) {
+      throw new Error("Workflow has cyclic step dependencies");
+    }
+    const existing = await this.db.query("workflows", { where: { slug } });
+    if (existing.length > 0) {
+      await this.db.update("workflows", { slug }, {
+        name: def.name,
+        description: def.description,
+        definition: JSON.stringify(def),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      await this.db.insert("workflows", {
+        slug,
+        name: def.name,
+        description: def.description,
+        definition: JSON.stringify(def)
+      });
+    }
+  }
+  /**
+   * Start a workflow run.
+   */
+  async start(workflowSlug, context) {
+    const workflows = await this.db.query("workflows", { where: { slug: workflowSlug } });
+    if (workflows.length === 0) {
+      throw new Error(`Workflow not found: ${workflowSlug}`);
+    }
+    const workflow = workflows[0];
+    const def = JSON.parse(workflow["definition"]);
+    const runRow = await this.db.insert("workflow_runs", {
+      workflow_id: workflow["id"],
+      status: "running",
+      step_results: JSON.stringify({}),
+      context: JSON.stringify(context)
+    });
+    const workflowRunId = runRow["id"];
+    const initialSteps = def.steps.filter((s) => !s.dependsOn || s.dependsOn.length === 0);
+    for (const step of initialSteps) {
+      await this._createStepTask(step, workflowRunId, workflow["id"], context);
+    }
+    return workflowRunId;
+  }
+  /**
+   * Called when a task with workflow_run_id completes.
+   */
+  async onStepCompleted(taskId, output) {
+    const task = await this.db.get("tasks", { id: taskId });
+    if (!task || !task["workflow_run_id"]) return;
+    const workflowRunId = task["workflow_run_id"];
+    const stepId = task["workflow_step_id"];
+    const run = await this.db.get("workflow_runs", { id: workflowRunId });
+    if (!run || run["status"] !== "running") return;
+    const stepResults = JSON.parse(run["step_results"] ?? "{}");
+    if (stepId) {
+      stepResults[stepId] = { output, taskId };
+    }
+    await this.db.update("workflow_runs", { id: workflowRunId }, {
+      step_results: JSON.stringify(stepResults),
+      current_step: stepId
+    });
+    const workflow = await this.db.get("workflows", { id: run["workflow_id"] });
+    if (!workflow) return;
+    const def = JSON.parse(workflow["definition"]);
+    const runContext = JSON.parse(run["context"] ?? "{}");
+    const stepsContext = {};
+    for (const [sid, result] of Object.entries(stepResults)) {
+      stepsContext[sid] = result;
+    }
+    const fullContext = { ...runContext, steps: stepsContext };
+    const allRunTasks = await this.db.query("tasks", { where: { workflow_run_id: workflowRunId } });
+    const completedStepIds = new Set(
+      allRunTasks.filter((t) => t["status"] === "done" || t["id"] === taskId).map((t) => t["workflow_step_id"]).filter(Boolean)
+    );
+    if (stepId) completedStepIds.add(stepId);
+    const startedStepIds = new Set(
+      allRunTasks.map((t) => t["workflow_step_id"]).filter(Boolean)
+    );
+    const nextSteps = def.steps.filter((s) => {
+      if (startedStepIds.has(s.id) && s.id !== stepId) return false;
+      if (s.id === stepId) return false;
+      if (!s.dependsOn || s.dependsOn.length === 0) return false;
+      return s.dependsOn.every((dep) => completedStepIds.has(dep));
+    });
+    if (nextSteps.length === 0) {
+      const allStepIds = new Set(def.steps.map((s) => s.id));
+      const allDone = [...allStepIds].every((id) => completedStepIds.has(id));
+      if (allDone) {
+        await this.db.update("workflow_runs", { id: workflowRunId }, {
+          status: "completed",
+          completed_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await this.hooks.emit("workflow.completed", { workflowRunId });
+      }
+      return;
+    }
+    for (const step of nextSteps) {
+      await this._createStepTask(step, workflowRunId, workflow["id"], fullContext);
+    }
+  }
+  /**
+   * Mark a workflow run as failed.
+   */
+  async onStepFailed(taskId, error) {
+    const task = await this.db.get("tasks", { id: taskId });
+    if (!task || !task["workflow_run_id"]) return;
+    const workflowRunId = task["workflow_run_id"];
+    const stepId = task["workflow_step_id"];
+    const run = await this.db.get("workflow_runs", { id: workflowRunId });
+    if (!run || run["status"] !== "running") return;
+    const workflow = await this.db.get("workflows", { id: run["workflow_id"] });
+    if (!workflow) return;
+    const def = JSON.parse(workflow["definition"]);
+    const step = stepId ? def.steps.find((s) => s.id === stepId) : void 0;
+    if (!step || step.onFail === "abort" || !step.onFail) {
+      await this.db.update("workflow_runs", { id: workflowRunId }, {
+        status: "failed",
+        error,
+        completed_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await this.hooks.emit("workflow.failed", { workflowRunId, error });
+    }
+  }
+  async _createStepTask(step, workflowRunId, workflowId, context) {
+    let assigneeId;
+    if (step.agentSlug) {
+      const agents = await this.db.query("agents", { where: { slug: step.agentSlug } });
+      if (agents.length > 0) {
+        assigneeId = agents[0]["id"];
+      }
+    }
+    const title = interpolate(step.taskTemplate.title, context);
+    const description = interpolate(step.taskTemplate.description, context);
+    const taskId = await this.taskQueue.create({
+      title,
+      description,
+      assignee_id: assigneeId,
+      workflow_run_id: workflowRunId,
+      workflow_step_id: step.id
+    });
+    return taskId;
+  }
+};
+
+// src/core/orchestrator/wakeup-queue.ts
+var WakeupQueue = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async enqueue(agentId, source, context) {
+    const row = await this.db.insert("wakeups", {
+      agent_id: agentId,
+      scheduled_at: (/* @__PURE__ */ new Date()).toISOString(),
+      context: context ? JSON.stringify({ source, ...context }) : JSON.stringify({ source })
+    });
+    return row["id"];
+  }
+  async coalesce(agentId, context) {
+    const existing = (await this.db.query("wakeups", {
+      where: { agent_id: agentId }
+    })).filter((w) => w["fired_at"] == null);
+    if (existing.length === 0) return;
+    const wakeup = existing[0];
+    const currentCtx = wakeup["context"] ? JSON.parse(wakeup["context"]) : {};
+    const merged = { ...currentCtx, ...context ?? {} };
+    await this.db.update("wakeups", { id: wakeup["id"] }, {
+      context: JSON.stringify(merged)
+    });
+  }
+  async getNext(agentId) {
+    const queued = (await this.db.query("wakeups", {
+      where: { agent_id: agentId }
+    })).filter((w) => w["fired_at"] == null).sort(
+      (a, b) => a["scheduled_at"].localeCompare(b["scheduled_at"])
+    );
+    return queued[0] ?? void 0;
+  }
+  async markFired(wakeupId, runId) {
+    await this.db.update("wakeups", { id: wakeupId }, {
+      fired_at: (/* @__PURE__ */ new Date()).toISOString(),
+      run_id: runId
+    });
+  }
+};
+
+// src/core/orchestrator/ndjson-logger.ts
+import { appendFileSync } from "fs";
+var NdjsonLogger = class {
+  constructor(logPath) {
+    this.logPath = logPath;
+  }
+  logPath;
+  log(stream, chunk) {
+    const line = JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      stream,
+      chunk
+    });
+    appendFileSync(this.logPath, line + "\n", "utf8");
+  }
+  close() {
+  }
+};
+
+// src/core/orchestrator/heartbeat-scheduler.ts
+var HeartbeatScheduler = class {
+  constructor(wakeupQueue, hooks) {
+    this.wakeupQueue = wakeupQueue;
+    this.hooks = hooks;
+  }
+  wakeupQueue;
+  hooks;
+  timers = /* @__PURE__ */ new Map();
+  start(agents) {
+    for (const agent of agents) {
+      let config;
+      try {
+        config = JSON.parse(agent.heartbeat_config);
+      } catch {
+        continue;
+      }
+      if (!config.enabled || !config.intervalSec) continue;
+      const timer = setInterval(() => {
+        void this.wakeupQueue.enqueue(agent.id, "heartbeat");
+      }, config.intervalSec * 1e3);
+      this.timers.set(agent.id, timer);
+    }
+  }
+  stop() {
+    for (const timer of this.timers.values()) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+  }
+};
+
+// src/core/orchestrator/adapters/api-adapter.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+
+// src/core/orchestrator/adapters/tool-loop.ts
+async function* toolLoop(params, callLLM, executeTool) {
+  const maxIterations = params.maxIterations ?? 20;
+  const messages = [...params.messages];
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    if (params.signal?.aborted) {
+      return;
+    }
+    iterations++;
+    const chatParams = {
+      model: params.model,
+      messages,
+      system: params.systemPrompt,
+      tools: params.tools
+    };
+    const result = await callLLM(chatParams);
+    if (result.content) {
+      yield { type: "text", content: result.content };
+    }
+    if (result.stopReason === "end_turn" || result.stopReason === "stop_sequence" || result.stopReason === "max_tokens") {
+      yield { type: "done", result };
+      return;
+    }
+    if (result.stopReason === "tool_use" && result.toolUses && result.toolUses.length > 0) {
+      const toolResults = [];
+      for (const toolUse of result.toolUses) {
+        yield { type: "tool_use", name: toolUse.name, input: toolUse.input };
+        if (executeTool) {
+          const toolResult = await executeTool(toolUse.name, toolUse.input);
+          toolResults.push(toolResult);
+          messages.push({
+            role: "assistant",
+            content: [
+              ...result.content ? [{ type: "text", text: result.content }] : [],
+              { type: "tool_use", id: toolUse.id, name: toolUse.name, input: toolUse.input }
+            ]
+          });
+          messages.push({
+            role: "user",
+            content: [
+              { type: "tool_result", tool_use_id: toolUse.id, content: toolResult }
+            ]
+          });
+        }
+      }
+      if (!executeTool) {
+        yield { type: "done", result };
+        return;
+      }
+    } else {
+      yield { type: "done", result };
+      return;
+    }
+  }
+  const finalResult = await callLLM({
+    model: params.model,
+    messages,
+    system: params.systemPrompt,
+    tools: params.tools
+  });
+  yield { type: "done", result: finalResult };
+}
+
+// src/core/orchestrator/adapters/api-adapter.ts
+var ApiExecutionAdapter = class {
+  constructor(modelRouter) {
+    this.modelRouter = modelRouter;
+  }
+  modelRouter;
+  type = "api";
+  async execute(ctx) {
+    const modelId = ctx.agent.model ?? "default";
+    const resolved = this.modelRouter.resolve(modelId) ?? this.modelRouter.resolveForPurpose("default");
+    const { provider, model } = resolved;
+    const registry = this.modelRouter.registry;
+    const providerImpl = registry.list().find((p) => p.id === provider);
+    if (!providerImpl) {
+      throw new Error(`Provider not found: ${provider}`);
+    }
+    let systemPrompt = "";
+    if (ctx.contextFiles && ctx.contextFiles.length > 0) {
+      const fileContents = [];
+      for (const filePath of ctx.contextFiles) {
+        if (existsSync2(filePath)) {
+          const content = readFileSync3(filePath, "utf8");
+          fileContents.push(`<file path="${filePath}">
+${content}
+</file>`);
+        }
+      }
+      if (fileContents.length > 0) {
+        systemPrompt = fileContents.join("\n\n");
+      }
+    }
+    const messages = [
+      ...ctx.sessionParams?.history ?? []
+    ];
+    const taskContent = [
+      ctx.task.description,
+      ctx.task.context
+    ].filter(Boolean).join("\n\n");
+    if (taskContent) {
+      messages.push({ role: "user", content: taskContent });
+    }
+    let outputText = "";
+    let totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const history = [...messages];
+    try {
+      const callLLM = (params) => providerImpl.chat(params);
+      for await (const event of toolLoop(
+        {
+          model,
+          messages,
+          systemPrompt: systemPrompt || void 0,
+          maxIterations: 20,
+          signal: ctx.abortSignal
+        },
+        callLLM
+      )) {
+        if (event.type === "text") {
+          outputText += event.content;
+          ctx.onLog?.("stdout", event.content);
+        } else if (event.type === "done") {
+          totalUsage = {
+            inputTokens: (totalUsage.inputTokens ?? 0) + (event.result.usage.inputTokens ?? 0),
+            outputTokens: (totalUsage.outputTokens ?? 0) + (event.result.usage.outputTokens ?? 0)
+          };
+        }
+      }
+      history.push({ role: "assistant", content: outputText });
+      return {
+        output: outputText,
+        exitCode: 0,
+        usage: { ...totalUsage, provider, model },
+        sessionParams: { history }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ctx.onLog?.("stderr", message);
+      return {
+        output: message,
+        exitCode: 1,
+        usage: { inputTokens: 0, outputTokens: 0, provider, model },
+        sessionParams: { history }
+      };
+    }
+  }
+};
+
+// src/core/orchestrator/adapters/cli-adapter.ts
+import { createWriteStream } from "fs";
+
+// src/core/orchestrator/adapters/process-manager.ts
+import { spawn } from "child_process";
+
+// src/core/orchestrator/adapters/env-whitelist.ts
+var DEFAULT_ALLOWED_ENV = [
+  "PATH",
+  "HOME",
+  "SHELL",
+  "LANG",
+  "USER",
+  "TERM",
+  "NODE_PATH",
+  "TMPDIR"
+];
+function filterEnv(allowed, extra) {
+  const allowedKeys = allowed ?? DEFAULT_ALLOWED_ENV;
+  const result = {};
+  for (const key of allowedKeys) {
+    const val = process.env[key];
+    if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  if (extra) {
+    Object.assign(result, extra);
+  }
+  return result;
+}
+
+// src/core/orchestrator/adapters/process-manager.ts
+function spawnProcess(command, args, opts) {
+  const env = filterEnv(opts.allowedEnvVars, opts.extraEnv);
+  const child = spawn(command, args, {
+    cwd: opts.cwd,
+    env,
+    detached: true,
+    stdio: "pipe"
+  });
+  return child;
+}
+function killProcessGroup(pid, signal = "SIGTERM") {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+}
+
+// src/core/orchestrator/adapters/output-extractor.ts
+import { readFileSync as readFileSync4 } from "fs";
+var MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+function extractOutput(ndjsonContent) {
+  const lines = ndjsonContent.split("\n").filter((l) => l.trim().length > 0);
+  let lastOutput;
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed["type"] === "result") {
+        const content = parsed["result"] ?? parsed["content"] ?? parsed["output"];
+        if (typeof content === "string") {
+          lastOutput = content;
+        }
+      } else if (parsed["role"] === "assistant") {
+        const content = parsed["content"];
+        if (typeof content === "string") {
+          lastOutput = content;
+        }
+      } else if (parsed["type"] === "assistant") {
+        const message = parsed["message"];
+        if (message && Array.isArray(message["content"])) {
+          for (const block of message["content"]) {
+            if (typeof block === "object" && block !== null && block["type"] === "text") {
+              lastOutput = block["text"];
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (!lastOutput) {
+    lastOutput = ndjsonContent;
+  }
+  if (Buffer.byteLength(lastOutput, "utf8") > MAX_OUTPUT_BYTES) {
+    return Buffer.from(lastOutput, "utf8").subarray(0, MAX_OUTPUT_BYTES).toString("utf8");
+  }
+  return lastOutput;
+}
+
+// src/core/orchestrator/adapters/cli-adapter.ts
+var CliExecutionAdapter = class {
+  type = "cli";
+  async execute(ctx) {
+    const cwd = ctx.agent.cwd ?? process.cwd();
+    let config = {};
+    if (ctx.agent.adapter_config) {
+      try {
+        config = JSON.parse(ctx.agent.adapter_config);
+      } catch {
+      }
+    }
+    const skipPermissions = ctx.agent.skip_permissions ?? config["skip_permissions"] ?? false;
+    const args = [];
+    if (skipPermissions) {
+      args.push("--dangerously-skip-permissions");
+    }
+    const prompt = [
+      ctx.task.title,
+      ctx.task.description,
+      ctx.task.context
+    ].filter(Boolean).join("\n\n");
+    args.push("--print", prompt);
+    const child = spawnProcess("claude", args, { cwd });
+    const stdoutChunks = [];
+    let logStream = null;
+    if (ctx.logPath) {
+      logStream = createWriteStream(ctx.logPath, { flags: "a" });
+    }
+    const abortHandler = () => {
+      if (child.pid != null) {
+        killProcessGroup(child.pid);
+      }
+    };
+    ctx.abortSignal?.addEventListener("abort", abortHandler);
+    child.stdout?.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+      const str = chunk.toString("utf8");
+      ctx.onLog?.("stdout", str);
+      logStream?.write(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const str = chunk.toString("utf8");
+      ctx.onLog?.("stderr", str);
+    });
+    const exitCode = await new Promise((resolve) => {
+      child.on("close", (code) => {
+        resolve(code ?? 1);
+      });
+      child.on("error", () => {
+        resolve(1);
+      });
+    });
+    ctx.abortSignal?.removeEventListener("abort", abortHandler);
+    logStream?.end();
+    const rawOutput = Buffer.concat(stdoutChunks).toString("utf8");
+    const output = extractOutput(rawOutput);
+    return { output, exitCode };
+  }
+};
+export {
+  AGENT_STATUSES,
+  AgentRegistry,
+  ApiExecutionAdapter,
+  AuditEmitter,
+  BackupManager,
+  BudgetController,
+  CORE_MIGRATIONS,
+  ChannelRegistry,
+  ChannelRegistryError,
+  ChatSessionManager,
+  CliExecutionAdapter,
+  ColumnValidatorImpl,
+  DEFAULTS,
+  DEFAULT_CONFIG,
+  DataStore,
+  DataStoreError,
+  EVENTS,
+  HeartbeatScheduler,
+  HookBus,
+  MAX_CHAIN_DEPTH,
+  MessagePipeline,
+  ModelRouter,
+  NdjsonLogger,
+  NotificationQueue,
+  ProviderRegistry,
+  RUN_STATUSES,
+  RunManager,
+  SessionKey,
+  SessionManager,
+  TASK_STATUSES,
+  TaskQueue,
+  UpdateChecker,
+  UpdateManager,
+  WakeupQueue,
+  WorkflowEngine,
+  _resetConfig,
+  areDependenciesMet,
+  buildAgentBindings,
+  buildChainOrigin,
+  checkAllowlist,
+  checkChainDepth,
+  checkMentionGate,
+  chunkText,
+  classifyUpdate,
+  compareVersions,
+  createConfigRevision,
+  defineCoreTables,
+  detectCycle,
+  discoverChannels,
+  discoverProviders,
+  formatText,
+  getConfig,
+  initConfig,
+  interpolate,
+  interpolateEnv,
+  loadConfig,
+  parseVersion,
+  runPackageMigrations,
+  sanitize,
+  topologicalSort,
+  validateConfig
+};