@yugenlab/vaayu 0.1.0

package/chunks/chunk-MINFB5LT.js

@@ -0,0 +1,1479 @@
+// packages/storage/src/postgres/pool.ts
+import { createRequire } from "node:module";
+function createPool(url) {
+  const require2 = createRequire(import.meta.url);
+  const { Pool } = require2("pg");
+  return new Pool({ connectionString: url });
+}
+
+// packages/storage/src/postgres/migrations.ts
+async function runMigrations(pool) {
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, key TEXT UNIQUE, created_at TEXT, updated_at TEXT, user_id TEXT, channel TEXT, chat_type TEXT, chat_id TEXT, peer_id TEXT, account_id TEXT, thread_id TEXT, label TEXT, current_provider TEXT, current_model TEXT, providers_used TEXT, provider_switches INTEGER)"
+  );
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS user_id TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS channel TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS chat_type TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS chat_id TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS peer_id TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS account_id TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS thread_id TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS label TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS current_provider TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS current_model TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS providers_used TEXT");
+  await pool.query("ALTER TABLE sessions ADD COLUMN IF NOT EXISTS provider_switches INTEGER");
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS audit (id TEXT PRIMARY KEY, time TEXT, type TEXT, payload TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_events (id TEXT PRIMARY KEY, session_id TEXT, role TEXT, content TEXT, metadata TEXT, created_at TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_summaries (session_id TEXT PRIMARY KEY, summary TEXT, event_count INTEGER, updated_at TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS tool_policy (id TEXT PRIMARY KEY, allow TEXT, deny TEXT, updated_at TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_prefs (session_id TEXT PRIMARY KEY, provider_id TEXT, model TEXT, system TEXT, auto_routing BOOLEAN, language TEXT, language_updated_at TEXT, continuity_preferred_device_id TEXT, continuity_mode TEXT, proactive_allowed BOOLEAN, proactive_observe BOOLEAN, proactive_deliver BOOLEAN, proactive_allowed_channels TEXT, proactive_paused_until TEXT, proactive_max_per_day INTEGER, proactive_cooldown_ms INTEGER, proactive_delivered_day TEXT, proactive_delivered_count INTEGER, proactive_last_delivered_at TEXT, updated_at TEXT)"
+  );
+  await pool.query("ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS auto_routing BOOLEAN");
+  await pool.query("ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS language TEXT");
+  await pool.query("ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS language_updated_at TEXT");
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS continuity_preferred_device_id TEXT"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS continuity_mode TEXT"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_allowed BOOLEAN"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_observe BOOLEAN"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_deliver BOOLEAN"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_allowed_channels TEXT"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_paused_until TEXT"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_max_per_day INTEGER"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_cooldown_ms INTEGER"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_delivered_day TEXT"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_delivered_count INTEGER"
+  );
+  await pool.query(
+    "ALTER TABLE session_prefs ADD COLUMN IF NOT EXISTS proactive_last_delivered_at TEXT"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_providers (session_id TEXT NOT NULL, provider_id TEXT NOT NULL, model TEXT, first_used_at TEXT, last_used_at TEXT, usage_count INTEGER, PRIMARY KEY (session_id, provider_id))"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS provider_switches (id TEXT PRIMARY KEY, session_id TEXT, from_provider_id TEXT, to_provider_id TEXT, from_model TEXT, to_model TEXT, reason TEXT, created_at TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS devices (id TEXT PRIMARY KEY, name TEXT, type TEXT, role TEXT, caps TEXT, status TEXT, scopes TEXT, auth_type TEXT, token_hash TEXT UNIQUE, token_hint TEXT, public_key TEXT, public_key_alg TEXT, created_at TEXT, updated_at TEXT, last_seen_at TEXT)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS channel_allows (id TEXT PRIMARY KEY, channel TEXT, chat_id TEXT, user_id TEXT, status TEXT, note TEXT, created_at TEXT, updated_at TEXT)"
+  );
+  await pool.query(
+    "CREATE UNIQUE INDEX IF NOT EXISTS channel_allows_key ON channel_allows(channel, chat_id, user_id)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS approval_requests (id TEXT PRIMARY KEY, status TEXT, kind TEXT, tool_name TEXT, tool_input TEXT, session_id TEXT, channel TEXT, chat_id TEXT, user_id TEXT, user_text TEXT, risk TEXT, reason TEXT, created_at TEXT, updated_at TEXT, expires_at TEXT, decided_at TEXT, decided_by TEXT, result TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS approval_requests_status_idx ON approval_requests(status, created_at)"
+  );
+  await pool.query("ALTER TABLE devices ADD COLUMN IF NOT EXISTS auth_type TEXT");
+  await pool.query("ALTER TABLE devices ADD COLUMN IF NOT EXISTS public_key TEXT");
+  await pool.query("ALTER TABLE devices ADD COLUMN IF NOT EXISTS public_key_alg TEXT");
+  await pool.query("ALTER TABLE devices ADD COLUMN IF NOT EXISTS role TEXT");
+  await pool.query("ALTER TABLE devices ADD COLUMN IF NOT EXISTS caps TEXT");
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS agent_runs (id TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, parent_agent_id TEXT, parent_run_id TEXT, lane TEXT, status TEXT, created_at TEXT, started_at TEXT, ended_at TEXT, timeout_ms INTEGER, channel TEXT, chat_id TEXT, user_id TEXT, provider_id TEXT, model TEXT, system TEXT, text TEXT, metadata TEXT, metrics TEXT, result_summary TEXT, error TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_runs_status_idx ON agent_runs(status, created_at)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_runs_session_idx ON agent_runs(session_id, created_at)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_runs_lane_idx ON agent_runs(lane, created_at)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS agent_queue (id TEXT PRIMARY KEY, session_id TEXT, agent_id TEXT, parent_agent_id TEXT, parent_run_id TEXT, lane TEXT, status TEXT, created_at TEXT, started_at TEXT, ended_at TEXT, lease_until TEXT, priority INTEGER, channel TEXT, chat_id TEXT, user_id TEXT, provider_id TEXT, model TEXT, system TEXT, text TEXT, timeout_ms INTEGER, tool_policy TEXT, metadata TEXT, error TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_queue_status_idx ON agent_queue(status, created_at)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_queue_lane_idx ON agent_queue(lane, created_at)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_queue_session_idx ON agent_queue(session_id, created_at)"
+  );
+  await pool.query("ALTER TABLE agent_queue ADD COLUMN IF NOT EXISTS lease_until TEXT");
+  await pool.query("ALTER TABLE agent_queue ADD COLUMN IF NOT EXISTS agent_id TEXT");
+  await pool.query("ALTER TABLE agent_queue ADD COLUMN IF NOT EXISTS parent_agent_id TEXT");
+  await pool.query("ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS agent_id TEXT");
+  await pool.query("ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS parent_agent_id TEXT");
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_routes (session_id TEXT PRIMARY KEY, agent_id TEXT, lane_id TEXT, queue_mode TEXT, announce_mode TEXT, updated_at TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS session_routes_updated_idx ON session_routes(updated_at)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS agent_run_events (id TEXT PRIMARY KEY, run_id TEXT, time TEXT, type TEXT, payload TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS agent_run_events_run_idx ON agent_run_events(run_id, time)"
+  );
+  await pool.query(
+    "CREATE TABLE IF NOT EXISTS session_inbox (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, status TEXT, created_at TEXT, started_at TEXT, ended_at TEXT, channel TEXT, chat_id TEXT, user_id TEXT, text TEXT, metadata TEXT, error TEXT)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS session_inbox_session_idx ON session_inbox(session_id, created_at)"
+  );
+  await pool.query(
+    "CREATE INDEX IF NOT EXISTS session_inbox_status_idx ON session_inbox(status, created_at)"
+  );
+}
+
+// packages/storage/src/postgres/sessions.ts
+import { randomUUID } from "node:crypto";
+
+// packages/storage/src/postgres/mappers.ts
+var parseJson = (value) => {
+  if (typeof value !== "string" || !value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+};
+function mapSession(row) {
+  const providersUsedRaw = row.providers_used ? String(row.providers_used) : "";
+  let providersUsed;
+  if (providersUsedRaw) {
+    try {
+      const parsed = JSON.parse(providersUsedRaw);
+      providersUsed = Array.isArray(parsed) ? parsed.map((value) => String(value)) : void 0;
+    } catch {
+      providersUsed = void 0;
+    }
+  }
+  return {
+    id: String(row.id),
+    key: String(row.key),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    userId: row.user_id ? String(row.user_id) : void 0,
+    channel: row.channel ? String(row.channel) : void 0,
+    chatType: row.chat_type ? String(row.chat_type) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    peerId: row.peer_id ? String(row.peer_id) : void 0,
+    accountId: row.account_id ? String(row.account_id) : void 0,
+    threadId: row.thread_id ? String(row.thread_id) : void 0,
+    label: row.label ? String(row.label) : void 0,
+    currentProviderId: row.current_provider ? String(row.current_provider) : void 0,
+    currentModel: row.current_model ? String(row.current_model) : void 0,
+    providersUsed,
+    providerSwitches: row.provider_switches === null || row.provider_switches === void 0 ? void 0 : Number(row.provider_switches)
+  };
+}
+function mapPrefs(row) {
+  let proactiveAllowedChannels;
+  if (row.proactive_allowed_channels) {
+    try {
+      const parsed = JSON.parse(String(row.proactive_allowed_channels));
+      if (Array.isArray(parsed)) {
+        proactiveAllowedChannels = parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      proactiveAllowedChannels = void 0;
+    }
+  }
+  return {
+    sessionId: String(row.session_id),
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    autoRouting: row.auto_routing === null || row.auto_routing === void 0 ? void 0 : Boolean(row.auto_routing),
+    language: row.language ? String(row.language) : void 0,
+    languageUpdatedAt: row.language_updated_at ? String(row.language_updated_at) : void 0,
+    continuityPreferredDeviceId: row.continuity_preferred_device_id ? String(row.continuity_preferred_device_id) : void 0,
+    continuityMode: row.continuity_mode === "auto" || row.continuity_mode === "prompt" || row.continuity_mode === "off" ? row.continuity_mode : void 0,
+    proactiveAllowed: row.proactive_allowed === null || row.proactive_allowed === void 0 ? void 0 : Boolean(row.proactive_allowed),
+    proactiveObserve: row.proactive_observe === null || row.proactive_observe === void 0 ? void 0 : Boolean(row.proactive_observe),
+    proactiveDeliver: row.proactive_deliver === null || row.proactive_deliver === void 0 ? void 0 : Boolean(row.proactive_deliver),
+    proactiveAllowedChannels,
+    proactivePausedUntil: row.proactive_paused_until ? String(row.proactive_paused_until) : void 0,
+    proactiveMaxPerDay: row.proactive_max_per_day === null || row.proactive_max_per_day === void 0 ? void 0 : Number(row.proactive_max_per_day),
+    proactiveCooldownMs: row.proactive_cooldown_ms === null || row.proactive_cooldown_ms === void 0 ? void 0 : Number(row.proactive_cooldown_ms),
+    proactiveDeliveredDay: row.proactive_delivered_day ? String(row.proactive_delivered_day) : void 0,
+    proactiveDeliveredCount: row.proactive_delivered_count === null || row.proactive_delivered_count === void 0 ? void 0 : Number(row.proactive_delivered_count),
+    proactiveLastDeliveredAt: row.proactive_last_delivered_at ? String(row.proactive_last_delivered_at) : void 0,
+    updatedAt: String(row.updated_at)
+  };
+}
+function mapEvent(row) {
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    role: String(row.role),
+    content: String(row.content),
+    metadata: row.metadata ? parseJson(String(row.metadata)) : void 0,
+    createdAt: String(row.created_at)
+  };
+}
+function mapSummary(row) {
+  return {
+    sessionId: String(row.session_id),
+    summary: String(row.summary),
+    eventCount: row.event_count === null || row.event_count === void 0 ? void 0 : Number(row.event_count),
+    updatedAt: String(row.updated_at)
+  };
+}
+function mapDevice(row) {
+  return {
+    id: String(row.id),
+    name: row.name ? String(row.name) : void 0,
+    type: row.type ? String(row.type) : void 0,
+    role: row.role ? String(row.role) : void 0,
+    caps: row.caps ? parseJson(String(row.caps)) : void 0,
+    status: row.status === "revoked" ? "revoked" : "active",
+    scopes: row.scopes ? parseJson(String(row.scopes)) : void 0,
+    authType: row.auth_type === "keypair" ? "keypair" : "token",
+    tokenHash: row.token_hash ? String(row.token_hash) : void 0,
+    tokenHint: row.token_hint ? String(row.token_hint) : void 0,
+    publicKey: row.public_key ? String(row.public_key) : void 0,
+    publicKeyAlgorithm: row.public_key_alg ? String(row.public_key_alg) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    lastSeenAt: row.last_seen_at ? String(row.last_seen_at) : void 0
+  };
+}
+function mapChannelAllow(row) {
+  const userId = row.user_id ? String(row.user_id) : "";
+  return {
+    id: String(row.id),
+    channel: String(row.channel),
+    chatId: String(row.chat_id),
+    userId: userId.length > 0 ? userId : void 0,
+    status: row.status === "revoked" ? "revoked" : "allowed",
+    note: row.note ? String(row.note) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+function mapApproval(row) {
+  const toolInput = parseJson(row.tool_input);
+  const decidedBy = parseJson(row.decided_by);
+  const result = parseJson(row.result);
+  const kind = typeof row.kind === "string" && row.kind.trim() ? row.kind : "tool";
+  return {
+    id: String(row.id),
+    status: String(row.status),
+    kind,
+    toolName: String(row.tool_name),
+    toolInput: toolInput ?? {},
+    sessionId: String(row.session_id),
+    channel: String(row.channel),
+    chatId: String(row.chat_id),
+    userId: row.user_id ? String(row.user_id) : void 0,
+    userText: row.user_text ? String(row.user_text) : void 0,
+    risk: row.risk ? String(row.risk) : void 0,
+    reason: row.reason ? String(row.reason) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    expiresAt: row.expires_at ? String(row.expires_at) : void 0,
+    decidedAt: row.decided_at ? String(row.decided_at) : void 0,
+    decidedBy: decidedBy ?? void 0,
+    result: result ?? void 0
+  };
+}
+
+// packages/storage/src/postgres/sessions.ts
+var createSessionStore = (pool) => {
+  const sessionSelect = "SELECT id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches ";
+  return {
+    async getSessionByKey(key) {
+      const result = await pool.query(`${sessionSelect}FROM sessions WHERE key = $1`, [key]);
+      return result.rows[0] ? mapSession(result.rows[0]) : void 0;
+    },
+    async getSessionById(id) {
+      const result = await pool.query(`${sessionSelect}FROM sessions WHERE id = $1`, [id]);
+      return result.rows[0] ? mapSession(result.rows[0]) : void 0;
+    },
+    async listSessions() {
+      const result = await pool.query(`${sessionSelect}FROM sessions ORDER BY created_at DESC`);
+      return result.rows.map(mapSession);
+    },
+    async createSession(key, meta) {
+      const existing = await this.getSessionByKey(key);
+      if (existing) {
+        return existing;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const record = {
+        id: randomUUID(),
+        key,
+        createdAt: now,
+        updatedAt: now,
+        userId: meta?.userId,
+        channel: meta?.channel,
+        chatType: meta?.chatType,
+        chatId: meta?.chatId,
+        peerId: meta?.peerId,
+        accountId: meta?.accountId,
+        threadId: meta?.threadId,
+        label: meta?.label,
+        currentProviderId: meta?.currentProviderId,
+        currentModel: meta?.currentModel,
+        providersUsed: meta?.providersUsed,
+        providerSwitches: meta?.providerSwitches
+      };
+      await pool.query(
+        "INSERT INTO sessions (id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) ON CONFLICT (key) DO NOTHING",
+        [
+          record.id,
+          record.key,
+          record.createdAt,
+          record.updatedAt,
+          record.userId ?? null,
+          record.channel ?? null,
+          record.chatType ?? null,
+          record.chatId ?? null,
+          record.peerId ?? null,
+          record.accountId ?? null,
+          record.threadId ?? null,
+          record.label ?? null,
+          record.currentProviderId ?? null,
+          record.currentModel ?? null,
+          record.providersUsed ? JSON.stringify(record.providersUsed) : null,
+          record.providerSwitches ?? null
+        ]
+      );
+      const stored = await this.getSessionByKey(key);
+      return stored ?? record;
+    },
+    async updateSession(id, update) {
+      const existing = await this.getSessionById(id);
+      if (!existing) {
+        return void 0;
+      }
+      const merged = {
+        ...existing,
+        ...update,
+        updatedAt: update.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await pool.query(
+        "UPDATE sessions SET key = $1, updated_at = $2, user_id = $3, channel = $4, chat_type = $5, chat_id = $6, peer_id = $7, account_id = $8, thread_id = $9, label = $10, current_provider = $11, current_model = $12, providers_used = $13, provider_switches = $14 WHERE id = $15",
+        [
+          merged.key,
+          merged.updatedAt,
+          merged.userId ?? null,
+          merged.channel ?? null,
+          merged.chatType ?? null,
+          merged.chatId ?? null,
+          merged.peerId ?? null,
+          merged.accountId ?? null,
+          merged.threadId ?? null,
+          merged.label ?? null,
+          merged.currentProviderId ?? null,
+          merged.currentModel ?? null,
+          merged.providersUsed ? JSON.stringify(merged.providersUsed) : null,
+          merged.providerSwitches ?? null,
+          merged.id
+        ]
+      );
+      return merged;
+    },
+    async appendProviderSwitch(record) {
+      await pool.query(
+        "INSERT INTO provider_switches (id, session_id, from_provider_id, to_provider_id, from_model, to_model, reason, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
+        [
+          record.id,
+          record.sessionId,
+          record.fromProviderId ?? null,
+          record.toProviderId ?? null,
+          record.fromModel ?? null,
+          record.toModel ?? null,
+          record.reason ?? null,
+          record.createdAt
+        ]
+      );
+    },
+    async upsertSessionProviderUsage(entry) {
+      const usedAt = entry.usedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      await pool.query(
+        "INSERT INTO session_providers (session_id, provider_id, model, first_used_at, last_used_at, usage_count) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (session_id, provider_id) DO UPDATE SET model = EXCLUDED.model, last_used_at = EXCLUDED.last_used_at, usage_count = session_providers.usage_count + 1",
+        [
+          entry.sessionId,
+          entry.providerId,
+          entry.model ?? null,
+          usedAt,
+          usedAt,
+          1
+        ]
+      );
+    },
+    async appendSessionEvent(event) {
+      await pool.query(
+        "INSERT INTO session_events (id, session_id, role, content, metadata, created_at) VALUES ($1, $2, $3, $4, $5, $6)",
+        [
+          event.id,
+          event.sessionId,
+          event.role,
+          event.content,
+          event.metadata ? JSON.stringify(event.metadata) : null,
+          event.createdAt
+        ]
+      );
+    },
+    async listSessionEvents(sessionId, options) {
+      const limit = options?.limit ?? 50;
+      const result = await pool.query(
+        "SELECT id, session_id, role, content, metadata, created_at FROM session_events WHERE session_id = $1 ORDER BY created_at DESC LIMIT $2",
+        [sessionId, limit]
+      );
+      return result.rows.map(mapEvent).reverse();
+    },
+    async countSessionEvents(sessionId) {
+      const result = await pool.query(
+        "SELECT COUNT(*) as count FROM session_events WHERE session_id = $1",
+        [sessionId]
+      );
+      const value = result.rows[0]?.count;
+      return typeof value === "number" ? value : Number(value ?? 0);
+    },
+    async getSessionSummary(sessionId) {
+      const result = await pool.query(
+        "SELECT session_id, summary, event_count, updated_at FROM session_summaries WHERE session_id = $1",
+        [sessionId]
+      );
+      return result.rows[0] ? mapSummary(result.rows[0]) : void 0;
+    },
+    async setSessionSummary(sessionId, summary, eventCount) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await pool.query(
+        "INSERT INTO session_summaries (session_id, summary, event_count, updated_at) VALUES ($1, $2, $3, $4) ON CONFLICT (session_id) DO UPDATE SET summary = EXCLUDED.summary, event_count = EXCLUDED.event_count, updated_at = EXCLUDED.updated_at",
+        [sessionId, summary, eventCount ?? null, now]
+      );
+      return await this.getSessionSummary(sessionId) ?? {
+        sessionId,
+        summary,
+        eventCount,
+        updatedAt: now
+      };
+    }
+  };
+};
+
+// packages/storage/src/postgres/prefs.ts
+var createSessionPrefsStore = (pool) => {
+  return {
+    async getSessionPrefs(sessionId) {
+      const result = await pool.query(
+        "SELECT session_id, provider_id, model, system, auto_routing, language, language_updated_at, continuity_preferred_device_id, continuity_mode, proactive_allowed, proactive_observe, proactive_deliver, proactive_allowed_channels, proactive_paused_until, proactive_max_per_day, proactive_cooldown_ms, proactive_delivered_day, proactive_delivered_count, proactive_last_delivered_at, updated_at FROM session_prefs WHERE session_id = $1",
+        [sessionId]
+      );
+      return result.rows[0] ? mapPrefs(result.rows[0]) : void 0;
+    },
+    async setSessionPrefs(sessionId, prefs) {
+      const existing = await this.getSessionPrefs(sessionId);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const providerId = prefs.providerId ?? existing?.providerId ?? null;
+      const model = prefs.model ?? existing?.model ?? null;
+      const system = prefs.system ?? existing?.system ?? null;
+      const autoRouting = prefs.autoRouting ?? existing?.autoRouting ?? null;
+      const hasLanguage = Object.prototype.hasOwnProperty.call(prefs, "language");
+      const language = hasLanguage ? prefs.language ?? null : existing?.language ?? null;
+      const hasLanguageUpdatedAt = Object.prototype.hasOwnProperty.call(prefs, "languageUpdatedAt");
+      const languageUpdatedAt = hasLanguage ? prefs.language ? prefs.languageUpdatedAt ?? now : null : hasLanguageUpdatedAt ? prefs.languageUpdatedAt ?? null : existing?.languageUpdatedAt ?? null;
+      const hasContinuityDevice = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "continuityPreferredDeviceId"
+      );
+      const continuityPreferredDeviceId = hasContinuityDevice ? prefs.continuityPreferredDeviceId ?? null : existing?.continuityPreferredDeviceId ?? null;
+      const hasContinuityMode = Object.prototype.hasOwnProperty.call(prefs, "continuityMode");
+      const continuityMode = hasContinuityMode ? prefs.continuityMode ?? null : existing?.continuityMode ?? null;
+      const proactiveAllowed = prefs.proactiveAllowed ?? existing?.proactiveAllowed ?? null;
+      const proactiveObserve = prefs.proactiveObserve ?? existing?.proactiveObserve ?? null;
+      const proactiveDeliver = prefs.proactiveDeliver ?? existing?.proactiveDeliver ?? null;
+      const hasAllowedChannels = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveAllowedChannels"
+      );
+      const proactiveAllowedChannels = hasAllowedChannels ? prefs.proactiveAllowedChannels ?? null : existing?.proactiveAllowedChannels ?? null;
+      const hasPausedUntil = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactivePausedUntil"
+      );
+      const proactivePausedUntil = hasPausedUntil ? prefs.proactivePausedUntil ?? null : existing?.proactivePausedUntil ?? null;
+      const hasMaxPerDay = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveMaxPerDay"
+      );
+      const proactiveMaxPerDay = hasMaxPerDay ? prefs.proactiveMaxPerDay ?? null : existing?.proactiveMaxPerDay ?? null;
+      const hasCooldown = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveCooldownMs"
+      );
+      const proactiveCooldownMs = hasCooldown ? prefs.proactiveCooldownMs ?? null : existing?.proactiveCooldownMs ?? null;
+      const hasDeliveredDay = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveDeliveredDay"
+      );
+      const proactiveDeliveredDay = hasDeliveredDay ? prefs.proactiveDeliveredDay ?? null : existing?.proactiveDeliveredDay ?? null;
+      const hasDeliveredCount = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveDeliveredCount"
+      );
+      const proactiveDeliveredCount = hasDeliveredCount ? prefs.proactiveDeliveredCount ?? null : existing?.proactiveDeliveredCount ?? null;
+      const hasLastDelivered = Object.prototype.hasOwnProperty.call(
+        prefs,
+        "proactiveLastDeliveredAt"
+      );
+      const proactiveLastDeliveredAt = hasLastDelivered ? prefs.proactiveLastDeliveredAt ?? null : existing?.proactiveLastDeliveredAt ?? null;
+      await pool.query(
+        "INSERT INTO session_prefs (session_id, provider_id, model, system, auto_routing, language, language_updated_at, continuity_preferred_device_id, continuity_mode, proactive_allowed, proactive_observe, proactive_deliver, proactive_allowed_channels, proactive_paused_until, proactive_max_per_day, proactive_cooldown_ms, proactive_delivered_day, proactive_delivered_count, proactive_last_delivered_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20) ON CONFLICT (session_id) DO UPDATE SET provider_id = EXCLUDED.provider_id, model = EXCLUDED.model, system = EXCLUDED.system, auto_routing = EXCLUDED.auto_routing, language = EXCLUDED.language, language_updated_at = EXCLUDED.language_updated_at, continuity_preferred_device_id = EXCLUDED.continuity_preferred_device_id, continuity_mode = EXCLUDED.continuity_mode, proactive_allowed = EXCLUDED.proactive_allowed, proactive_observe = EXCLUDED.proactive_observe, proactive_deliver = EXCLUDED.proactive_deliver, proactive_allowed_channels = EXCLUDED.proactive_allowed_channels, proactive_paused_until = EXCLUDED.proactive_paused_until, proactive_max_per_day = EXCLUDED.proactive_max_per_day, proactive_cooldown_ms = EXCLUDED.proactive_cooldown_ms, proactive_delivered_day = EXCLUDED.proactive_delivered_day, proactive_delivered_count = EXCLUDED.proactive_delivered_count, proactive_last_delivered_at = EXCLUDED.proactive_last_delivered_at, updated_at = EXCLUDED.updated_at",
+        [
+          sessionId,
+          providerId,
+          model,
+          system,
+          autoRouting,
+          language,
+          languageUpdatedAt,
+          continuityPreferredDeviceId,
+          continuityMode,
+          proactiveAllowed,
+          proactiveObserve,
+          proactiveDeliver,
+          Array.isArray(proactiveAllowedChannels) ? JSON.stringify(proactiveAllowedChannels) : null,
+          proactivePausedUntil,
+          proactiveMaxPerDay,
+          proactiveCooldownMs,
+          proactiveDeliveredDay,
+          proactiveDeliveredCount,
+          proactiveLastDeliveredAt,
+          now
+        ]
+      );
+      return await this.getSessionPrefs(sessionId) ?? {
+        sessionId,
+        providerId: providerId ?? void 0,
+        model: model ?? void 0,
+        system: system ?? void 0,
+        autoRouting: autoRouting ?? void 0,
+        language: language ?? void 0,
+        languageUpdatedAt: languageUpdatedAt ?? void 0,
+        continuityPreferredDeviceId: continuityPreferredDeviceId ?? void 0,
+        continuityMode: continuityMode ?? void 0,
+        updatedAt: now
+      };
+    },
+    async clearSessionPrefs(sessionId) {
+      await pool.query("DELETE FROM session_prefs WHERE session_id = $1", [sessionId]);
+    }
+  };
+};
+
+// packages/storage/src/postgres/tool-policy.ts
+var createToolPolicyStore = (pool) => {
+  return {
+    async getToolPolicy() {
+      const result = await pool.query(
+        "SELECT id, allow, deny, updated_at FROM tool_policy WHERE id = $1",
+        ["global"]
+      );
+      const row = result.rows[0];
+      if (!row) {
+        return void 0;
+      }
+      return {
+        allow: row.allow ? JSON.parse(String(row.allow)) : void 0,
+        deny: row.deny ? JSON.parse(String(row.deny)) : void 0,
+        updatedAt: row.updated_at ? String(row.updated_at) : void 0
+      };
+    },
+    async setToolPolicy(policy) {
+      const record = {
+        allow: policy.allow ?? [],
+        deny: policy.deny ?? [],
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await pool.query(
+        "INSERT INTO tool_policy (id, allow, deny, updated_at) VALUES ($1, $2, $3, $4) ON CONFLICT (id) DO UPDATE SET allow = EXCLUDED.allow, deny = EXCLUDED.deny, updated_at = EXCLUDED.updated_at",
+        [
+          "global",
+          JSON.stringify(record.allow ?? []),
+          JSON.stringify(record.deny ?? []),
+          record.updatedAt
+        ]
+      );
+      return record;
+    }
+  };
+};
+
+// packages/storage/src/postgres/devices.ts
+var createDeviceStore = (pool) => {
+  const selectDevices = "SELECT id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at ";
+  return {
+    async listDevices() {
+      const result = await pool.query(`${selectDevices}FROM devices ORDER BY created_at DESC`);
+      return result.rows.map(mapDevice);
+    },
+    async getDeviceById(id) {
+      const result = await pool.query(`${selectDevices}FROM devices WHERE id = $1`, [id]);
+      return result.rows[0] ? mapDevice(result.rows[0]) : void 0;
+    },
+    async getDeviceByTokenHash(tokenHash) {
+      const result = await pool.query(`${selectDevices}FROM devices WHERE token_hash = $1`, [tokenHash]);
+      return result.rows[0] ? mapDevice(result.rows[0]) : void 0;
+    },
+    async createDevice(record) {
+      await pool.query(
+        "INSERT INTO devices (id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)",
+        [
+          record.id,
+          record.name ?? null,
+          record.type ?? null,
+          record.role ?? null,
+          record.caps ? JSON.stringify(record.caps) : null,
+          record.status,
+          record.scopes ? JSON.stringify(record.scopes) : null,
+          record.authType,
+          record.tokenHash ?? null,
+          record.tokenHint ?? null,
+          record.publicKey ?? null,
+          record.publicKeyAlgorithm ?? null,
+          record.createdAt,
+          record.updatedAt,
+          record.lastSeenAt ?? null
+        ]
+      );
+      return record;
+    },
+    async updateDevice(id, update) {
+      const existing = await this.getDeviceById(id);
+      if (!existing) {
+        return void 0;
+      }
+      const updated = {
+        ...existing,
+        name: update.name ?? existing.name,
+        type: update.type ?? existing.type,
+        scopes: update.scopes ?? existing.scopes,
+        role: update.role ?? existing.role,
+        caps: update.caps ?? existing.caps,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await pool.query(
+        "UPDATE devices SET name = $1, type = $2, role = $3, caps = $4, scopes = $5, updated_at = $6 WHERE id = $7",
+        [
+          updated.name ?? null,
+          updated.type ?? null,
+          updated.role ?? null,
+          updated.caps ? JSON.stringify(updated.caps) : null,
+          updated.scopes ? JSON.stringify(updated.scopes) : null,
+          updated.updatedAt,
+          id
+        ]
+      );
+      return updated;
+    },
+    async revokeDevice(id) {
+      const existing = await this.getDeviceById(id);
+      if (!existing) {
+        return void 0;
+      }
+      const updated = {
+        ...existing,
+        status: "revoked",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await pool.query(
+        "UPDATE devices SET status = $1, updated_at = $2 WHERE id = $3",
+        [updated.status, updated.updatedAt, id]
+      );
+      return updated;
+    },
+    async touchDevice(id) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await pool.query(
+        "UPDATE devices SET last_seen_at = $1, updated_at = $2 WHERE id = $3",
+        [now, now, id]
+      );
+    }
+  };
+};
+
+// packages/storage/src/postgres/channels.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var createChannelAllowStore = (pool) => {
+  const selectAllows = "SELECT id, channel, chat_id, user_id, status, note, created_at, updated_at ";
+  return {
+    async listChannelAllows(channel) {
+      const result = channel ? await pool.query(
+        `${selectAllows}FROM channel_allows WHERE channel = $1 ORDER BY created_at DESC`,
+        [channel]
+      ) : await pool.query(`${selectAllows}FROM channel_allows ORDER BY created_at DESC`);
+      return result.rows.map(mapChannelAllow);
+    },
+    async getChannelAllow(channel, chatId, userId) {
+      const userKey = userId ?? "";
+      let result = await pool.query(
+        `${selectAllows}FROM channel_allows WHERE channel = $1 AND chat_id = $2 AND user_id = $3`,
+        [channel, chatId, userKey]
+      );
+      if (result.rows[0]) {
+        return mapChannelAllow(result.rows[0]);
+      }
+      if (userId) {
+        result = await pool.query(
+          `${selectAllows}FROM channel_allows WHERE channel = $1 AND chat_id = $2 AND user_id = $3`,
+          [channel, chatId, ""]
+        );
+        return result.rows[0] ? mapChannelAllow(result.rows[0]) : void 0;
+      }
+      return void 0;
+    },
+    async allowChannel(record) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const userKey = record.userId ?? "";
+      await pool.query(
+        "INSERT INTO channel_allows (id, channel, chat_id, user_id, status, note, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (channel, chat_id, user_id) DO UPDATE SET status = EXCLUDED.status, note = EXCLUDED.note, updated_at = EXCLUDED.updated_at",
+        [
+          randomUUID2(),
+          record.channel,
+          record.chatId,
+          userKey,
+          "allowed",
+          record.note ?? null,
+          now,
+          now
+        ]
+      );
+      const stored = await this.getChannelAllow(record.channel, record.chatId, record.userId);
+      return stored ?? {
+        id: randomUUID2(),
+        channel: record.channel,
+        chatId: record.chatId,
+        userId: record.userId,
+        note: record.note,
+        status: "allowed",
+        createdAt: now,
+        updatedAt: now
+      };
+    },
+    async revokeChannel(id) {
+      const result = await pool.query(
+        "UPDATE channel_allows SET status = $1, updated_at = $2 WHERE id = $3 RETURNING id, channel, chat_id, user_id, status, note, created_at, updated_at",
+        ["revoked", (/* @__PURE__ */ new Date()).toISOString(), id]
+      );
+      return result.rows[0] ? mapChannelAllow(result.rows[0]) : void 0;
+    }
+  };
+};
+
+// packages/storage/src/postgres/approvals.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var createApprovalStore = (pool) => {
+  const selectApproval = "SELECT id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result ";
+  return {
+    async createApprovalRequest(request) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = request.id ?? randomUUID3();
+      const record = {
+        id,
+        status: request.status ?? "pending",
+        kind: request.kind ?? "tool",
+        toolName: request.toolName,
+        toolInput: request.toolInput ?? {},
+        sessionId: request.sessionId,
+        channel: request.channel,
+        chatId: request.chatId,
+        userId: request.userId,
+        userText: request.userText,
+        risk: request.risk,
+        reason: request.reason,
+        createdAt: request.createdAt ?? now,
+        updatedAt: request.updatedAt ?? now,
+        expiresAt: request.expiresAt,
+        decidedAt: request.decidedAt,
+        decidedBy: request.decidedBy,
+        result: request.result
+      };
+      const result = await pool.query(
+        `INSERT INTO approval_requests (id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18) ON CONFLICT (id) DO UPDATE SET status = EXCLUDED.status, kind = EXCLUDED.kind, tool_name = EXCLUDED.tool_name, tool_input = EXCLUDED.tool_input, session_id = EXCLUDED.session_id, channel = EXCLUDED.channel, chat_id = EXCLUDED.chat_id, user_id = EXCLUDED.user_id, user_text = EXCLUDED.user_text, risk = EXCLUDED.risk, reason = EXCLUDED.reason, updated_at = EXCLUDED.updated_at, expires_at = EXCLUDED.expires_at, decided_at = EXCLUDED.decided_at, decided_by = EXCLUDED.decided_by, result = EXCLUDED.result RETURNING ${selectApproval.replace("SELECT ", "")}`,
+        [
+          record.id,
+          record.status,
+          record.kind,
+          record.toolName,
+          JSON.stringify(record.toolInput ?? {}),
+          record.sessionId,
+          record.channel,
+          record.chatId,
+          record.userId ?? null,
+          record.userText ?? null,
+          record.risk ?? null,
+          record.reason ?? null,
+          record.createdAt,
+          record.updatedAt,
+          record.expiresAt ?? null,
+          record.decidedAt ?? null,
+          record.decidedBy ? JSON.stringify(record.decidedBy) : null,
+          record.result ? JSON.stringify(record.result) : null
+        ]
+      );
+      return result.rows[0] ? mapApproval(result.rows[0]) : record;
+    },
+    async getApprovalRequest(id) {
+      const result = await pool.query(`${selectApproval}FROM approval_requests WHERE id = $1`, [id]);
+      return result.rows[0] ? mapApproval(result.rows[0]) : void 0;
+    },
+    async listApprovalRequests(options) {
+      const limit = options?.limit ?? 50;
+      const status = options?.status;
+      if (status) {
+        const result2 = await pool.query(
+          `${selectApproval}FROM approval_requests WHERE status = $1 ORDER BY created_at DESC LIMIT $2`,
+          [status, limit]
+        );
+        return result2.rows.map(mapApproval);
+      }
+      const result = await pool.query(
+        `${selectApproval}FROM approval_requests ORDER BY created_at DESC LIMIT $1`,
+        [limit]
+      );
+      return result.rows.map(mapApproval);
+    },
+    async updateApprovalRequest(id, update) {
+      const existing = await this.getApprovalRequest(id);
+      if (!existing) return void 0;
+      const merged = {
+        ...existing,
+        ...update,
+        id: existing.id,
+        createdAt: existing.createdAt,
+        updatedAt: update.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return this.createApprovalRequest({
+        ...merged,
+        id: merged.id,
+        status: merged.status,
+        createdAt: merged.createdAt,
+        updatedAt: merged.updatedAt
+      });
+    }
+  };
+};
+
+// packages/storage/src/postgres/audit.ts
+var createAuditStore = (pool) => {
+  return {
+    async appendAudit(event) {
+      await pool.query(
+        "INSERT INTO audit (id, time, type, payload) VALUES ($1, $2, $3, $4)",
+        [
+          event.id,
+          event.time,
+          event.type,
+          event.payload ? JSON.stringify(event.payload) : null
+        ]
+      );
+    }
+  };
+};
+
+// packages/storage/src/postgres/agent-runs.ts
+var selectRun = "SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, timeout_ms, channel, chat_id, user_id, provider_id, model, system, text, metadata, metrics, result_summary, error ";
+var mapRun = (row) => {
+  const parseJson2 = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: row.session_id ? String(row.session_id) : void 0,
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    parentAgentId: row.parent_agent_id ? String(row.parent_agent_id) : void 0,
+    parentRunId: row.parent_run_id ? String(row.parent_run_id) : void 0,
+    lane: String(row.lane),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    timeoutMs: row.timeout_ms === null || row.timeout_ms === void 0 ? void 0 : Number(row.timeout_ms),
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    metadata: parseJson2(row.metadata),
+    metrics: parseJson2(row.metrics),
+    resultSummary: row.result_summary ? String(row.result_summary) : void 0,
+    error: row.error ? String(row.error) : void 0
+  };
+};
+var mapEvent2 = (row) => ({
+  id: String(row.id),
+  runId: String(row.run_id),
+  time: String(row.time),
+  type: String(row.type),
+  payload: row.payload ? JSON.parse(String(row.payload)) : void 0
+});
+var createAgentRunStore = (pool) => {
+  return {
+    async upsertAgentRun(record) {
+      const result = await pool.query(
+        `INSERT INTO agent_runs (id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, timeout_ms, channel, chat_id, user_id, provider_id, model, system, text, metadata, metrics, result_summary, error) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22) ON CONFLICT (id) DO UPDATE SET session_id = EXCLUDED.session_id, agent_id = EXCLUDED.agent_id, parent_agent_id = EXCLUDED.parent_agent_id, parent_run_id = EXCLUDED.parent_run_id, lane = EXCLUDED.lane, status = EXCLUDED.status, created_at = EXCLUDED.created_at, started_at = EXCLUDED.started_at, ended_at = EXCLUDED.ended_at, timeout_ms = EXCLUDED.timeout_ms, channel = EXCLUDED.channel, chat_id = EXCLUDED.chat_id, user_id = EXCLUDED.user_id, provider_id = EXCLUDED.provider_id, model = EXCLUDED.model, system = EXCLUDED.system, text = EXCLUDED.text, metadata = EXCLUDED.metadata, metrics = EXCLUDED.metrics, result_summary = EXCLUDED.result_summary, error = EXCLUDED.error RETURNING ${selectRun.replace("SELECT ", "")}`,
+        [
+          record.id,
+          record.sessionId ?? null,
+          record.agentId ?? null,
+          record.parentAgentId ?? null,
+          record.parentRunId ?? null,
+          record.lane,
+          record.status,
+          record.createdAt,
+          record.startedAt ?? null,
+          record.endedAt ?? null,
+          record.timeoutMs ?? null,
+          record.channel ?? null,
+          record.chatId ?? null,
+          record.userId ?? null,
+          record.providerId ?? null,
+          record.model ?? null,
+          record.system ?? null,
+          record.text ?? null,
+          record.metadata ? JSON.stringify(record.metadata) : null,
+          record.metrics ? JSON.stringify(record.metrics) : null,
+          record.resultSummary ?? null,
+          record.error ?? null
+        ]
+      );
+      return result.rows[0] ? mapRun(result.rows[0]) : record;
+    },
+    async updateAgentRun(id, update) {
+      const existing = await this.getAgentRun(id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      return this.upsertAgentRun(merged);
+    },
+    async getAgentRun(id) {
+      const result = await pool.query(`${selectRun}FROM agent_runs WHERE id = $1`, [id]);
+      return result.rows[0] ? mapRun(result.rows[0]) : void 0;
+    },
+    async listAgentRuns(options) {
+      const limit = options?.limit ?? 50;
+      const filters = [];
+      const params = [];
+      if (options?.status) {
+        params.push(options.status);
+        filters.push(`status = $${params.length}`);
+      }
+      if (options?.lane) {
+        params.push(options.lane);
+        filters.push(`lane = $${params.length}`);
+      }
+      if (options?.sessionId) {
+        params.push(options.sessionId);
+        filters.push(`session_id = $${params.length}`);
+      }
+      if (options?.since) {
+        params.push(options.since);
+        filters.push(`created_at >= $${params.length}`);
+      }
+      params.push(limit);
+      const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+      const result = await pool.query(
+        `${selectRun}FROM agent_runs ${where} ORDER BY created_at DESC LIMIT $${params.length}`,
+        params
+      );
+      return result.rows.map(mapRun);
+    },
+    async appendAgentRunEvent(event) {
+      await pool.query(
+        "INSERT INTO agent_run_events (id, run_id, time, type, payload) VALUES ($1,$2,$3,$4,$5)",
+        [
+          event.id,
+          event.runId,
+          event.time,
+          event.type,
+          event.payload ? JSON.stringify(event.payload) : null
+        ]
+      );
+    },
+    async listAgentRunEvents(runId, options) {
+      const limit = options?.limit ?? 50;
+      const result = await pool.query(
+        "SELECT id, run_id, time, type, payload FROM agent_run_events WHERE run_id = $1 ORDER BY time DESC LIMIT $2",
+        [runId, limit]
+      );
+      return result.rows.map(mapEvent2).reverse();
+    }
+  };
+};
+
+// packages/storage/src/postgres/agent-queue.ts
+var selectQueue = "SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, lease_until, priority, channel, chat_id, user_id, provider_id, model, system, text, timeout_ms, tool_policy, metadata, error ";
+var mapRecord = (row) => {
+  const parseJson2 = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: row.session_id ? String(row.session_id) : void 0,
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    parentAgentId: row.parent_agent_id ? String(row.parent_agent_id) : void 0,
+    parentRunId: row.parent_run_id ? String(row.parent_run_id) : void 0,
+    lane: String(row.lane),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    leaseUntil: row.lease_until ? String(row.lease_until) : void 0,
+    priority: row.priority === null || row.priority === void 0 ? void 0 : Number(row.priority),
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    timeoutMs: row.timeout_ms === null || row.timeout_ms === void 0 ? void 0 : Number(row.timeout_ms),
+    toolPolicy: parseJson2(row.tool_policy),
+    metadata: parseJson2(row.metadata),
+    error: row.error ? String(row.error) : void 0
+  };
+};
+var createAgentQueueStore = (pool) => {
+  return {
+    async enqueueAgentQueue(record) {
+      const result = await pool.query(
+        `INSERT INTO agent_queue (id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, lease_until, priority, channel, chat_id, user_id, provider_id, model, system, text, timeout_ms, tool_policy, metadata, error) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22,$23) ON CONFLICT (id) DO UPDATE SET session_id = EXCLUDED.session_id, agent_id = EXCLUDED.agent_id, parent_agent_id = EXCLUDED.parent_agent_id, parent_run_id = EXCLUDED.parent_run_id, lane = EXCLUDED.lane, status = EXCLUDED.status, created_at = EXCLUDED.created_at, started_at = EXCLUDED.started_at, ended_at = EXCLUDED.ended_at, lease_until = EXCLUDED.lease_until, priority = EXCLUDED.priority, channel = EXCLUDED.channel, chat_id = EXCLUDED.chat_id, user_id = EXCLUDED.user_id, provider_id = EXCLUDED.provider_id, model = EXCLUDED.model, system = EXCLUDED.system, text = EXCLUDED.text, timeout_ms = EXCLUDED.timeout_ms, tool_policy = EXCLUDED.tool_policy, metadata = EXCLUDED.metadata, error = EXCLUDED.error RETURNING ${selectQueue.replace("SELECT ", "")}`,
+        [
+          record.id,
+          record.sessionId ?? null,
+          record.agentId ?? null,
+          record.parentAgentId ?? null,
+          record.parentRunId ?? null,
+          record.lane,
+          record.status,
+          record.createdAt,
+          record.startedAt ?? null,
+          record.endedAt ?? null,
+          record.leaseUntil ?? null,
+          record.priority ?? null,
+          record.channel ?? null,
+          record.chatId ?? null,
+          record.userId ?? null,
+          record.providerId ?? null,
+          record.model ?? null,
+          record.system ?? null,
+          record.text ?? null,
+          record.timeoutMs ?? null,
+          record.toolPolicy ? JSON.stringify(record.toolPolicy) : null,
+          record.metadata ? JSON.stringify(record.metadata) : null,
+          record.error ?? null
+        ]
+      );
+      return result.rows[0] ? mapRecord(result.rows[0]) : record;
+    },
+    async updateAgentQueue(id, update) {
+      const existing = await this.getAgentQueue(id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      return this.enqueueAgentQueue(merged);
+    },
+    async getAgentQueue(id) {
+      const result = await pool.query(`${selectQueue}FROM agent_queue WHERE id = $1`, [id]);
+      return result.rows[0] ? mapRecord(result.rows[0]) : void 0;
+    },
+    async listAgentQueue(options) {
+      const limit = options?.limit ?? 50;
+      const order = options?.order === "asc" ? "ASC" : "DESC";
+      const orderBy = options?.orderBy === "priority" ? "COALESCE(priority, 0) DESC, created_at" : "created_at";
+      const filters = [];
+      const params = [];
+      if (options?.status) {
+        params.push(options.status);
+        filters.push(`status = $${params.length}`);
+      }
+      if (options?.lane) {
+        params.push(options.lane);
+        filters.push(`lane = $${params.length}`);
+      }
+      if (options?.sessionId) {
+        params.push(options.sessionId);
+        filters.push(`session_id = $${params.length}`);
+      }
+      if (options?.agentId) {
+        params.push(options.agentId);
+        filters.push(`agent_id = $${params.length}`);
+      }
+      params.push(limit);
+      const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+      const result = await pool.query(
+        `${selectQueue}FROM agent_queue ${where} ORDER BY ${orderBy} ${order} LIMIT $${params.length}`,
+        params
+      );
+      return result.rows.map(mapRecord);
+    }
+  };
+};
+
+// packages/storage/src/postgres/session-inbox.ts
+var mapInbox = (row) => {
+  const parseJson2 = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    metadata: parseJson2(row.metadata),
+    error: row.error ? String(row.error) : void 0
+  };
+};
+var selectInbox = "SELECT id, session_id, status, created_at, started_at, ended_at, channel, chat_id, user_id, text, metadata, error ";
+var createSessionInboxStore = (pool) => {
+  return {
+    async enqueueSessionInbox(record) {
+      const result = await pool.query(
+        `INSERT INTO session_inbox (id, session_id, status, created_at, started_at, ended_at, channel, chat_id, user_id, text, metadata, error) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) ON CONFLICT (id) DO UPDATE SET session_id = EXCLUDED.session_id, status = EXCLUDED.status, created_at = EXCLUDED.created_at, started_at = EXCLUDED.started_at, ended_at = EXCLUDED.ended_at, channel = EXCLUDED.channel, chat_id = EXCLUDED.chat_id, user_id = EXCLUDED.user_id, text = EXCLUDED.text, metadata = EXCLUDED.metadata, error = EXCLUDED.error RETURNING ${selectInbox.replace("SELECT ", "")}`,
+        [
+          record.id,
+          record.sessionId,
+          record.status,
+          record.createdAt,
+          record.startedAt ?? null,
+          record.endedAt ?? null,
+          record.channel ?? null,
+          record.chatId ?? null,
+          record.userId ?? null,
+          record.text ?? null,
+          record.metadata ? JSON.stringify(record.metadata) : null,
+          record.error ?? null
+        ]
+      );
+      return result.rows[0] ? mapInbox(result.rows[0]) : record;
+    },
+    async updateSessionInbox(id, update) {
+      const existing = await this.getSessionInbox(id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      return this.enqueueSessionInbox(merged);
+    },
+    async getSessionInbox(id) {
+      const result = await pool.query(`${selectInbox}FROM session_inbox WHERE id = $1`, [id]);
+      return result.rows[0] ? mapInbox(result.rows[0]) : void 0;
+    },
+    async listSessionInbox(options) {
+      const limit = options?.limit ?? 50;
+      const order = options?.order === "asc" ? "ASC" : "DESC";
+      const filters = [];
+      const params = [];
+      if (options?.sessionId) {
+        params.push(options.sessionId);
+        filters.push(`session_id = $${params.length}`);
+      }
+      if (options?.status) {
+        params.push(options.status);
+        filters.push(`status = $${params.length}`);
+      }
+      params.push(limit);
+      const where = filters.length ? `WHERE ${filters.join(" AND ")}` : "";
+      const result = await pool.query(
+        `${selectInbox}FROM session_inbox ${where} ORDER BY created_at ${order} LIMIT $${params.length}`,
+        params
+      );
+      return result.rows.map(mapInbox);
+    }
+  };
+};
+
+// packages/storage/src/postgres/session-routes.ts
+var selectRoute = "SELECT session_id, agent_id, lane_id, queue_mode, announce_mode, updated_at ";
+var mapRoute = (row) => {
+  return {
+    sessionId: String(row.session_id),
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    laneId: row.lane_id ? String(row.lane_id) : void 0,
+    queueMode: row.queue_mode ? String(row.queue_mode) : void 0,
+    announceMode: row.announce_mode ? String(row.announce_mode) : void 0,
+    updatedAt: row.updated_at ? String(row.updated_at) : (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+var createSessionRouteStore = (pool) => {
+  return {
+    async getSessionRoute(sessionId) {
+      const result = await pool.query(`${selectRoute}FROM session_routes WHERE session_id = $1`, [
+        sessionId
+      ]);
+      return result.rows[0] ? mapRoute(result.rows[0]) : void 0;
+    },
+    async setSessionRoute(sessionId, route) {
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const result = await pool.query(
+        `INSERT INTO session_routes (session_id, agent_id, lane_id, queue_mode, announce_mode, updated_at) VALUES ($1,$2,$3,$4,$5,$6) ON CONFLICT (session_id) DO UPDATE SET agent_id = EXCLUDED.agent_id, lane_id = EXCLUDED.lane_id, queue_mode = EXCLUDED.queue_mode, announce_mode = EXCLUDED.announce_mode, updated_at = EXCLUDED.updated_at RETURNING ${selectRoute.replace("SELECT ", "")}`,
+        [
+          sessionId,
+          route.agentId ?? null,
+          route.laneId ?? null,
+          route.queueMode ?? null,
+          route.announceMode ?? null,
+          updatedAt
+        ]
+      );
+      return result.rows[0] ? mapRoute(result.rows[0]) : { sessionId, ...route, updatedAt };
+    },
+    async listSessionRoutes(options) {
+      const limit = options?.limit ?? 100;
+      const result = await pool.query(
+        `${selectRoute}FROM session_routes ORDER BY updated_at DESC LIMIT $1`,
+        [limit]
+      );
+      return result.rows.map(mapRoute);
+    }
+  };
+};
+
+// packages/storage/src/postgres.ts
+var PostgresStorage = class _PostgresStorage {
+  pool;
+  sessions;
+  prefs;
+  toolPolicy;
+  devices;
+  channels;
+  approvals;
+  audit;
+  agentRuns;
+  agentQueue;
+  sessionInbox;
+  sessionRoutes;
+  constructor(pool) {
+    this.pool = pool;
+    this.sessions = createSessionStore(pool);
+    this.prefs = createSessionPrefsStore(pool);
+    this.toolPolicy = createToolPolicyStore(pool);
+    this.devices = createDeviceStore(pool);
+    this.channels = createChannelAllowStore(pool);
+    this.approvals = createApprovalStore(pool);
+    this.audit = createAuditStore(pool);
+    this.agentRuns = createAgentRunStore(pool);
+    this.agentQueue = createAgentQueueStore(pool);
+    this.sessionInbox = createSessionInboxStore(pool);
+    this.sessionRoutes = createSessionRouteStore(pool);
+  }
+  static async create(options) {
+    const pool = createPool(options.url);
+    await runMigrations(pool);
+    return new _PostgresStorage(pool);
+  }
+  getSessionByKey(key) {
+    return this.sessions.getSessionByKey(key);
+  }
+  getSessionById(id) {
+    return this.sessions.getSessionById(id);
+  }
+  listSessions() {
+    return this.sessions.listSessions();
+  }
+  createSession(key, meta) {
+    return this.sessions.createSession(key, meta);
+  }
+  updateSession(id, update) {
+    return this.sessions.updateSession(id, update);
+  }
+  appendProviderSwitch(record) {
+    return this.sessions.appendProviderSwitch(record);
+  }
+  upsertSessionProviderUsage(entry) {
+    return this.sessions.upsertSessionProviderUsage(entry);
+  }
+  appendSessionEvent(event) {
+    return this.sessions.appendSessionEvent(event);
+  }
+  listSessionEvents(sessionId, options) {
+    return this.sessions.listSessionEvents(sessionId, options);
+  }
+  countSessionEvents(sessionId) {
+    return this.sessions.countSessionEvents(sessionId);
+  }
+  getSessionSummary(sessionId) {
+    return this.sessions.getSessionSummary(sessionId);
+  }
+  setSessionSummary(sessionId, summary, eventCount) {
+    return this.sessions.setSessionSummary(sessionId, summary, eventCount);
+  }
+  getToolPolicy() {
+    return this.toolPolicy.getToolPolicy();
+  }
+  setToolPolicy(policy) {
+    return this.toolPolicy.setToolPolicy(policy);
+  }
+  getSessionPrefs(sessionId) {
+    return this.prefs.getSessionPrefs(sessionId);
+  }
+  setSessionPrefs(sessionId, prefs) {
+    return this.prefs.setSessionPrefs(sessionId, prefs);
+  }
+  clearSessionPrefs(sessionId) {
+    return this.prefs.clearSessionPrefs(sessionId);
+  }
+  getSessionRoute(sessionId) {
+    return this.sessionRoutes.getSessionRoute(sessionId);
+  }
+  setSessionRoute(sessionId, route) {
+    return this.sessionRoutes.setSessionRoute(sessionId, route);
+  }
+  listSessionRoutes(options) {
+    return this.sessionRoutes.listSessionRoutes(options);
+  }
+  listDevices() {
+    return this.devices.listDevices();
+  }
+  getDeviceById(id) {
+    return this.devices.getDeviceById(id);
+  }
+  getDeviceByTokenHash(tokenHash) {
+    return this.devices.getDeviceByTokenHash(tokenHash);
+  }
+  createDevice(record) {
+    return this.devices.createDevice(record);
+  }
+  updateDevice(id, update) {
+    return this.devices.updateDevice(id, update);
+  }
+  revokeDevice(id) {
+    return this.devices.revokeDevice(id);
+  }
+  touchDevice(id) {
+    return this.devices.touchDevice(id);
+  }
+  listChannelAllows(channel) {
+    return this.channels.listChannelAllows(channel);
+  }
+  getChannelAllow(channel, chatId, userId) {
+    return this.channels.getChannelAllow(channel, chatId, userId);
+  }
+  allowChannel(record) {
+    return this.channels.allowChannel(record);
+  }
+  revokeChannel(id) {
+    return this.channels.revokeChannel(id);
+  }
+  createApprovalRequest(request) {
+    return this.approvals.createApprovalRequest(request);
+  }
+  getApprovalRequest(id) {
+    return this.approvals.getApprovalRequest(id);
+  }
+  listApprovalRequests(options) {
+    return this.approvals.listApprovalRequests(options);
+  }
+  updateApprovalRequest(id, update) {
+    return this.approvals.updateApprovalRequest(id, update);
+  }
+  appendAudit(event) {
+    return this.audit.appendAudit(event);
+  }
+  // -- Kaala Agent Runs ---------------------------------------------------
+  upsertAgentRun(record) {
+    return this.agentRuns.upsertAgentRun(record);
+  }
+  updateAgentRun(id, update) {
+    return this.agentRuns.updateAgentRun(id, update);
+  }
+  getAgentRun(id) {
+    return this.agentRuns.getAgentRun(id);
+  }
+  listAgentRuns(options) {
+    return this.agentRuns.listAgentRuns(options);
+  }
+  appendAgentRunEvent(event) {
+    return this.agentRuns.appendAgentRunEvent(event);
+  }
+  listAgentRunEvents(runId, options) {
+    return this.agentRuns.listAgentRunEvents(runId, options);
+  }
+  // -- Session Inbox ---------------------------------------------------
+  enqueueSessionInbox(record) {
+    return this.sessionInbox.enqueueSessionInbox(record);
+  }
+  updateSessionInbox(id, update) {
+    return this.sessionInbox.updateSessionInbox(id, update);
+  }
+  getSessionInbox(id) {
+    return this.sessionInbox.getSessionInbox(id);
+  }
+  listSessionInbox(options) {
+    return this.sessionInbox.listSessionInbox(options);
+  }
+  enqueueAgentQueue(record) {
+    return this.agentQueue.enqueueAgentQueue(record);
+  }
+  updateAgentQueue(id, update) {
+    return this.agentQueue.updateAgentQueue(id, update);
+  }
+  getAgentQueue(id) {
+    return this.agentQueue.getAgentQueue(id);
+  }
+  listAgentQueue(options) {
+    return this.agentQueue.listAgentQueue(options);
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+
+export {
+  PostgresStorage
+};
+//# sourceMappingURL=chunk-MINFB5LT.js.map