@hasna/assistants 1.1.51 → 1.1.53

package/dist/index.js

@@ -616,8 +616,6 @@ async function ensureConfigDir(sessionId, baseDir) {
   const dirs = [
     mkdir2(configDir, { recursive: true }),
     mkdir2(join(configDir, "logs"), { recursive: true }),
-    mkdir2(join(configDir, "assistants"), { recursive: true }),
-    mkdir2(join(configDir, "migration"), { recursive: true }),
     mkdir2(join(configDir, "temp"), { recursive: true }),
     mkdir2(join(configDir, "messages"), { recursive: true }),
     mkdir2(join(configDir, "backups"), { recursive: true })
@@ -1472,7 +1470,119 @@ var init_schema = __esm(() => {
     created_at TEXT NOT NULL
   )`,
     `CREATE INDEX IF NOT EXISTS idx_guardrail_evaluations_session ON guardrail_evaluations(session_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_guardrail_evaluations_rule ON guardrail_evaluations(rule_id)`
+    `CREATE INDEX IF NOT EXISTS idx_guardrail_evaluations_rule ON guardrail_evaluations(rule_id)`,
+    `CREATE TABLE IF NOT EXISTS assistants_config (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    model TEXT,
+    system_prompt TEXT,
+    settings TEXT NOT NULL DEFAULT '{}',
+    identity_id TEXT,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS assistants_active (
+    key TEXT PRIMARY KEY DEFAULT 'active',
+    assistant_id TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS assistant_sessions (
+    id TEXT PRIMARY KEY,
+    assistant_id TEXT NOT NULL,
+    cwd TEXT,
+    started_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active',
+    metadata TEXT
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_assistant_sessions_assistant ON assistant_sessions(assistant_id)`,
+    `CREATE TABLE IF NOT EXISTS people (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    email TEXT,
+    phone TEXT,
+    role TEXT,
+    notes TEXT,
+    avatar_url TEXT,
+    metadata TEXT,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS people_active (
+    key TEXT PRIMARY KEY DEFAULT 'active',
+    person_id TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS verification_sessions (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    assistant_id TEXT,
+    goal TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    result TEXT,
+    created_at TEXT NOT NULL,
+    completed_at TEXT,
+    data TEXT
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_verification_sessions_session ON verification_sessions(session_id)`,
+    `CREATE TABLE IF NOT EXISTS workspaces (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    description TEXT,
+    creator_id TEXT NOT NULL,
+    creator_name TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'active',
+    participants TEXT NOT NULL DEFAULT '[]',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS workspaces_active (
+    assistant_id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL
+  )`,
+    `CREATE TABLE IF NOT EXISTS budget_usage (
+    scope TEXT NOT NULL,
+    scope_id TEXT NOT NULL,
+    input_tokens INTEGER NOT NULL DEFAULT 0,
+    output_tokens INTEGER NOT NULL DEFAULT 0,
+    total_tokens INTEGER NOT NULL DEFAULT 0,
+    api_calls INTEGER NOT NULL DEFAULT 0,
+    tool_calls INTEGER NOT NULL DEFAULT 0,
+    estimated_cost_usd REAL NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (scope, scope_id)
+  )`,
+    `CREATE TABLE IF NOT EXISTS registered_assistants (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'general',
+    description TEXT,
+    model TEXT,
+    status TEXT NOT NULL DEFAULT 'active',
+    state TEXT NOT NULL DEFAULT 'idle',
+    capabilities TEXT,
+    tags TEXT,
+    parent_id TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_active_at TEXT,
+    metadata TEXT
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_registered_assistants_type ON registered_assistants(type)`,
+    `CREATE INDEX IF NOT EXISTS idx_registered_assistants_status ON registered_assistants(status)`,
+    `CREATE TABLE IF NOT EXISTS heartbeat_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    energy INTEGER,
+    context_tokens INTEGER,
+    action TEXT,
+    timestamp TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_heartbeat_history_session ON heartbeat_history(session_id, timestamp DESC)`,
+    `CREATE TABLE IF NOT EXISTS connector_cache (
+    key TEXT PRIMARY KEY,
+    data TEXT NOT NULL,
+    cached_at TEXT NOT NULL
+  )`
   ];
 });
 
@@ -20345,80 +20455,105 @@ var init_energy = __esm(() => {
 });
 
 // packages/core/src/heartbeat/history.ts
-import { dirname as dirname6, join as join10 } from "path";
-import { mkdirSync as mkdirSync5, existsSync as existsSync8, readdirSync as readdirSync4 } from "fs";
-import { appendFile as appendFile2, readFile as readFile2 } from "fs/promises";
-function applySessionPlaceholder(path2, sessionId) {
-  if (path2.includes("{sessionId}")) {
-    return path2.replace("{sessionId}", sessionId);
+function getDb() {
+  return getDatabase();
+}
+function rowToHeartbeat(row) {
+  if (row.action) {
+    try {
+      const parsed = JSON.parse(row.action);
+      if (parsed.sessionId)
+        return parsed;
+    } catch {}
   }
-  return path2;
+  return {
+    sessionId: row.session_id,
+    timestamp: row.timestamp,
+    state: row.status,
+    lastActivity: row.timestamp,
+    stats: {
+      messagesProcessed: 0,
+      toolCallsExecuted: 0,
+      errorsEncountered: 0,
+      uptimeSeconds: 0
+    }
+  };
 }
-function resolveHeartbeatPersistPath(sessionId, persistPath, baseDir) {
+function resolveHeartbeatPersistPath(sessionId, persistPath, _baseDir) {
   if (persistPath) {
-    return applySessionPlaceholder(persistPath, sessionId);
+    if (persistPath.includes("{sessionId}")) {
+      return persistPath.replace("{sessionId}", sessionId);
+    }
+    return persistPath;
   }
-  return join10(baseDir ?? getConfigDir(), "heartbeats", `${sessionId}.json`);
+  return `<db>:heartbeat_history:${sessionId}`;
 }
-function resolveHeartbeatHistoryPath(sessionId, historyPath, baseDir) {
+function resolveHeartbeatHistoryPath(sessionId, historyPath, _baseDir) {
   if (historyPath) {
-    return applySessionPlaceholder(historyPath, sessionId);
+    if (historyPath.includes("{sessionId}")) {
+      return historyPath.replace("{sessionId}", sessionId);
+    }
+    return historyPath;
   }
-  return join10(baseDir ?? getConfigDir(), "heartbeats", "runs", `${sessionId}.jsonl`);
+  return `<db>:heartbeat_history:${sessionId}`;
 }
-function listHeartbeatHistorySessions(baseDir) {
-  const dir = baseDir ?? join10(getConfigDir(), "heartbeats", "runs");
-  if (!existsSync8(dir))
+function listHeartbeatHistorySessions(_baseDir, db) {
+  try {
+    const conn = db || getDb();
+    const rows = conn.query("SELECT DISTINCT session_id FROM heartbeat_history").all();
+    return rows.map((r) => r.session_id);
+  } catch {
     return [];
-  return readdirSync4(dir).filter((file) => file.endsWith(".jsonl")).map((file) => file.replace(/\.jsonl$/, ""));
+  }
 }
-async function appendHeartbeatHistory(historyPath, heartbeat) {
+async function appendHeartbeatHistory(historyPath, heartbeat, db) {
   try {
-    mkdirSync5(dirname6(historyPath), { recursive: true });
-    await appendFile2(historyPath, `${JSON.stringify(heartbeat)}
-`, "utf-8");
+    const conn = db || getDb();
+    conn.prepare(`INSERT INTO heartbeat_history (session_id, status, energy, context_tokens, action, timestamp)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(heartbeat.sessionId, heartbeat.state, null, null, JSON.stringify(heartbeat), heartbeat.timestamp);
   } catch {}
 }
-async function readHeartbeatHistory(historyPath, options = {}) {
+function extractSessionId(historyPath) {
+  if (historyPath.startsWith("<db>:heartbeat_history:")) {
+    return historyPath.replace("<db>:heartbeat_history:", "");
+  }
+  const match = historyPath.match(/[/\\]([^/\\]+?)\.jsonl?$/);
+  if (match) {
+    return match[1];
+  }
+  return null;
+}
+async function readHeartbeatHistory(historyPath, options = {}, db) {
   try {
-    const content = await readFile2(historyPath, "utf-8");
-    const lines = content.split(`
-`).filter(Boolean);
-    const parsed = [];
-    for (const line of lines) {
-      try {
-        parsed.push(JSON.parse(line));
-      } catch {}
-    }
+    const conn = db || getDb();
+    const sessionId = extractSessionId(historyPath);
     const order = options.order ?? "desc";
-    const ordered = order === "desc" ? parsed.reverse() : parsed;
-    if (options.limit && options.limit > 0) {
-      return ordered.slice(0, options.limit);
+    const orderSql = order === "desc" ? "DESC" : "ASC";
+    const limitSql = options.limit && options.limit > 0 ? `LIMIT ${options.limit}` : "";
+    let rows;
+    if (sessionId) {
+      rows = conn.query(`SELECT * FROM heartbeat_history WHERE session_id = ? ORDER BY timestamp ${orderSql} ${limitSql}`).all(sessionId);
+    } else {
+      rows = conn.query(`SELECT * FROM heartbeat_history ORDER BY timestamp ${orderSql} ${limitSql}`).all();
     }
-    return ordered;
+    return rows.map(rowToHeartbeat);
   } catch {
     return [];
   }
 }
-async function readHeartbeatHistoryBySession(sessionId, options = {}) {
-  const historyPath = resolveHeartbeatHistoryPath(sessionId, options.historyPath, options.baseDir);
-  return readHeartbeatHistory(historyPath, { limit: options.limit, order: options.order });
+async function readHeartbeatHistoryBySession(sessionId, options = {}, db) {
+  const historyPath = resolveHeartbeatHistoryPath(sessionId, options.historyPath);
+  return readHeartbeatHistory(historyPath, { limit: options.limit, order: options.order }, db);
 }
-async function readLatestHeartbeat(persistPath, historyPath) {
-  if (historyPath) {
-    const history = await readHeartbeatHistory(historyPath, { limit: 1, order: "desc" });
-    if (history.length > 0)
-      return history[0];
-  }
-  try {
-    const content = await readFile2(persistPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
+async function readLatestHeartbeat(persistPath, historyPath, db) {
+  const path2 = historyPath || persistPath;
+  const history = await readHeartbeatHistory(path2, { limit: 1, order: "desc" }, db);
+  if (history.length > 0)
+    return history[0];
+  return null;
 }
 var init_history = __esm(async () => {
-  await init_config();
+  await init_database();
 });
 
 // packages/core/src/tools/heartbeat.ts
@@ -20530,7 +20665,7 @@ var init_heartbeat = __esm(async () => {
 });
 
 // packages/core/src/projects/store.ts
-function getDb() {
+function getDb2() {
   return getDatabase();
 }
 function rowToProject(row) {
@@ -20548,11 +20683,11 @@ function normalizeName(name) {
   return name.trim().toLowerCase();
 }
 async function listProjects(cwd) {
-  const rows = getDb().query("SELECT * FROM projects WHERE project_path = ? ORDER BY updated_at DESC").all(cwd);
+  const rows = getDb2().query("SELECT * FROM projects WHERE project_path = ? ORDER BY updated_at DESC").all(cwd);
   return rows.map(rowToProject);
 }
 async function readProject(cwd, id) {
-  const row = getDb().query("SELECT * FROM projects WHERE id = ?").get(id);
+  const row = getDb2().query("SELECT * FROM projects WHERE id = ?").get(id);
   if (!row)
     return null;
   return rowToProject(row);
@@ -20563,11 +20698,11 @@ async function findProjectByName(cwd, name) {
   return projects.find((project) => normalizeName(project.name) === normalized) || null;
 }
 async function saveProject(cwd, project) {
-  getDb().prepare(`INSERT OR REPLACE INTO projects (id, project_path, name, description, context, plans, created_at, updated_at)
+  getDb2().prepare(`INSERT OR REPLACE INTO projects (id, project_path, name, description, context, plans, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(project.id, cwd, project.name, project.description ?? null, JSON.stringify(project.context), JSON.stringify(project.plans), project.createdAt, project.updatedAt);
 }
 async function deleteProject(cwd, id) {
-  const result = getDb().prepare("DELETE FROM projects WHERE id = ?").run(id);
+  const result = getDb2().prepare("DELETE FROM projects WHERE id = ?").run(id);
   return result.changes > 0;
 }
 async function createProject(cwd, name, description) {
@@ -20669,9 +20804,9 @@ function isWithinPath(target, base) {
 var init_paths = () => {};
 
 // packages/core/src/projects/context.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { resolve as resolve2, join as join11 } from "path";
+import { resolve as resolve2, join as join10 } from "path";
 function singleLine(value) {
   return value.replace(/[\r\n]+/g, " ").trim();
 }
@@ -20689,7 +20824,7 @@ function normalizeEntryLabel(entry) {
 }
 async function renderFileEntry(entry, options) {
   const rawPath = entry.value.trim();
-  const expandedPath = rawPath === "~" ? homedir6() : rawPath.startsWith("~/") ? join11(homedir6(), rawPath.slice(2)) : rawPath;
+  const expandedPath = rawPath === "~" ? homedir6() : rawPath.startsWith("~/") ? join10(homedir6(), rawPath.slice(2)) : rawPath;
   const resolved = resolve2(options.cwd, expandedPath);
   const validation = await validatePath(resolved, { allowedPaths: [options.cwd] });
   if (!validation.valid) {
@@ -20697,7 +20832,7 @@ async function renderFileEntry(entry, options) {
   }
   let content = "";
   try {
-    const data = await readFile3(validation.resolved, "utf-8");
+    const data = await readFile2(validation.resolved, "utf-8");
     const limit2 = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
     if (data.length > limit2) {
       content = `${data.slice(0, limit2)}
@@ -21214,8 +21349,8 @@ var init_security = __esm(() => {
 });
 
 // packages/core/src/logger.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, appendFileSync, readdirSync as readdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, appendFileSync, readdirSync as readdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join11 } from "path";
 function isValidId(id) {
   return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN2.test(id);
 }
@@ -21226,14 +21361,14 @@ class Logger {
   sessionId;
   constructor(sessionId, basePath) {
     this.sessionId = sessionId;
-    this.logDir = join12(basePath || getConfigDir(), "logs");
+    this.logDir = join11(basePath || getConfigDir(), "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join12(this.logDir, `${date}.log`);
+    this.logFile = join11(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync9(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync8(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
   }
   write(level, message, data) {
@@ -21265,12 +21400,12 @@ class Logger {
     this.write("error", message, data);
   }
   static readEntries(options) {
-    const logDir = join12(options?.basePath || getConfigDir(), "logs");
-    if (!existsSync9(logDir))
+    const logDir = join11(options?.basePath || getConfigDir(), "logs");
+    if (!existsSync8(logDir))
       return [];
     const levelOrder = { debug: 0, info: 1, warn: 2, error: 3 };
     const minLevel = options?.level ? levelOrder[options.level] : 0;
-    const files = readdirSync5(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).sort((a, b) => b.localeCompare(a));
+    const files = readdirSync4(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).sort((a, b) => b.localeCompare(a));
     const entries = [];
     for (const file of files) {
       if (options?.since) {
@@ -21280,7 +21415,7 @@ class Logger {
           break;
       }
       try {
-        const content = readFileSync5(join12(logDir, file), "utf-8");
+        const content = readFileSync5(join11(logDir, file), "utf-8");
         const lines = content.trim().split(`
 `).filter(Boolean);
         for (const line of lines) {
@@ -21303,10 +21438,10 @@ class Logger {
     return entries.slice(offset, offset + limit2);
   }
   static listLogDates(basePath) {
-    const logDir = join12(basePath || getConfigDir(), "logs");
-    if (!existsSync9(logDir))
+    const logDir = join11(basePath || getConfigDir(), "logs");
+    if (!existsSync8(logDir))
       return [];
-    return readdirSync5(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).map((f) => f.replace(".log", "")).sort((a, b) => b.localeCompare(a));
+    return readdirSync4(logDir).filter((f) => /^\d{4}-\d{2}-\d{2}\.log$/.test(f)).map((f) => f.replace(".log", "")).sort((a, b) => b.localeCompare(a));
   }
 }
 
@@ -21321,13 +21456,13 @@ class SessionStorage {
     this.sessionId = sessionId;
     const root = basePath || getConfigDir();
     const safeAssistantId = isValidId(assistantId) ? assistantId : null;
-    this.sessionsDir = safeAssistantId ? join12(root, "assistants", safeAssistantId, "sessions") : join12(root, "sessions");
+    this.sessionsDir = safeAssistantId ? join11(root, "assistants", safeAssistantId, "sessions") : join11(root, "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join12(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join11(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync9(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync8(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
   }
   save(data) {
@@ -21340,7 +21475,7 @@ class SessionStorage {
   }
   load() {
     try {
-      if (!existsSync9(this.sessionFile))
+      if (!existsSync8(this.sessionFile))
         return null;
       return JSON.parse(readFileSync5(this.sessionFile, "utf-8"));
     } catch {
@@ -21350,8 +21485,8 @@ class SessionStorage {
   static getActiveAssistantId(basePath) {
     try {
       const root = basePath || getConfigDir();
-      const activePath = join12(root, "active.json");
-      if (!existsSync9(activePath))
+      const activePath = join11(root, "active.json");
+      if (!existsSync8(activePath))
         return null;
       const raw = readFileSync5(activePath, "utf-8");
       const data = JSON.parse(raw);
@@ -21372,23 +21507,23 @@ class SessionStorage {
     const safeAssistantId = isValidId(assistantId) ? assistantId : null;
     const resolvedId = safeAssistantId ?? SessionStorage.getActiveAssistantId(basePath);
     if (resolvedId && isValidId(resolvedId)) {
-      const assistantDir = join12(root, "assistants", resolvedId, "sessions");
-      if (existsSync9(assistantDir)) {
+      const assistantDir = join11(root, "assistants", resolvedId, "sessions");
+      if (existsSync8(assistantDir)) {
         return { dir: assistantDir, assistantId: resolvedId };
       }
     }
-    return { dir: join12(root, "sessions"), assistantId: null };
+    return { dir: join11(root, "sessions"), assistantId: null };
   }
   static readSessionsFromDir(sessionsDir, assistantId) {
-    if (!existsSync9(sessionsDir))
+    if (!existsSync8(sessionsDir))
       return [];
     const sessions = [];
-    const files = readdirSync5(sessionsDir);
+    const files = readdirSync4(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const filePath = join12(sessionsDir, file);
+        const filePath = join11(sessionsDir, file);
         const content = JSON.parse(readFileSync5(filePath, "utf-8"));
         sessions.push({
           id: file.replace(".json", ""),
@@ -21410,17 +21545,17 @@ class SessionStorage {
   static listAllSessions(basePath) {
     const root = basePath || getConfigDir();
     const sessions = [];
-    const rootSessionsDir = join12(root, "sessions");
+    const rootSessionsDir = join11(root, "sessions");
     sessions.push(...SessionStorage.readSessionsFromDir(rootSessionsDir, null));
-    const assistantsDir = join12(root, "assistants");
-    if (existsSync9(assistantsDir)) {
-      const entries = readdirSync5(assistantsDir, { withFileTypes: true });
+    const assistantsDir = join11(root, "assistants");
+    if (existsSync8(assistantsDir)) {
+      const entries = readdirSync4(assistantsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
         if (!isValidId(entry.name))
           continue;
-        const assistantSessionsDir = join12(assistantsDir, entry.name, "sessions");
+        const assistantSessionsDir = join11(assistantsDir, entry.name, "sessions");
         sessions.push(...SessionStorage.readSessionsFromDir(assistantSessionsDir, entry.name));
       }
     }
@@ -21435,9 +21570,9 @@ class SessionStorage {
       return null;
     }
     const sessionsDir = SessionStorage.resolveSessionsDir(assistantId, basePath);
-    const sessionFile = join12(sessionsDir, `${sessionId}.json`);
+    const sessionFile = join11(sessionsDir, `${sessionId}.json`);
     try {
-      if (!existsSync9(sessionFile))
+      if (!existsSync8(sessionFile))
         return null;
       return JSON.parse(readFileSync5(sessionFile, "utf-8"));
     } catch {
@@ -21449,19 +21584,14 @@ function initAssistantsDir(basePath) {
   const baseDir = basePath || getConfigDir();
   const dirs = [
     baseDir,
-    join12(baseDir, "logs"),
-    join12(baseDir, "assistants"),
-    join12(baseDir, "shared", "skills"),
-    join12(baseDir, "commands"),
-    join12(baseDir, "temp"),
-    join12(baseDir, "heartbeats"),
-    join12(baseDir, "state"),
-    join12(baseDir, "energy"),
-    join12(baseDir, "migration")
+    join11(baseDir, "logs"),
+    join11(baseDir, "temp"),
+    join11(baseDir, "messages"),
+    join11(baseDir, "backups")
   ];
   for (const dir of dirs) {
-    if (!existsSync9(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync8(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
   }
 }
@@ -21472,20 +21602,20 @@ var init_logger2 = __esm(async () => {
 });
 
 // packages/core/src/hooks/logger.ts
-import { join as join13 } from "path";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, appendFileSync as appendFileSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join12 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, appendFileSync as appendFileSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 function getLogPath() {
-  return join13(getConfigDir(), "logs", "hooks.jsonl");
+  return join12(getConfigDir(), "logs", "hooks.jsonl");
 }
 function ensureLogsDir() {
-  const logsDir = join13(getConfigDir(), "logs");
-  if (!existsSync10(logsDir)) {
-    mkdirSync7(logsDir, { recursive: true });
+  const logsDir = join12(getConfigDir(), "logs");
+  if (!existsSync9(logsDir)) {
+    mkdirSync6(logsDir, { recursive: true });
   }
 }
 function rotateIfNeeded() {
   const logPath = getLogPath();
-  if (!existsSync10(logPath))
+  if (!existsSync9(logPath))
     return;
   try {
     const content = readFileSync6(logPath, "utf-8");
@@ -21543,7 +21673,7 @@ class HookLogger {
   }
   static getHistory(limit2 = 50, hookId) {
     const logPath = getLogPath();
-    if (!existsSync10(logPath))
+    if (!existsSync9(logPath))
       return [];
     try {
       const content = readFileSync6(logPath, "utf-8");
@@ -21565,7 +21695,7 @@ class HookLogger {
   }
   static clearHistory() {
     const logPath = getLogPath();
-    if (existsSync10(logPath)) {
+    if (existsSync9(logPath)) {
       writeFileSync4(logPath, "", "utf-8");
     }
   }
@@ -21947,22 +22077,48 @@ var init_logs = __esm(async () => {
 });
 
 // packages/core/src/sessions/verification.ts
-import { join as join14 } from "path";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5, readdirSync as readdirSync6, unlinkSync as unlinkSync2 } from "fs";
+function getDb3() {
+  return getDatabase();
+}
+function rowToSession(row) {
+  try {
+    if (row.data) {
+      return JSON.parse(row.data);
+    }
+    const goals = row.goal ? JSON.parse(row.goal) : [];
+    const result = row.result || "fail";
+    return {
+      id: row.id,
+      parentSessionId: row.session_id,
+      type: "scope-verification",
+      result,
+      goals,
+      reason: "",
+      suggestions: [],
+      verificationResult: {
+        goalsMet: result === "pass",
+        goalsAnalysis: [],
+        reason: "",
+        suggestions: []
+      },
+      createdAt: row.created_at
+    };
+  } catch {
+    return null;
+  }
+}
 
 class VerificationSessionStore {
-  basePath;
   maxSessions;
   lastTimestamp;
-  constructor(basePath, maxSessions = 100) {
-    this.basePath = join14(basePath, "verifications");
+  db;
+  constructor(dbOrBasePath, maxSessions = 100) {
     this.maxSessions = maxSessions;
     this.lastTimestamp = 0;
-    this.ensureDirectory();
-  }
-  ensureDirectory() {
-    if (!existsSync11(this.basePath)) {
-      mkdirSync8(this.basePath, { recursive: true });
+    if (dbOrBasePath && typeof dbOrBasePath === "object" && "exec" in dbOrBasePath) {
+      this.db = dbOrBasePath;
+    } else {
+      this.db = getDb3();
     }
   }
   create(parentSessionId, goals, verificationResult) {
@@ -21987,50 +22143,34 @@ class VerificationSessionStore {
     return session;
   }
   save(session) {
-    const filePath = join14(this.basePath, `${session.id}.json`);
-    writeFileSync5(filePath, JSON.stringify(session, null, 2));
+    this.db.prepare(`INSERT OR REPLACE INTO verification_sessions (id, session_id, assistant_id, goal, status, result, created_at, completed_at, data)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(session.id, session.parentSessionId, null, JSON.stringify(session.goals), session.result === "pass" ? "passed" : session.result === "fail" ? "failed" : session.result, session.result, session.createdAt, null, JSON.stringify(session));
   }
   get(id) {
-    const filePath = join14(this.basePath, `${id}.json`);
-    if (!existsSync11(filePath)) {
-      return null;
-    }
-    try {
-      const content = readFileSync7(filePath, "utf-8");
-      return JSON.parse(content);
-    } catch {
+    const row = this.db.query("SELECT * FROM verification_sessions WHERE id = ?").get(id);
+    if (!row)
       return null;
-    }
+    return rowToSession(row);
   }
   getByParentSession(parentSessionId) {
+    const rows = this.db.query("SELECT * FROM verification_sessions WHERE session_id = ? ORDER BY created_at DESC").all(parentSessionId);
     const sessions = [];
-    const files = this.listFiles();
-    for (const file of files) {
-      try {
-        const content = readFileSync7(join14(this.basePath, file), "utf-8");
-        const session = JSON.parse(content);
-        if (session.parentSessionId === parentSessionId) {
-          sessions.push(session);
-        }
-      } catch {
-        continue;
-      }
+    for (const row of rows) {
+      const session = rowToSession(row);
+      if (session)
+        sessions.push(session);
     }
-    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return sessions;
   }
   listRecent(limit2 = 10) {
+    const rows = this.db.query("SELECT * FROM verification_sessions ORDER BY created_at DESC LIMIT ?").all(limit2);
     const sessions = [];
-    const files = this.listFiles();
-    for (const file of files) {
-      try {
-        const content = readFileSync7(join14(this.basePath, file), "utf-8");
-        const session = JSON.parse(content);
+    for (const row of rows) {
+      const session = rowToSession(row);
+      if (session)
         sessions.push(session);
-      } catch {
-        continue;
-      }
     }
-    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit2);
+    return sessions;
   }
   updateResult(id, result) {
     const session = this.get(id);
@@ -22039,53 +22179,22 @@ class VerificationSessionStore {
     session.result = result;
     this.save(session);
   }
-  listFiles() {
-    if (!existsSync11(this.basePath)) {
-      return [];
-    }
-    return readdirSync6(this.basePath).filter((f) => f.endsWith(".json"));
-  }
   pruneOldSessions() {
-    const files = this.listFiles();
-    if (files.length <= this.maxSessions) {
+    const countRow = this.db.query("SELECT COUNT(*) as cnt FROM verification_sessions").get();
+    const count = countRow?.cnt || 0;
+    if (count <= this.maxSessions)
       return;
-    }
-    const sessions = [];
-    for (const file of files) {
-      try {
-        const content = readFileSync7(join14(this.basePath, file), "utf-8");
-        const session = JSON.parse(content);
-        sessions.push({
-          file,
-          timestamp: new Date(session.createdAt).getTime()
-        });
-      } catch {
-        continue;
-      }
-    }
-    sessions.sort((a, b) => a.timestamp - b.timestamp);
-    const toRemove = sessions.slice(0, sessions.length - this.maxSessions);
-    for (const item of toRemove) {
-      try {
-        unlinkSync2(join14(this.basePath, item.file));
-      } catch {
-        continue;
-      }
-    }
+    this.db.prepare(`DELETE FROM verification_sessions WHERE id IN (
+        SELECT id FROM verification_sessions ORDER BY created_at ASC LIMIT ?
+      )`).run(count - this.maxSessions);
   }
   clear() {
-    const files = this.listFiles();
-    for (const file of files) {
-      try {
-        unlinkSync2(join14(this.basePath, file));
-      } catch {
-        continue;
-      }
-    }
+    this.db.prepare("DELETE FROM verification_sessions").run();
   }
 }
-var init_verification = __esm(() => {
+var init_verification = __esm(async () => {
   init_src2();
+  await init_database();
 });
 
 // packages/core/src/hooks/loader.ts
@@ -22226,7 +22335,7 @@ var init_background = __esm(() => {
 });
 
 // packages/core/src/hooks/executor.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function killSpawnedProcess(proc) {
   proc.kill();
 }
@@ -22357,7 +22466,7 @@ class HookExecutor {
     }
     try {
       const runtime = getRuntime();
-      const cwd = input.cwd && existsSync12(input.cwd) ? input.cwd : process.cwd();
+      const cwd = input.cwd && existsSync10(input.cwd) ? input.cwd : process.cwd();
       const isWindows = process.platform === "win32";
       const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
       const shellArgs = isWindows ? ["/c", hook.command] : ["-lc", hook.command];
@@ -22410,7 +22519,7 @@ class HookExecutor {
       return null;
     try {
       const runtime = getRuntime();
-      const cwd = input.cwd && existsSync12(input.cwd) ? input.cwd : process.cwd();
+      const cwd = input.cwd && existsSync10(input.cwd) ? input.cwd : process.cwd();
       const isWindows = process.platform === "win32";
       const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
       const shellArgs = isWindows ? ["/c", hook.command] : ["-lc", hook.command];
@@ -22991,13 +23100,15 @@ Respond with ONLY valid JSON in this exact format:
 }`;
 var init_scope_verification = __esm(async () => {
   init_src2();
-  init_verification();
-  await init_config();
+  await __promiseAll([
+    init_verification(),
+    init_config()
+  ]);
 });
 
 // packages/core/src/hooks/store.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "fs";
-import { join as join15, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync11, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 import { createHash as createHash2 } from "crypto";
 function generateHookId2(event, hook) {
   const content = hook.command || hook.prompt || "";
@@ -23026,20 +23137,20 @@ class HookStore {
   getFilePath(location) {
     switch (location) {
       case "user":
-        return join15(this.baseDir || getConfigDir(), "hooks.json");
+        return join13(this.baseDir || getConfigDir(), "hooks.json");
       case "project":
-        return join15(this.cwd, ".assistants", "hooks.json");
+        return join13(this.cwd, ".assistants", "hooks.json");
       case "local":
-        return join15(this.cwd, ".assistants", "hooks.local.json");
+        return join13(this.cwd, ".assistants", "hooks.local.json");
     }
   }
   loadFrom(location) {
     const filePath = this.getFilePath(location);
-    if (!existsSync13(filePath)) {
+    if (!existsSync11(filePath)) {
       return {};
     }
     try {
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync7(filePath, "utf-8");
       const data = JSON.parse(content);
       const config = data.hooks || data;
       ensureHookIds(config);
@@ -23050,12 +23161,12 @@ class HookStore {
   }
   save(location, config) {
     const filePath = this.getFilePath(location);
-    const dir = dirname7(filePath);
-    if (!existsSync13(dir)) {
-      mkdirSync9(dir, { recursive: true });
+    const dir = dirname6(filePath);
+    if (!existsSync11(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
     ensureHookIds(config);
-    writeFileSync6(filePath, JSON.stringify({ hooks: config }, null, 2), "utf-8");
+    writeFileSync5(filePath, JSON.stringify({ hooks: config }, null, 2), "utf-8");
   }
   loadAll() {
     const userHooks = this.loadFrom("user");
@@ -23194,7 +23305,7 @@ var init_store2 = __esm(async () => {
 });
 
 // packages/core/src/hooks/tester.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 
 class HookTester {
   cwd;
@@ -23258,7 +23369,7 @@ class HookTester {
   }
   async executeCommand(command, input, timeout) {
     const runtime = getRuntime();
-    const cwd = input.cwd && existsSync14(input.cwd) ? input.cwd : process.cwd();
+    const cwd = input.cwd && existsSync12(input.cwd) ? input.cwd : process.cwd();
     const isWindows = process.platform === "win32";
     const shellBinary = isWindows ? "cmd" : runtime.which("bash") || "sh";
     const shellArgs = isWindows ? ["/c", command] : ["-lc", command];
@@ -23759,8 +23870,8 @@ function registerVerificationTools(registry, context) {
 }
 var verificationListTool, verificationGetTool, verificationStatusTool, verificationEnableTool, verificationDisableTool, verificationTools;
 var init_verification2 = __esm(async () => {
-  init_verification();
   await __promiseAll([
+    init_verification(),
     init_hooks(),
     init_config()
   ]);
@@ -24679,12 +24790,12 @@ var init_path_validator = __esm(() => {
 });
 
 // packages/core/src/tools/filesystem.ts
-import { join as join16, resolve as resolve4, dirname as dirname8, sep } from "path";
+import { join as join14, resolve as resolve4, dirname as dirname7, sep } from "path";
 import { homedir as homedir8 } from "os";
 import { mkdir as mkdir4 } from "fs/promises";
 function getScriptsFolder(cwd, sessionId) {
   const resolvedSessionId = sessionId || currentSessionId;
-  return join16(getProjectDataDir(cwd), "scripts", resolvedSessionId);
+  return join14(getProjectDataDir(cwd), "scripts", resolvedSessionId);
 }
 function isInScriptsFolder(path2, cwd, sessionId) {
   const scriptsFolder = resolve4(getScriptsFolder(cwd, sessionId));
@@ -24947,7 +25058,7 @@ var init_filesystem = __esm(async () => {
         });
       }
       const sanitizedFilename = filename.replace(/\.\.[/\\]/g, "").replace(/\.\./g, "").replace(/^[/\\]+/, "");
-      const path2 = join16(scriptsFolder, sanitizedFilename);
+      const path2 = join14(scriptsFolder, sanitizedFilename);
       if (!isInScriptsFolder(path2, baseCwd, input.sessionId)) {
         throw new ToolExecutionError(`Cannot write outside scripts folder. Files are saved to ${scriptsFolder}`, {
           toolName: "write",
@@ -24990,7 +25101,7 @@ var init_filesystem = __esm(async () => {
             retryable: false
           });
         }
-        const dir = dirname8(validated.resolved);
+        const dir = dirname7(validated.resolved);
         await mkdir4(dir, { recursive: true });
         const runtime = getRuntime();
         await runtime.write(validated.resolved, content);
@@ -25198,7 +25309,7 @@ var init_filesystem = __esm(async () => {
             if (file.includes(".Trash") || file.includes(".Spotlight-V100") || file.includes(".fseventsd")) {
               continue;
             }
-            const filePath = join16(validated.resolved, file);
+            const filePath = join14(validated.resolved, file);
             try {
               const content = await runtime.file(filePath).text();
               const lines = content.split(`
@@ -26128,8 +26239,8 @@ ${responseBody || "(empty response)"}`;
 });
 
 // packages/core/src/tools/feedback.ts
-import { join as join17 } from "path";
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync7 } from "fs";
+import { join as join15 } from "path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync6 } from "fs";
 function normalizeTags(value) {
   if (Array.isArray(value)) {
     const tags = value.map((t) => String(t).trim()).filter(Boolean);
@@ -26143,13 +26254,13 @@ function normalizeTags(value) {
 }
 function resolveFeedbackDir(cwd) {
   const baseCwd = cwd && cwd.trim().length > 0 ? cwd : process.cwd();
-  return join17(getProjectDataDir(baseCwd), "feedback");
+  return join15(getProjectDataDir(baseCwd), "feedback");
 }
 function saveFeedbackEntry(entry, cwd) {
   const feedbackDir = resolveFeedbackDir(cwd);
-  mkdirSync10(feedbackDir, { recursive: true });
-  const path2 = join17(feedbackDir, `${entry.id}.json`);
-  writeFileSync7(path2, JSON.stringify(entry, null, 2));
+  mkdirSync8(feedbackDir, { recursive: true });
+  const path2 = join15(feedbackDir, `${entry.id}.json`);
+  writeFileSync6(path2, JSON.stringify(entry, null, 2));
   return { path: path2 };
 }
 function buildEntry(input, overrides) {
@@ -26248,7 +26359,7 @@ Path: ${path2}`;
 });
 
 // packages/core/src/scheduler/store.ts
-function getDb2() {
+function getDb4() {
   return getDatabase();
 }
 function rowToSchedule(row) {
@@ -26269,7 +26380,7 @@ function rowToSchedule(row) {
   };
 }
 async function listSchedules(cwd, options) {
-  const rows = getDb2().query("SELECT * FROM schedules WHERE project_path = ?").all(cwd);
+  const rows = getDb4().query("SELECT * FROM schedules WHERE project_path = ?").all(cwd);
   const schedules = rows.map(rowToSchedule);
   if (options?.sessionId && !options?.global) {
     return schedules.filter((s) => s.sessionId === options.sessionId || !s.sessionId);
@@ -26279,17 +26390,17 @@ async function listSchedules(cwd, options) {
 async function saveSchedule(cwd, schedule) {
   const scheduleJson = JSON.stringify(schedule.schedule);
   const data = JSON.stringify(schedule);
-  getDb2().prepare(`INSERT OR REPLACE INTO schedules (id, project_path, command, schedule, status, session_id, next_run_at, last_run_at, run_count, max_runs, created_at, updated_at, data)
+  getDb4().prepare(`INSERT OR REPLACE INTO schedules (id, project_path, command, schedule, status, session_id, next_run_at, last_run_at, run_count, max_runs, created_at, updated_at, data)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(schedule.id, cwd, schedule.command, scheduleJson, schedule.status, schedule.sessionId ?? null, schedule.nextRunAt ?? null, schedule.lastRunAt ?? null, 0, null, String(schedule.createdAt), String(schedule.updatedAt), data);
 }
 async function getSchedule(cwd, id) {
-  const row = getDb2().query("SELECT * FROM schedules WHERE id = ?").get(id);
+  const row = getDb4().query("SELECT * FROM schedules WHERE id = ?").get(id);
   if (!row)
     return null;
   return rowToSchedule(row);
 }
 async function deleteSchedule(cwd, id) {
-  const result = getDb2().prepare("DELETE FROM schedules WHERE id = ?").run(id);
+  const result = getDb4().prepare("DELETE FROM schedules WHERE id = ?").run(id);
   return result.changes > 0;
 }
 function computeNextRun2(schedule, fromTime) {
@@ -26340,11 +26451,11 @@ function computeIntervalNextRun(schedule, fromTime) {
   return fromTime + intervalMs;
 }
 async function getDueSchedules(cwd, nowTime) {
-  const rows = getDb2().query("SELECT * FROM schedules WHERE project_path = ? AND status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?").all(cwd, nowTime);
+  const rows = getDb4().query("SELECT * FROM schedules WHERE project_path = ? AND status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?").all(cwd, nowTime);
   return rows.map(rowToSchedule).filter((s) => Number.isFinite(s.nextRunAt));
 }
 async function updateSchedule(cwd, id, updater, _options) {
-  const d = getDb2();
+  const d = getDb4();
   return d.transaction(() => {
     const row = d.query("SELECT * FROM schedules WHERE id = ?").get(id);
     if (!row)
@@ -26704,9 +26815,9 @@ var init_scheduler = __esm(async () => {
 });
 
 // packages/core/src/tools/image.ts
-import { existsSync as existsSync15, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync13, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir } from "os";
-import { join as join18, basename as basename3 } from "path";
+import { join as join16, basename as basename3 } from "path";
 
 class ImageTools {
   static registerAll(registry) {
@@ -26801,8 +26912,8 @@ var init_image = __esm(() => {
             offset += chunk.length;
           }
           const ext = contentType.split("/")[1]?.split(";")[0] || "png";
-          const tempFile = join18(tmpdir(), `assistants-image-${generateId()}.${ext}`);
-          writeFileSync8(tempFile, buffer);
+          const tempFile = join16(tmpdir(), `assistants-image-${generateId()}.${ext}`);
+          writeFileSync7(tempFile, buffer);
           localPath = tempFile;
         } catch (error2) {
           if (error2 instanceof Error && error2.name === "AbortError") {
@@ -26811,7 +26922,7 @@ var init_image = __esm(() => {
           return `Error: Failed to fetch image: ${error2 instanceof Error ? error2.message : String(error2)}`;
         }
       }
-      if (!existsSync15(localPath)) {
+      if (!existsSync13(localPath)) {
         return `Error: Image file not found: ${localPath}`;
       }
       return JSON.stringify({
@@ -26826,18 +26937,18 @@ var init_image = __esm(() => {
 });
 
 // packages/core/src/voice/utils.ts
-import { existsSync as existsSync16, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join19 } from "path";
+import { join as join17 } from "path";
 import { spawnSync } from "child_process";
 function loadApiKeyFromSecrets2(key) {
   const envHome = process.env.HOME || process.env.USERPROFILE;
   const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir9();
-  const secretsPath = join19(homeDir, ".secrets");
-  if (!existsSync16(secretsPath))
+  const secretsPath = join17(homeDir, ".secrets");
+  if (!existsSync14(secretsPath))
     return;
   try {
-    const content = readFileSync9(secretsPath, "utf-8");
+    const content = readFileSync8(secretsPath, "utf-8");
     const match = content.match(new RegExp(`export\\s+${key}\\s*=\\s*['"]?([^'"\\n]+)['"]?`));
     return match?.[1];
   } catch {
@@ -27289,7 +27400,7 @@ ${result.text}`;
 });
 
 // packages/core/src/skills/create.ts
-import { join as join20, dirname as dirname9 } from "path";
+import { join as join18, dirname as dirname8 } from "path";
 import { homedir as homedir11 } from "os";
 import { mkdir as mkdir5, stat, writeFile as writeFile2, rm } from "fs/promises";
 function slugify(input) {
@@ -27347,9 +27458,9 @@ function buildDefaultContent() {
 }
 function resolveSkillRoot(scope, cwd) {
   if (scope === "global") {
-    return join20(homedir11(), ".skill");
+    return join18(homedir11(), ".skill");
   }
-  return join20(cwd, ".skill");
+  return join18(cwd, ".skill");
 }
 async function pathExists(path2) {
   try {
@@ -27360,15 +27471,15 @@ async function pathExists(path2) {
   }
 }
 async function deleteSkill(filePath) {
-  const skillDir = dirname9(filePath);
+  const skillDir = dirname8(filePath);
   await rm(skillDir, { recursive: true });
 }
 async function createSkill(options) {
   const scope = options.scope ?? "project";
   const { skillName, dirName } = normalizeName2(options.name);
   const root = resolveSkillRoot(scope, options.cwd);
-  const directory = join20(root, dirName);
-  const filePath = join20(directory, "SKILL.md");
+  const directory = join18(root, dirName);
+  const filePath = join18(directory, "SKILL.md");
   if (!options.overwrite && await pathExists(filePath)) {
     throw new Error(`Skill already exists at ${filePath}`);
   }
@@ -27390,7 +27501,7 @@ ${content}
 var init_create = () => {};
 
 // packages/core/src/skills/executor.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname9 } from "path";
 
 class SkillExecutor {
   constructor() {}
@@ -27411,7 +27522,7 @@ ARGUMENTS: ${args.join(" ")}`;
     if (matches.length === 0) {
       return content;
     }
-    const skillDir = dirname10(skillFilePath);
+    const skillDir = dirname9(skillFilePath);
     let result = content;
     const runtime = getRuntime();
     for (const match of matches) {
@@ -27448,25 +27559,25 @@ var init_executor2 = __esm(async () => {
 });
 
 // packages/core/src/skills/installer.ts
-import { join as join21 } from "path";
+import { join as join19 } from "path";
 import { homedir as homedir12 } from "os";
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile3, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile3, writeFile as writeFile3, stat as stat2 } from "fs/promises";
 function resolveSkillRoot2(scope, cwd) {
   if (scope === "global") {
-    return join21(homedir12(), ".skill");
+    return join19(homedir12(), ".skill");
   }
-  return join21(cwd || process.cwd(), ".skill");
+  return join19(cwd || process.cwd(), ".skill");
 }
 async function ensurePackageJson(dir) {
   await mkdir6(dir, { recursive: true });
-  const pkgPath = join21(dir, "package.json");
+  const pkgPath = join19(dir, "package.json");
   try {
     await stat2(pkgPath);
   } catch {
     await writeFile3(pkgPath, JSON.stringify({ name: "assistants-skills", private: true, dependencies: {} }, null, 2) + `
 `);
   }
-  const gitignorePath = join21(dir, ".gitignore");
+  const gitignorePath = join19(dir, ".gitignore");
   try {
     await stat2(gitignorePath);
   } catch {
@@ -27489,10 +27600,10 @@ async function install(options) {
     const stderr = result.stderr.toString().trim();
     throw new Error(`Failed to install ${packageName}: ${stderr || "unknown error"}`);
   }
-  const skillDir = join21(root, "node_modules", "@hasnaxyz", `skill-${rawName}`);
+  const skillDir = join19(root, "node_modules", "@hasnaxyz", `skill-${rawName}`);
   let version = "unknown";
   try {
-    const pkgJson = JSON.parse(await readFile4(join21(skillDir, "package.json"), "utf-8"));
+    const pkgJson = JSON.parse(await readFile3(join19(skillDir, "package.json"), "utf-8"));
     version = pkgJson.version || "unknown";
   } catch {}
   return { name: rawName, packageName, version, skillDir };
@@ -27515,9 +27626,9 @@ async function uninstall(name, scope, cwd) {
 async function listInstalled(scope, cwd) {
   const resolvedScope = scope ?? "project";
   const root = resolveSkillRoot2(resolvedScope, cwd);
-  const pkgPath = join21(root, "package.json");
+  const pkgPath = join19(root, "package.json");
   try {
-    const pkgJson = JSON.parse(await readFile4(pkgPath, "utf-8"));
+    const pkgJson = JSON.parse(await readFile3(pkgPath, "utf-8"));
     const deps = pkgJson.dependencies || {};
     const results = [];
     for (const [name, version] of Object.entries(deps)) {
@@ -33573,9 +33684,9 @@ var require_out4 = __commonJS((exports, module) => {
 });
 
 // packages/core/src/skills/loader.ts
-import { join as join22, basename as basename4, dirname as dirname11 } from "path";
+import { join as join20, basename as basename4, dirname as dirname10 } from "path";
 import { homedir as homedir13 } from "os";
-import { readFile as readFile5, stat as stat3 } from "fs/promises";
+import { readFile as readFile4, stat as stat3 } from "fs/promises";
 
 class SkillLoader {
   skills = new Map;
@@ -33583,8 +33694,8 @@ class SkillLoader {
     const includeContent = options.includeContent ?? true;
     const envHome = process.env.HOME || process.env.USERPROFILE;
     const userHome = envHome && envHome.trim().length > 0 ? envHome : homedir13();
-    const globalRoot = join22(userHome, ".skill");
-    const projectRoot = join22(projectDir, ".skill");
+    const globalRoot = join20(userHome, ".skill");
+    const projectRoot = join20(projectDir, ".skill");
     await this.loadNpmSkills(globalRoot, { includeContent });
     await this.loadLocalSkills(globalRoot, { includeContent });
     await this.loadNpmSkills(projectRoot, { includeContent });
@@ -33593,7 +33704,7 @@ class SkillLoader {
   async loadNpmSkills(skillRoot, options) {
     const includeContent = options.includeContent ?? true;
     try {
-      const nmDir = join22(skillRoot, "node_modules", "@hasnaxyz");
+      const nmDir = join20(skillRoot, "node_modules", "@hasnaxyz");
       try {
         const stats = await stat3(nmDir);
         if (!stats.isDirectory())
@@ -33604,10 +33715,10 @@ class SkillLoader {
       const files = await import_fast_glob.default("skill-*/SKILL.md", { cwd: nmDir });
       const tasks = [];
       for (const file of files) {
-        const fullPath = join22(nmDir, file);
+        const fullPath = join20(nmDir, file);
         const dirName = file.split(/[\\/]/)[0];
         const packageName = `@hasnaxyz/${dirName}`;
-        const pkgJsonPath = join22(nmDir, dirName, "package.json");
+        const pkgJsonPath = join20(nmDir, dirName, "package.json");
         tasks.push(this.loadNpmSkillFile(fullPath, pkgJsonPath, packageName, { includeContent }));
       }
       await Promise.all(tasks);
@@ -33616,7 +33727,7 @@ class SkillLoader {
   async loadNpmSkillFile(filePath, pkgJsonPath, packageName, options) {
     let version;
     try {
-      const pkgJson = JSON.parse(await readFile5(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(await readFile4(pkgJsonPath, "utf-8"));
       version = pkgJson.version;
     } catch {}
     return this.loadSkillFile(filePath, options, {
@@ -33641,7 +33752,7 @@ class SkillLoader {
       });
       const tasks = [];
       for (const file of files) {
-        tasks.push(this.loadSkillFile(join22(skillRoot, file), { includeContent }, { source: "local" }));
+        tasks.push(this.loadSkillFile(join20(skillRoot, file), { includeContent }, { source: "local" }));
       }
       await Promise.all(tasks);
     } catch {}
@@ -33659,13 +33770,13 @@ class SkillLoader {
       const filesToLoad = [];
       const skillPrefixFiles = await import_fast_glob.default("skill-*/SKILL.md", { cwd: dir });
       for (const file of skillPrefixFiles) {
-        filesToLoad.push(join22(dir, file));
+        filesToLoad.push(join20(dir, file));
       }
       const regularFiles = await import_fast_glob.default("*/SKILL.md", { cwd: dir });
       for (const file of regularFiles) {
         const dirName = file.split(/[\\/]/)[0];
         if (!dirName.startsWith("skill-")) {
-          filesToLoad.push(join22(dir, file));
+          filesToLoad.push(join20(dir, file));
         }
       }
       const loadTasks = [];
@@ -33677,10 +33788,10 @@ class SkillLoader {
   }
   async loadSkillFile(filePath, options = {}, extra) {
     try {
-      const content = await readFile5(filePath, "utf-8");
+      const content = await readFile4(filePath, "utf-8");
       const { frontmatter, content: markdownContent } = parseFrontmatter(content);
       const includeContent = options.includeContent ?? true;
-      const dirName = basename4(dirname11(filePath));
+      const dirName = basename4(dirname10(filePath));
       const name = frontmatter.name || dirName;
       let description = frontmatter.description || "";
       if (!description && markdownContent) {
@@ -33789,8 +33900,8 @@ var init_loader2 = __esm(() => {
   import_fast_glob = __toESM(require_out4(), 1);
 });
 // packages/core/src/commands/loader.ts
-import { existsSync as existsSync17, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
-import { join as join23, basename as basename5, extname as extname2 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { join as join21, basename as basename5, extname as extname2 } from "path";
 import { homedir as homedir14 } from "os";
 
 class CommandLoader {
@@ -33803,17 +33914,17 @@ class CommandLoader {
     this.commands.clear();
     const envHome = process.env.HOME || process.env.USERPROFILE;
     const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir14();
-    const globalDir = join23(homeDir, ".assistants", "commands");
+    const globalDir = join21(homeDir, ".assistants", "commands");
     await this.loadFromDirectory(globalDir, "global");
-    const projectDir = join23(this.cwd, ".assistants", "commands");
+    const projectDir = join21(this.cwd, ".assistants", "commands");
     await this.loadFromDirectory(projectDir, "project");
   }
   async loadFromDirectory(dir, source, prefix = "") {
-    if (!existsSync17(dir))
+    if (!existsSync15(dir))
       return;
-    const entries = readdirSync7(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join23(dir, entry);
+      const fullPath = join21(dir, entry);
       const stat4 = statSync3(fullPath);
       if (stat4.isDirectory()) {
         const newPrefix = prefix ? `${prefix}:${entry}` : entry;
@@ -34179,7 +34290,7 @@ function formatAbsoluteTime(timestamp) {
   return new Date(timestamp).toLocaleString();
 }
 // packages/core/src/jobs/job-store.ts
-function getDb3() {
+function getDb5() {
   return getDatabase();
 }
 function jobToRow(job) {
@@ -34221,12 +34332,12 @@ function rowToJob(row) {
 }
 async function saveJob(job) {
   const params = jobToRow(job);
-  getDb3().prepare(`INSERT OR REPLACE INTO jobs (id, session_id, connector_name, action, status, input, output, error, timeout_ms, created_at, started_at, completed_at)
+  getDb5().prepare(`INSERT OR REPLACE INTO jobs (id, session_id, connector_name, action, status, input, output, error, timeout_ms, created_at, started_at, completed_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(...params);
 }
 async function readJob(id) {
   try {
-    const row = getDb3().query("SELECT * FROM jobs WHERE id = ?").get(id);
+    const row = getDb5().query("SELECT * FROM jobs WHERE id = ?").get(id);
     if (!row)
       return null;
     return rowToJob(row);
@@ -34236,7 +34347,7 @@ async function readJob(id) {
 }
 async function deleteJob(id) {
   try {
-    const result = getDb3().prepare("DELETE FROM jobs WHERE id = ?").run(id);
+    const result = getDb5().prepare("DELETE FROM jobs WHERE id = ?").run(id);
     return result.changes > 0;
   } catch {
     return false;
@@ -34244,7 +34355,7 @@ async function deleteJob(id) {
 }
 async function listJobs() {
   try {
-    const rows = getDb3().query("SELECT * FROM jobs ORDER BY created_at DESC").all();
+    const rows = getDb5().query("SELECT * FROM jobs ORDER BY created_at DESC").all();
     return rows.map(rowToJob);
   } catch {
     return [];
@@ -34252,7 +34363,7 @@ async function listJobs() {
 }
 async function listJobsForSession(sessionId) {
   try {
-    const rows = getDb3().query("SELECT * FROM jobs WHERE session_id = ? ORDER BY created_at DESC").all(sessionId);
+    const rows = getDb5().query("SELECT * FROM jobs WHERE session_id = ? ORDER BY created_at DESC").all(sessionId);
     return rows.map(rowToJob);
   } catch {
     return [];
@@ -34260,7 +34371,7 @@ async function listJobsForSession(sessionId) {
 }
 async function listJobsByStatus(status) {
   try {
-    const rows = getDb3().query("SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC").all(status);
+    const rows = getDb5().query("SELECT * FROM jobs WHERE status = ? ORDER BY created_at DESC").all(status);
     return rows.map(rowToJob);
   } catch {
     return [];
@@ -34879,7 +34990,7 @@ var init_types3 = __esm(() => {
 });
 
 // packages/core/src/tasks/store.ts
-function getDb4() {
+function getDb6() {
   return getDatabase();
 }
 function rowToTask(row) {
@@ -34943,7 +35054,7 @@ async function loadTaskStore(cwd) {
 }
 async function saveTaskStore(_cwd, _data) {}
 async function getTasks(cwd) {
-  const rows = getDb4().query("SELECT * FROM tasks WHERE project_path = ? ORDER BY created_at").all(cwd);
+  const rows = getDb6().query("SELECT * FROM tasks WHERE project_path = ? ORDER BY created_at").all(cwd);
   const tasks = rows.map(rowToTask);
   const knownIds = new Set(tasks.map((t) => t.id));
   for (const task of tasks) {
@@ -34959,7 +35070,7 @@ async function getTasks(cwd) {
   return tasks;
 }
 async function getTask(cwd, id) {
-  const row = getDb4().query("SELECT * FROM tasks WHERE project_path = ? AND id = ?").get(cwd, id);
+  const row = getDb6().query("SELECT * FROM tasks WHERE project_path = ? AND id = ?").get(cwd, id);
   return row ? rowToTask(row) : null;
 }
 async function resolveTaskId(cwd, idOrPrefix, filter) {
@@ -34973,7 +35084,7 @@ async function resolveTaskId(cwd, idOrPrefix, filter) {
   return { task: matches.length === 1 ? matches[0] : null, matches };
 }
 async function addTask(cwd, options, priority = "normal", projectId) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const now2 = Date.now();
     const opts = typeof options === "string" ? { description: options, priority, projectId } : options;
@@ -35042,7 +35153,7 @@ async function addTask(cwd, options, priority = "normal", projectId) {
   });
 }
 async function updateTask(cwd, id, updates) {
-  const d = getDb4();
+  const d = getDb6();
   const row = d.query("SELECT * FROM tasks WHERE project_path = ? AND id = ?").get(cwd, id);
   if (!row)
     return null;
@@ -35080,7 +35191,7 @@ async function updateTask(cwd, id, updates) {
   return updated ? rowToTask(updated) : null;
 }
 async function deleteTask(cwd, id) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const row = d.query("SELECT * FROM tasks WHERE project_path = ? AND id = ?").get(cwd, id);
     if (!row)
@@ -35107,7 +35218,7 @@ async function deleteTask(cwd, id) {
   });
 }
 async function clearPendingTasks(cwd) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const pending = d.query("SELECT id FROM tasks WHERE project_path = ? AND status = 'pending'").all(cwd);
     if (pending.length === 0)
@@ -35132,7 +35243,7 @@ async function clearPendingTasks(cwd) {
   });
 }
 async function clearCompletedTasks(cwd) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const completed = d.query("SELECT id FROM tasks WHERE project_path = ? AND (status = 'completed' OR status = 'failed')").all(cwd);
     if (completed.length === 0)
@@ -35178,18 +35289,18 @@ async function getNextTask(cwd) {
   return pending[0];
 }
 async function isPaused(cwd) {
-  const row = getDb4().query("SELECT paused FROM task_queue_settings WHERE project_path = ?").get(cwd);
+  const row = getDb6().query("SELECT paused FROM task_queue_settings WHERE project_path = ?").get(cwd);
   return row ? row.paused === 1 : false;
 }
 async function setPaused(cwd, paused) {
-  getDb4().prepare("INSERT OR REPLACE INTO task_queue_settings (project_path, paused, auto_run) VALUES (?, ?, COALESCE((SELECT auto_run FROM task_queue_settings WHERE project_path = ?), 1))").run(cwd, paused ? 1 : 0, cwd);
+  getDb6().prepare("INSERT OR REPLACE INTO task_queue_settings (project_path, paused, auto_run) VALUES (?, ?, COALESCE((SELECT auto_run FROM task_queue_settings WHERE project_path = ?), 1))").run(cwd, paused ? 1 : 0, cwd);
 }
 async function isAutoRun(cwd) {
-  const row = getDb4().query("SELECT auto_run FROM task_queue_settings WHERE project_path = ?").get(cwd);
+  const row = getDb6().query("SELECT auto_run FROM task_queue_settings WHERE project_path = ?").get(cwd);
   return row ? row.auto_run === 1 : true;
 }
 async function setAutoRun(cwd, autoRun) {
-  getDb4().prepare("INSERT OR REPLACE INTO task_queue_settings (project_path, paused, auto_run) VALUES (?, COALESCE((SELECT paused FROM task_queue_settings WHERE project_path = ?), 0), ?)").run(cwd, cwd, autoRun ? 1 : 0);
+  getDb6().prepare("INSERT OR REPLACE INTO task_queue_settings (project_path, paused, auto_run) VALUES (?, COALESCE((SELECT paused FROM task_queue_settings WHERE project_path = ?), 0), ?)").run(cwd, cwd, autoRun ? 1 : 0);
 }
 async function startTask(cwd, id) {
   return updateTask(cwd, id, {
@@ -35212,7 +35323,7 @@ async function failTask(cwd, id, error2) {
   });
 }
 async function getTaskCounts(cwd) {
-  const rows = getDb4().query("SELECT status, COUNT(*) as cnt FROM tasks WHERE project_path = ? GROUP BY status").all(cwd);
+  const rows = getDb6().query("SELECT status, COUNT(*) as cnt FROM tasks WHERE project_path = ? GROUP BY status").all(cwd);
   const counts = {
     pending: 0,
     in_progress: 0,
@@ -35225,16 +35336,16 @@ async function getTaskCounts(cwd) {
   return counts;
 }
 async function getRecurringTasks(cwd) {
-  const rows = getDb4().query("SELECT * FROM tasks WHERE project_path = ? AND is_recurring_template = 1").all(cwd);
+  const rows = getDb6().query("SELECT * FROM tasks WHERE project_path = ? AND is_recurring_template = 1").all(cwd);
   return rows.map(rowToTask);
 }
 async function getDueRecurringTasks(cwd) {
   const now2 = Date.now();
-  const rows = getDb4().query("SELECT * FROM tasks WHERE project_path = ? AND is_recurring_template = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?").all(cwd, now2);
+  const rows = getDb6().query("SELECT * FROM tasks WHERE project_path = ? AND is_recurring_template = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?").all(cwd, now2);
   return rows.map(rowToTask);
 }
 async function createRecurringInstance(cwd, templateId) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const row = d.query("SELECT * FROM tasks WHERE project_path = ? AND id = ? AND is_recurring_template = 1").get(cwd, templateId);
     if (!row || !row.recurrence)
@@ -35281,7 +35392,7 @@ async function processDueRecurringTasks(cwd) {
   return createdInstances;
 }
 async function cancelRecurringTask(cwd, id) {
-  const d = getDb4();
+  const d = getDb6();
   return d.transaction(() => {
     const row = d.query("SELECT * FROM tasks WHERE project_path = ? AND id = ? AND is_recurring_template = 1").get(cwd, id);
     if (!row)
@@ -35734,8 +35845,8 @@ var init_evaluator = __esm(() => {
 });
 
 // packages/core/src/guardrails/store.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
-import { join as join24, dirname as dirname12 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, existsSync as existsSync16, mkdirSync as mkdirSync9 } from "fs";
+import { join as join22, dirname as dirname11 } from "path";
 import { createHash as createHash3 } from "crypto";
 function generatePolicyId(name, scope) {
   const hash = createHash3("sha256").update(`${name}-${scope}-${Date.now()}`).digest("hex").slice(0, 8);
@@ -35759,20 +35870,20 @@ class GuardrailsStore {
   getFilePath(location) {
     switch (location) {
       case "user":
-        return join24(this.baseDir || getConfigDir(), "guardrails.json");
+        return join22(this.baseDir || getConfigDir(), "guardrails.json");
       case "project":
-        return join24(this.cwd, ".assistants", "guardrails.json");
+        return join22(this.cwd, ".assistants", "guardrails.json");
       case "local":
-        return join24(this.cwd, ".assistants", "guardrails.local.json");
+        return join22(this.cwd, ".assistants", "guardrails.local.json");
     }
   }
   loadFrom(location) {
     const filePath = this.getFilePath(location);
-    if (!existsSync18(filePath)) {
+    if (!existsSync16(filePath)) {
       return null;
     }
     try {
-      const content = readFileSync10(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       const data = JSON.parse(content);
       const config = data.guardrails || data;
       ensurePolicyIds(config);
@@ -35783,12 +35894,12 @@ class GuardrailsStore {
   }
   save(location, config) {
     const filePath = this.getFilePath(location);
-    const dir = dirname12(filePath);
-    if (!existsSync18(dir)) {
-      mkdirSync11(dir, { recursive: true });
+    const dir = dirname11(filePath);
+    if (!existsSync16(dir)) {
+      mkdirSync9(dir, { recursive: true });
     }
     ensurePolicyIds(config);
-    writeFileSync9(filePath, JSON.stringify({ guardrails: config }, null, 2), "utf-8");
+    writeFileSync8(filePath, JSON.stringify({ guardrails: config }, null, 2), "utf-8");
   }
   loadAll() {
     const userConfig = this.loadFrom("user");
@@ -65188,8 +65299,8 @@ var require_core3 = __commonJS((exports) => {
   function many1(p) {
     return ab(p, many(p), (head, tail) => [head, ...tail]);
   }
-  function ab(pa, pb, join25) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join25(ma.value, vb, data, i, j)));
+  function ab(pa, pb, join23) {
+    return (data, i) => mapOuter(pa(data, i), (ma) => mapInner(pb(data, ma.position), (vb, j) => join23(ma.value, vb, data, i, j)));
   }
   function left(pa, pb) {
     return ab(pa, pb, (va) => va);
@@ -65197,8 +65308,8 @@ var require_core3 = __commonJS((exports) => {
   function right(pa, pb) {
     return ab(pa, pb, (va, vb) => vb);
   }
-  function abc(pa, pb, pc, join25) {
-    return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join25(ma.value, mb.value, vc, data, i, j))));
+  function abc(pa, pb, pc, join23) {
+    return (data, i) => mapOuter(pa(data, i), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j) => join23(ma.value, mb.value, vc, data, i, j))));
   }
   function middle(pa, pb, pc) {
     return abc(pa, pb, pc, (ra, rb) => rb);
@@ -73911,82 +74022,89 @@ var init_email_parser = __esm(() => {
   import_mailparser = __toESM(require_mailparser(), 1);
 });
 
-// packages/core/src/utils/atomic-write.ts
-import { writeFileSync as writeFileSync10, renameSync, unlinkSync as unlinkSync4 } from "fs";
-function atomicWriteFileSync(path2, data) {
-  const tmpPath = `${path2}.${process.pid}.tmp`;
-  try {
-    writeFileSync10(tmpPath, data);
-    renameSync(tmpPath, path2);
-  } catch (error2) {
-    try {
-      unlinkSync4(tmpPath);
-    } catch {}
-    throw error2;
-  }
-}
-var init_atomic_write = () => {};
-
 // packages/core/src/workspace/shared.ts
-import { join as join25 } from "path";
+import { join as join23 } from "path";
 import {
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync8,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync10,
   rmSync,
-  renameSync as renameSync2
+  renameSync,
+  readdirSync as readdirSync6
 } from "fs";
+function getDb7() {
+  return getDatabase();
+}
+function rowToWorkspace(row) {
+  let participants = [];
+  try {
+    participants = JSON.parse(row.participants);
+  } catch {
+    participants = [];
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || undefined,
+    createdAt: new Date(row.created_at).getTime(),
+    updatedAt: new Date(row.updated_at).getTime(),
+    createdBy: row.creator_id,
+    participants,
+    status: row.status
+  };
+}
 
 class SharedWorkspaceManager {
   basePath;
-  constructor(basePath) {
-    this.basePath = basePath || join25(getConfigDir(), "workspaces");
+  db;
+  constructor(basePath, db) {
+    this.basePath = basePath || join23(getConfigDir(), "workspaces");
+    this.db = db || getDb7();
     this.ensureDir();
     this.migrateAgentsToAssistants();
   }
   ensureDir() {
-    if (!existsSync19(this.basePath)) {
-      mkdirSync12(this.basePath, { recursive: true });
+    if (!existsSync17(this.basePath)) {
+      mkdirSync10(this.basePath, { recursive: true });
     }
   }
   migrateAgentsToAssistants() {
     try {
-      const dirs = readdirSync8(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = readdirSync6(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const dir of dirs) {
-        const wsPath = join25(this.basePath, dir);
-        const oldAgentsDir = join25(wsPath, "agents");
-        const newAssistantsDir = join25(wsPath, "assistants");
-        if (existsSync19(oldAgentsDir) && !existsSync19(newAssistantsDir)) {
-          renameSync2(oldAgentsDir, newAssistantsDir);
+        const wsPath = join23(this.basePath, dir);
+        const oldAgentsDir = join23(wsPath, "agents");
+        const newAssistantsDir = join23(wsPath, "assistants");
+        if (existsSync17(oldAgentsDir) && !existsSync17(newAssistantsDir)) {
+          renameSync(oldAgentsDir, newAssistantsDir);
         }
       }
     } catch {}
   }
   getWorkspacePath(id) {
-    return join25(this.basePath, id);
-  }
-  getMetadataPath(id) {
-    return join25(this.getWorkspacePath(id), "workspace.json");
+    return join23(this.basePath, id);
   }
   create(name, createdBy, participants, description) {
     const id = `ws_${generateId().slice(0, 8)}`;
+    const now2 = Date.now();
+    const nowIso = new Date(now2).toISOString();
+    const allParticipants = [...new Set([createdBy, ...participants])];
     const workspace = {
       id,
       name,
       description,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
+      createdAt: now2,
+      updatedAt: now2,
       createdBy,
-      participants: [...new Set([createdBy, ...participants])],
+      participants: allParticipants,
       status: "active"
     };
     const wsPath = this.getWorkspacePath(id);
-    mkdirSync12(join25(wsPath, "shared"), { recursive: true });
-    for (const assistantId of workspace.participants) {
-      mkdirSync12(join25(wsPath, "assistants", assistantId), { recursive: true });
+    mkdirSync10(join23(wsPath, "shared"), { recursive: true });
+    for (const assistantId of allParticipants) {
+      mkdirSync10(join23(wsPath, "assistants", assistantId), { recursive: true });
     }
-    atomicWriteFileSync(this.getMetadataPath(id), JSON.stringify(workspace, null, 2));
+    this.db.prepare(`INSERT INTO workspaces (id, name, description, creator_id, creator_name, status, participants, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, name, description || null, createdBy, createdBy, "active", JSON.stringify(allParticipants), nowIso, nowIso);
     return workspace;
   }
   join(workspaceId, assistantId) {
@@ -73997,49 +74115,32 @@ class SharedWorkspaceManager {
     if (!workspace.participants.includes(assistantId)) {
       workspace.participants.push(assistantId);
       workspace.updatedAt = Date.now();
-      atomicWriteFileSync(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
+      this.db.prepare("UPDATE workspaces SET participants = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(workspace.participants), new Date(workspace.updatedAt).toISOString(), workspaceId);
     }
-    const assistantDir = join25(this.getWorkspacePath(workspaceId), "assistants", assistantId);
-    if (!existsSync19(assistantDir)) {
-      mkdirSync12(assistantDir, { recursive: true });
+    const assistantDir = join23(this.getWorkspacePath(workspaceId), "assistants", assistantId);
+    if (!existsSync17(assistantDir)) {
+      mkdirSync10(assistantDir, { recursive: true });
     }
   }
   get(workspaceId) {
-    try {
-      const metadataPath = this.getMetadataPath(workspaceId);
-      if (!existsSync19(metadataPath))
-        return null;
-      return JSON.parse(readFileSync11(metadataPath, "utf-8"));
-    } catch {
+    const row = this.db.query("SELECT * FROM workspaces WHERE id = ?").get(workspaceId);
+    if (!row)
       return null;
-    }
+    return rowToWorkspace(row);
   }
   getPath(workspaceId) {
     return this.getWorkspacePath(workspaceId);
   }
   getSharedPath(workspaceId) {
-    return join25(this.getWorkspacePath(workspaceId), "shared");
+    return join23(this.getWorkspacePath(workspaceId), "shared");
   }
   getAssistantPath(workspaceId, assistantId) {
-    return join25(this.getWorkspacePath(workspaceId), "assistants", assistantId);
+    return join23(this.getWorkspacePath(workspaceId), "assistants", assistantId);
   }
   list(includeArchived = false) {
-    try {
-      this.ensureDir();
-      const dirs = readdirSync8(this.basePath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-      const workspaces = [];
-      for (const dir of dirs) {
-        const workspace = this.get(dir);
-        if (workspace) {
-          if (includeArchived || workspace.status === "active") {
-            workspaces.push(workspace);
-          }
-        }
-      }
-      return workspaces.sort((a, b) => b.updatedAt - a.updatedAt);
-    } catch {
-      return [];
-    }
+    const query = includeArchived ? "SELECT * FROM workspaces ORDER BY updated_at DESC" : "SELECT * FROM workspaces WHERE status = 'active' ORDER BY updated_at DESC";
+    const rows = this.db.query(query).all();
+    return rows.map(rowToWorkspace);
   }
   listForAgent(assistantId) {
     return this.list().filter((ws) => ws.participants.includes(assistantId));
@@ -74047,44 +74148,42 @@ class SharedWorkspaceManager {
   archive(workspaceId) {
     const workspace = this.get(workspaceId);
     if (workspace) {
-      workspace.status = "archived";
-      workspace.updatedAt = Date.now();
-      atomicWriteFileSync(this.getMetadataPath(workspaceId), JSON.stringify(workspace, null, 2));
+      this.db.prepare("UPDATE workspaces SET status = 'archived', updated_at = ? WHERE id = ?").run(new Date().toISOString(), workspaceId);
     }
   }
   delete(workspaceId) {
+    this.db.prepare("DELETE FROM workspaces WHERE id = ?").run(workspaceId);
     const wsPath = this.getWorkspacePath(workspaceId);
-    if (existsSync19(wsPath)) {
+    if (existsSync17(wsPath)) {
       rmSync(wsPath, { recursive: true, force: true });
     }
   }
 }
 var init_shared2 = __esm(async () => {
   init_src2();
-  init_atomic_write();
-  await init_config();
+  await __promiseAll([
+    init_config(),
+    init_database()
+  ]);
 });
 
 // packages/core/src/workspace/active.ts
-import { join as join26 } from "path";
-import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join24 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11 } from "fs";
+function getDb8() {
+  return getDatabase();
+}
 function isValidId2(id) {
   return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN3.test(id);
 }
 function getWorkspaceRoot(baseDir) {
-  return join26(baseDir ?? getConfigDir(), "workspaces");
-}
-function getActiveWorkspacePath(baseDir) {
-  return join26(getWorkspaceRoot(baseDir), "active.json");
+  return join24(baseDir ?? getConfigDir(), "workspaces");
 }
-function getActiveWorkspaceId(baseDir) {
+function getActiveWorkspaceId(baseDir, db) {
   try {
-    const activePath = getActiveWorkspacePath(baseDir);
-    if (!existsSync20(activePath))
-      return null;
-    const raw = readFileSync12(activePath, "utf-8");
-    const data = JSON.parse(raw);
-    const id = data.id ?? null;
+    const conn = db || getDb8();
+    const row = conn.query("SELECT workspace_id FROM workspaces_active WHERE assistant_id = '__global__'").get();
+    const id = row?.workspace_id ?? null;
     if (id && !isValidId2(id)) {
       return null;
     }
@@ -74093,29 +74192,27 @@ function getActiveWorkspaceId(baseDir) {
     return null;
   }
 }
-function setActiveWorkspaceId(id, baseDir) {
+function setActiveWorkspaceId(id, baseDir, db) {
   if (id && !isValidId2(id)) {
     throw new Error(`Invalid workspace id: "${id}"`);
   }
-  const root = getWorkspaceRoot(baseDir);
-  if (!existsSync20(root)) {
-    mkdirSync13(root, { recursive: true });
+  const conn = db || getDb8();
+  if (id) {
+    conn.prepare("INSERT OR REPLACE INTO workspaces_active (assistant_id, workspace_id) VALUES ('__global__', ?)").run(id);
+  } else {
+    conn.prepare("DELETE FROM workspaces_active WHERE assistant_id = '__global__'").run();
   }
-  const activePath = getActiveWorkspacePath(baseDir);
-  try {
-    writeFileSync12(activePath, JSON.stringify({ id: id ?? null }, null, 2), "utf-8");
-  } catch {}
 }
 function getWorkspaceDataDir(workspaceId, baseDir) {
   if (!isValidId2(workspaceId)) {
     throw new Error(`Invalid workspace id: "${workspaceId}"`);
   }
-  return join26(getWorkspaceRoot(baseDir), workspaceId, ".assistants");
+  return join24(getWorkspaceRoot(baseDir), workspaceId, ".assistants");
 }
 function ensureWorkspaceDataDir(workspaceId, baseDir) {
   const dir = getWorkspaceDataDir(workspaceId, baseDir);
-  if (!existsSync20(dir)) {
-    mkdirSync13(dir, { recursive: true });
+  if (!existsSync18(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
   initAssistantsDir(dir);
   return dir;
@@ -74131,7 +74228,8 @@ var SAFE_ID_PATTERN3;
 var init_active = __esm(async () => {
   await __promiseAll([
     init_config(),
-    init_logger2()
+    init_logger2(),
+    init_database()
   ]);
   SAFE_ID_PATTERN3 = /^[a-zA-Z0-9_-]+$/;
 });
@@ -74195,9 +74293,9 @@ var init_defaults2 = __esm(() => {
 });
 
 // packages/core/src/budget/tracker.ts
-import { join as join27, dirname as dirname13 } from "path";
-import { homedir as homedir15 } from "os";
-import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync13 } from "fs";
+function getDb9() {
+  return getDatabase();
+}
 function createEmptyUsage() {
   const now2 = new Date().toISOString();
   return {
@@ -74220,85 +74318,92 @@ class BudgetTracker {
   projectUsages = new Map;
   sessionId;
   activeProjectId = null;
-  constructor(sessionId, config) {
+  db = null;
+  constructor(sessionId, config, db) {
     this.sessionId = sessionId;
     this.config = { ...DEFAULT_BUDGET_CONFIG, ...config };
     this.sessionUsage = createEmptyUsage();
     this.swarmUsage = createEmptyUsage();
     if (this.config.persist) {
+      try {
+        this.db = db || getDb9();
+      } catch {}
+    }
+    if (this.config.persist && this.db) {
       this.loadState();
     }
   }
-  getStatePath() {
-    const envHome = process.env.HOME || process.env.USERPROFILE || homedir15();
-    return join27(envHome, ".assistants", "budget", `${this.sessionId}.json`);
-  }
-  getProjectStatePath(projectId) {
-    const envHome = process.env.HOME || process.env.USERPROFILE || homedir15();
-    return join27(envHome, ".assistants", "budget", `project-${projectId}.json`);
-  }
   loadState() {
+    if (!this.db)
+      return;
     try {
-      const statePath = this.getStatePath();
-      if (!existsSync21(statePath))
-        return;
-      const data = JSON.parse(readFileSync13(statePath, "utf-8"));
-      if (data.version !== PERSISTENCE_VERSION && data.version !== 1)
-        return;
-      this.sessionUsage = data.session;
-      this.swarmUsage = data.swarm;
-      const assistantData = data.assistants || data.agents || {};
-      for (const [assistantId, usage] of Object.entries(assistantData)) {
-        this.assistantUsages.set(assistantId, usage);
+      const sessionRow = this.db.query("SELECT * FROM budget_usage WHERE scope = 'session' AND scope_id = ?").get(this.sessionId);
+      if (sessionRow) {
+        this.sessionUsage = {
+          ...this.sessionUsage,
+          inputTokens: sessionRow.input_tokens,
+          outputTokens: sessionRow.output_tokens,
+          totalTokens: sessionRow.total_tokens,
+          llmCalls: sessionRow.api_calls,
+          toolCalls: sessionRow.tool_calls,
+          lastUpdatedAt: sessionRow.updated_at
+        };
       }
-      if (data.projects) {
-        for (const [projectId, usage] of Object.entries(data.projects)) {
-          this.projectUsages.set(projectId, usage);
-        }
+      const swarmRow = this.db.query("SELECT * FROM budget_usage WHERE scope = 'swarm' AND scope_id = ?").get(this.sessionId);
+      if (swarmRow) {
+        this.swarmUsage = {
+          ...this.swarmUsage,
+          inputTokens: swarmRow.input_tokens,
+          outputTokens: swarmRow.output_tokens,
+          totalTokens: swarmRow.total_tokens,
+          llmCalls: swarmRow.api_calls,
+          toolCalls: swarmRow.tool_calls,
+          lastUpdatedAt: swarmRow.updated_at
+        };
+      }
+      const assistantRows = this.db.query("SELECT * FROM budget_usage WHERE scope = 'assistant' AND scope_id LIKE ?").all(`${this.sessionId}:%`);
+      for (const row of assistantRows) {
+        const assistantId = row.scope_id.replace(`${this.sessionId}:`, "");
+        this.assistantUsages.set(assistantId, {
+          ...createEmptyUsage(),
+          inputTokens: row.input_tokens,
+          outputTokens: row.output_tokens,
+          totalTokens: row.total_tokens,
+          llmCalls: row.api_calls,
+          toolCalls: row.tool_calls,
+          lastUpdatedAt: row.updated_at
+        });
+      }
+      const projectRows = this.db.query("SELECT * FROM budget_usage WHERE scope = 'project'").all();
+      for (const row of projectRows) {
+        this.projectUsages.set(row.scope_id, {
+          ...createEmptyUsage(),
+          inputTokens: row.input_tokens,
+          outputTokens: row.output_tokens,
+          totalTokens: row.total_tokens,
+          llmCalls: row.api_calls,
+          toolCalls: row.tool_calls,
+          lastUpdatedAt: row.updated_at
+        });
       }
     } catch {}
   }
-  loadProjectState(projectId) {
-    try {
-      const statePath = this.getProjectStatePath(projectId);
-      if (!existsSync21(statePath))
-        return createEmptyUsage();
-      const data = JSON.parse(readFileSync13(statePath, "utf-8"));
-      return data;
-    } catch {
-      return createEmptyUsage();
-    }
-  }
-  saveProjectState(projectId, usage) {
-    if (!this.config.persist)
+  saveUsageRow(scope, scopeId, usage) {
+    if (!this.db || !this.config.persist)
       return;
     try {
-      const statePath = this.getProjectStatePath(projectId);
-      const stateDir = dirname13(statePath);
-      if (!existsSync21(stateDir)) {
-        mkdirSync14(stateDir, { recursive: true });
-      }
-      atomicWriteFileSync(statePath, JSON.stringify(usage, null, 2));
+      this.db.prepare(`INSERT OR REPLACE INTO budget_usage (scope, scope_id, input_tokens, output_tokens, total_tokens, api_calls, tool_calls, estimated_cost_usd, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(scope, scopeId, usage.inputTokens, usage.outputTokens, usage.totalTokens, usage.llmCalls, usage.toolCalls, 0, usage.lastUpdatedAt);
     } catch {}
   }
   saveState() {
-    if (!this.config.persist)
+    if (!this.db || !this.config.persist)
       return;
-    try {
-      const statePath = this.getStatePath();
-      const stateDir = dirname13(statePath);
-      if (!existsSync21(stateDir)) {
-        mkdirSync14(stateDir, { recursive: true });
-      }
-      const state = {
-        version: PERSISTENCE_VERSION,
-        session: this.sessionUsage,
-        assistants: Object.fromEntries(this.assistantUsages),
-        swarm: this.swarmUsage,
-        projects: Object.fromEntries(this.projectUsages)
-      };
-      atomicWriteFileSync(statePath, JSON.stringify(state, null, 2));
-    } catch {}
+    this.saveUsageRow("session", this.sessionId, this.sessionUsage);
+    this.saveUsageRow("swarm", this.sessionId, this.swarmUsage);
+  }
+  saveProjectState(projectId, usage) {
+    this.saveUsageRow("project", projectId, usage);
   }
   isEnabled() {
     return this.config.enabled ?? false;
@@ -74309,8 +74414,24 @@ class BudgetTracker {
   setActiveProject(projectId) {
     this.activeProjectId = projectId;
     if (projectId && !this.projectUsages.has(projectId)) {
-      const usage = this.config.persist ? this.loadProjectState(projectId) : createEmptyUsage();
-      this.projectUsages.set(projectId, usage);
+      if (this.db && this.config.persist) {
+        const row = this.db.query("SELECT * FROM budget_usage WHERE scope = 'project' AND scope_id = ?").get(projectId);
+        if (row) {
+          this.projectUsages.set(projectId, {
+            ...createEmptyUsage(),
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            totalTokens: row.total_tokens,
+            llmCalls: row.api_calls,
+            toolCalls: row.tool_calls,
+            lastUpdatedAt: row.updated_at
+          });
+        } else {
+          this.projectUsages.set(projectId, createEmptyUsage());
+        }
+      } else {
+        this.projectUsages.set(projectId, createEmptyUsage());
+      }
     }
   }
   getActiveProject() {
@@ -74409,7 +74530,7 @@ class BudgetTracker {
     };
     if (scope === "assistant" && idOrAssistant) {
       const assistantUsage = this.assistantUsages.get(idOrAssistant) || createEmptyUsage();
-      this.assistantUsages.set(idOrAssistant, {
+      const updatedAssistant = {
         ...assistantUsage,
         inputTokens: assistantUsage.inputTokens + (update.inputTokens || 0),
         outputTokens: assistantUsage.outputTokens + (update.outputTokens || 0),
@@ -74418,7 +74539,9 @@ class BudgetTracker {
         toolCalls: assistantUsage.toolCalls + (update.toolCalls || 0),
         durationMs: assistantUsage.durationMs + (update.durationMs || 0),
         lastUpdatedAt: now2
-      });
+      };
+      this.assistantUsages.set(idOrAssistant, updatedAssistant);
+      this.saveUsageRow("assistant", `${this.sessionId}:${idOrAssistant}`, updatedAssistant);
     }
     if (scope === "swarm") {
       this.swarmUsage = {
@@ -74618,10 +74741,9 @@ class BudgetTracker {
 `);
   }
 }
-var PERSISTENCE_VERSION = 2;
-var init_tracker = __esm(() => {
+var init_tracker = __esm(async () => {
   init_defaults2();
-  init_atomic_write();
+  await init_database();
 });
 
 // packages/core/src/budget/tools.ts
@@ -74882,10 +75004,10 @@ __export(exports_budget, {
   DEFAULT_ASSISTANT_LIMITS: () => DEFAULT_ASSISTANT_LIMITS,
   BudgetTracker: () => BudgetTracker
 });
-var init_budget = __esm(() => {
-  init_tracker();
+var init_budget = __esm(async () => {
   init_defaults2();
   init_tools4();
+  await init_tracker();
 });
 
 // packages/core/src/registry/types.ts
@@ -74904,9 +75026,9 @@ var init_types4 = __esm(() => {
 });
 
 // packages/core/src/registry/store.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "fs";
-import { join as join28, dirname as dirname14 } from "path";
-import { homedir as homedir16 } from "os";
+function getDb10() {
+  return getDatabase();
+}
 function generateAssistantId() {
   return `assistant_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
@@ -75028,51 +75150,65 @@ class RegistryStore {
   config;
   cleanupTimer = null;
   startedAt;
-  constructor(config) {
+  db = null;
+  constructor(config, db) {
     this.config = { ...DEFAULT_REGISTRY_CONFIG, ...config };
     this.startedAt = Date.now();
-    if (this.config.storage === "file") {
-      this.loadFromFile();
+    if (db) {
+      this.db = db;
+    } else if (this.config.storage === "database" || this.config.storage === "file") {
+      try {
+        this.db = getDb10();
+      } catch {}
+    }
+    if (this.db) {
+      this.loadFromDb();
     }
     if (this.config.autoDeregister) {
       this.startCleanup();
     }
   }
-  getStoragePath() {
-    if (this.config.storagePath) {
-      return this.config.storagePath;
-    }
-    const home = process.env.HOME || process.env.USERPROFILE || homedir16();
-    return join28(home, ".assistants", "registry", "assistants.json");
+  loadFromDb() {
+    if (!this.db)
+      return;
+    try {
+      const rows = this.db.query("SELECT * FROM registered_assistants").all();
+      for (const row of rows) {
+        try {
+          if (row.metadata) {
+            const assistant = JSON.parse(row.metadata);
+            this.assistants.set(assistant.id, assistant);
+          }
+        } catch {}
+      }
+    } catch {}
   }
-  loadFromFile() {
+  saveToDb() {
+    if (!this.db)
+      return;
     try {
-      const path2 = this.getStoragePath();
-      if (!existsSync22(path2))
-        return;
-      const data = JSON.parse(readFileSync14(path2, "utf-8"));
-      if (Array.isArray(data.assistants)) {
-        for (const assistant of data.assistants) {
-          this.assistants.set(assistant.id, assistant);
-        }
+      for (const assistant of this.assistants.values()) {
+        this.persistAssistant(assistant);
       }
     } catch {}
   }
-  saveToFile() {
-    if (this.config.storage !== "file")
+  persistAssistant(assistant) {
+    if (!this.db)
       return;
     try {
-      const path2 = this.getStoragePath();
-      const dir = dirname14(path2);
-      if (!existsSync22(dir)) {
-        mkdirSync15(dir, { recursive: true });
-      }
-      const data = {
-        version: 1,
-        savedAt: new Date().toISOString(),
-        assistants: Array.from(this.assistants.values())
-      };
-      writeFileSync13(path2, JSON.stringify(data, null, 2));
+      const capabilitiesStr = JSON.stringify(assistant.capabilities);
+      const tagsStr = JSON.stringify(assistant.capabilities.tags);
+      const metadataStr = JSON.stringify(assistant);
+      this.db.prepare(`INSERT OR REPLACE INTO registered_assistants
+         (id, name, type, description, model, status, state, capabilities, tags, parent_id, created_at, updated_at, last_active_at, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(assistant.id, assistant.name, assistant.type, assistant.description || null, null, assistant.heartbeat.isStale ? "stale" : "active", assistant.status.state, capabilitiesStr, tagsStr, assistant.parentId || null, assistant.registeredAt, assistant.updatedAt, assistant.heartbeat.lastHeartbeat, metadataStr);
+    } catch {}
+  }
+  removeFromDb(id) {
+    if (!this.db)
+      return;
+    try {
+      this.db.prepare("DELETE FROM registered_assistants WHERE id = ?").run(id);
     } catch {}
   }
   startCleanup() {
@@ -75096,14 +75232,15 @@ class RegistryStore {
       const age = now2 - lastHeartbeat;
       if (age > staleThreshold) {
         this.assistants.delete(id);
+        this.removeFromDb(id);
       } else if (age > this.config.heartbeatStaleThreshold) {
         assistant.heartbeat.isStale = true;
         assistant.heartbeat.missedCount = Math.floor(age / this.config.heartbeatStaleThreshold);
         assistant.status.state = "offline";
         assistant.updatedAt = new Date().toISOString();
+        this.persistAssistant(assistant);
       }
     }
-    this.saveToFile();
   }
   register(registration) {
     if (this.assistants.size >= this.config.maxAssistants) {
@@ -75118,10 +75255,11 @@ class RegistryStore {
       if (parent) {
         parent.childIds.push(assistant.id);
         parent.updatedAt = new Date().toISOString();
+        this.persistAssistant(parent);
       }
     }
     this.assistants.set(assistant.id, assistant);
-    this.saveToFile();
+    this.persistAssistant(assistant);
     return assistant;
   }
   get(id) {
@@ -75161,7 +75299,7 @@ class RegistryStore {
       };
     }
     assistant.updatedAt = now2;
-    this.saveToFile();
+    this.persistAssistant(assistant);
     return assistant;
   }
   heartbeat(id) {
@@ -75187,13 +75325,14 @@ class RegistryStore {
       if (parent) {
         parent.childIds = parent.childIds.filter((cid) => cid !== id);
         parent.updatedAt = new Date().toISOString();
+        this.persistAssistant(parent);
       }
     }
     for (const childId of assistant.childIds) {
       this.deregister(childId);
     }
     this.assistants.delete(id);
-    this.saveToFile();
+    this.removeFromDb(id);
     return true;
   }
   query(query) {
@@ -75290,11 +75429,16 @@ class RegistryStore {
   }
   clear() {
     this.assistants.clear();
-    this.saveToFile();
+    if (this.db) {
+      try {
+        this.db.prepare("DELETE FROM registered_assistants").run();
+      } catch {}
+    }
   }
 }
-var init_store6 = __esm(() => {
+var init_store6 = __esm(async () => {
   init_types4();
+  await init_database();
 });
 
 // packages/core/src/registry/service.ts
@@ -75465,9 +75609,9 @@ function resetGlobalRegistry() {
   }
 }
 var globalRegistry = null;
-var init_service = __esm(() => {
+var init_service = __esm(async () => {
   init_types4();
-  init_store6();
+  await init_store6();
 });
 
 // packages/core/src/registry/index.ts
@@ -75479,9 +75623,11 @@ __export(exports_registry, {
   DEFAULT_REGISTRY_CONFIG: () => DEFAULT_REGISTRY_CONFIG,
   AssistantRegistryService: () => AssistantRegistryService
 });
-var init_registry2 = __esm(() => {
-  init_store6();
-  init_service();
+var init_registry2 = __esm(async () => {
+  await __promiseAll([
+    init_store6(),
+    init_service()
+  ]);
   init_types4();
 });
 
@@ -79857,9 +80003,9 @@ var init_swarm = __esm(() => {
 });
 
 // packages/core/src/commands/builtin.ts
-import { join as join29 } from "path";
-import { homedir as homedir17, platform as platform2, release, arch as arch2 } from "os";
-import { existsSync as existsSync23, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
+import { join as join25 } from "path";
+import { homedir as homedir15, platform as platform2, release, arch as arch2 } from "os";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, writeFileSync as writeFileSync9 } from "fs";
 function resolveAuthTimeout(resolve6) {
   resolve6({ exitCode: 1, stdout: { toString: () => "{}" } });
 }
@@ -86330,9 +86476,9 @@ Format the summary as a brief bullet-point list. This summary will replace the c
         if (action === "show" || action === "paths") {
           const storageDir = context.getStorageDir?.() || getConfigDir();
           const configPaths = [
-            join29(context.cwd, ".assistants", "config.json"),
-            join29(context.cwd, ".assistants", "config.local.json"),
-            join29(storageDir, "config.json")
+            join25(context.cwd, ".assistants", "config.json"),
+            join25(context.cwd, ".assistants", "config.local.json"),
+            join25(storageDir, "config.json")
           ];
           let message = `
 **Configuration**
@@ -86341,21 +86487,21 @@ Format the summary as a brief bullet-point list. This summary will replace the c
           message += `**Config File Locations:**
 `;
           for (const path2 of configPaths) {
-            const exists = existsSync23(path2);
+            const exists = existsSync19(path2);
             message += `  ${exists ? "\u2713" : "\u25CB"} ${path2}
 `;
           }
           const envHome = process.env.HOME || process.env.USERPROFILE;
-          const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir17();
+          const homeDir = envHome && envHome.trim().length > 0 ? envHome : homedir15();
           message += `
 **Commands Directories:**
 `;
-          message += `  - Project: ${join29(context.cwd, ".assistants", "commands")}
+          message += `  - Project: ${join25(context.cwd, ".assistants", "commands")}
 `;
-          message += `  - User/Workspace: ${join29(storageDir, "commands")}
+          message += `  - User/Workspace: ${join25(storageDir, "commands")}
 `;
-          if (storageDir !== join29(homeDir, ".assistants")) {
-            message += `  - Global fallback: ${join29(homeDir, ".assistants", "commands")}
+          if (storageDir !== join25(homeDir, ".assistants")) {
+            message += `  - Global fallback: ${join25(homeDir, ".assistants", "commands")}
 `;
           }
           context.emit("text", message);
@@ -86376,7 +86522,7 @@ Format the summary as a brief bullet-point list. This summary will replace the c
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const { BudgetTracker: BudgetTracker2 } = await Promise.resolve().then(() => (init_budget(), exports_budget));
+        const { BudgetTracker: BudgetTracker2 } = await init_budget().then(() => exports_budget);
         const rawArgs = args.trim();
         const [actionToken = "", ...actionParts] = rawArgs.length > 0 ? rawArgs.split(/\s+/) : [];
         const action = actionToken.toLowerCase();
@@ -86802,7 +86948,7 @@ On exceeded: ${config.onExceeded || "warn"}
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const { getGlobalRegistry: getGlobalRegistry2 } = await Promise.resolve().then(() => (init_registry2(), exports_registry));
+        const { getGlobalRegistry: getGlobalRegistry2 } = await init_registry2().then(() => exports_registry);
         const action = args.trim().toLowerCase();
         const registry = getGlobalRegistry2();
         if (action === "help") {
@@ -87271,8 +87417,8 @@ ${error2 instanceof Error ? error2.message : String(error2)}
       selfHandled: true,
       content: "",
       handler: async (args, context) => {
-        const commandsDir = join29(context.cwd, ".assistants", "commands");
-        mkdirSync16(commandsDir, { recursive: true });
+        const commandsDir = join25(context.cwd, ".assistants", "commands");
+        mkdirSync12(commandsDir, { recursive: true });
         const exampleCommand = `---
 name: reflect
 description: Reflect on the conversation and suggest next steps
@@ -87287,9 +87433,9 @@ Please summarize the last interaction and suggest 2-3 next steps.
 - Focus on clarity
 - Ask a follow-up question if needed
 `;
-        const examplePath = join29(commandsDir, "reflect.md");
-        if (!existsSync23(examplePath)) {
-          writeFileSync14(examplePath, exampleCommand);
+        const examplePath = join25(commandsDir, "reflect.md");
+        if (!existsSync19(examplePath)) {
+          writeFileSync9(examplePath, exampleCommand);
         }
         let message = `
 **Initialized assistants**
@@ -88018,11 +88164,11 @@ Memory Statistics
           return { handled: true };
         }
         if (action === "export") {
-          const filePath = rest[0] || join29(context.getStorageDir?.() || getConfigDir(), "memories-export.json");
+          const filePath = rest[0] || join25(context.getStorageDir?.() || getConfigDir(), "memories-export.json");
           const memories = await manager.export();
           try {
             const content = JSON.stringify(memories, null, 2);
-            writeFileSync14(filePath, content, "utf-8");
+            writeFileSync9(filePath, content, "utf-8");
             context.emit("text", `Exported ${memories.length} memories to: ${filePath}
 `);
           } catch (error2) {
@@ -88236,7 +88382,7 @@ Importing ${validMemories.length} valid entries (skipping ${errors.length} inval
         const heartbeatConfig = context.getHeartbeatConfig?.() ?? null;
         const historyPathTemplate = heartbeatConfig?.historyPath;
         const storageDir = context.getStorageDir?.();
-        const runsDir = storageDir ? join29(storageDir, "heartbeats", "runs") : undefined;
+        const runsDir = storageDir ? join25(storageDir, "heartbeats", "runs") : undefined;
         if (!cleanedArgs || cleanedArgs === "ui") {
           context.emit("done");
           return { handled: true, showPanel: "heartbeat" };
@@ -88938,11 +89084,10 @@ Not a git repository or git not available.
     context.setProjectContext(projectContext);
   }
 }
-var VERSION2 = "1.1.51";
+var VERSION2 = "1.1.53";
 var init_builtin = __esm(async () => {
   init_src2();
   init_context3();
-  init_verification();
   init_create();
   init_installer();
   init_templates();
@@ -88954,6 +89099,7 @@ var init_builtin = __esm(async () => {
     init_store3(),
     init_history(),
     init_store(),
+    init_verification(),
     init_hooks(),
     init_jobs2(),
     init_tasks()
@@ -93877,9 +94023,9 @@ var init_client3 = __esm(() => {
 });
 
 // packages/core/src/heartbeat/manager.ts
-import { dirname as dirname15 } from "path";
-import { mkdirSync as mkdirSync17 } from "fs";
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname12 } from "path";
+import { mkdirSync as mkdirSync13 } from "fs";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 
 class HeartbeatManager {
   config;
@@ -93900,8 +94046,8 @@ class HeartbeatManager {
       errorsEncountered: 0,
       uptimeSeconds: 0
     };
-    const dir = dirname15(config.persistPath);
-    mkdirSync17(dir, { recursive: true });
+    const dir = dirname12(config.persistPath);
+    mkdirSync13(dir, { recursive: true });
   }
   start(sessionId) {
     if (this.intervalId)
@@ -93989,7 +94135,7 @@ class HeartbeatManager {
   }
   static async checkStale(path3, thresholdMs) {
     try {
-      const content = await readFile6(path3, "utf-8");
+      const content = await readFile5(path3, "utf-8");
       const heartbeat = JSON.parse(content);
       const age = Date.now() - new Date(heartbeat.timestamp).getTime();
       return { isStale: age > thresholdMs, lastHeartbeat: heartbeat };
@@ -94082,65 +94228,38 @@ var init_recovery = __esm(async () => {
 });
 
 // packages/core/src/heartbeat/finder.ts
-import { existsSync as existsSync24, readdirSync as readdirSync9, readFileSync as readFileSync15 } from "fs";
-import { join as join30 } from "path";
 function findRecoverableSessions(staleThresholdMs = 120000, maxAgeMs = 24 * 60 * 60 * 1000, baseDir) {
-  const configDir = baseDir ?? getConfigDir();
-  const heartbeatsDir = join30(configDir, "heartbeats");
-  const stateDir = join30(configDir, "state");
-  const sessionsDir = join30(configDir, "sessions");
   const recoverableSessions = [];
-  if (!existsSync24(heartbeatsDir)) {
+  let db;
+  try {
+    db = getDatabase();
+  } catch {
     return recoverableSessions;
   }
   const now2 = Date.now();
-  const heartbeatFiles = readdirSync9(heartbeatsDir).filter((f) => f.endsWith(".json"));
-  for (const file of heartbeatFiles) {
-    const sessionId = file.replace(".json", "");
-    const heartbeatPath = join30(heartbeatsDir, file);
-    const statePath = join30(stateDir, `${sessionId}.json`);
-    const sessionPath = join30(sessionsDir, `${sessionId}.json`);
+  const cutoffIso = new Date(now2 - maxAgeMs).toISOString();
+  const rows = db.query("SELECT session_id, heartbeat, context, timestamp FROM heartbeat_state WHERE timestamp > ?").all(cutoffIso);
+  for (const row of rows) {
     try {
-      const heartbeatContent = readFileSync15(heartbeatPath, "utf-8");
-      const heartbeat = JSON.parse(heartbeatContent);
+      const heartbeat = JSON.parse(row.heartbeat);
+      const context = JSON.parse(row.context);
       const heartbeatAge = now2 - new Date(heartbeat.timestamp).getTime();
       if (heartbeatAge < staleThresholdMs) {
         continue;
       }
-      let state = null;
-      if (existsSync24(statePath)) {
-        const stateContent = readFileSync15(statePath, "utf-8");
-        state = JSON.parse(stateContent);
-      }
-      if (state) {
-        const stateAge = now2 - new Date(state.timestamp).getTime();
-        if (stateAge > maxAgeMs) {
-          continue;
-        }
-      }
+      const state = {
+        sessionId: row.session_id,
+        heartbeat,
+        context,
+        timestamp: row.timestamp
+      };
       let messageCount = 0;
-      let cwd = state?.context?.cwd || process.cwd();
-      if (existsSync24(sessionPath)) {
-        try {
-          const sessionContent = readFileSync15(sessionPath, "utf-8");
-          const sessionData = JSON.parse(sessionContent);
-          messageCount = sessionData.messages?.length || 0;
-          cwd = sessionData.cwd || cwd;
-        } catch {}
-      }
-      if (!state && messageCount === 0) {
-        continue;
-      }
+      const cwd = context.cwd || process.cwd();
       recoverableSessions.push({
-        sessionId,
+        sessionId: row.session_id,
         heartbeat,
-        state: state || {
-          sessionId,
-          heartbeat,
-          context: { cwd },
-          timestamp: heartbeat.timestamp
-        },
-        sessionPath,
+        state,
+        sessionPath: "",
         cwd,
         lastActivity: new Date(heartbeat.lastActivity || heartbeat.timestamp),
         messageCount
@@ -94153,23 +94272,13 @@ function findRecoverableSessions(staleThresholdMs = 120000, maxAgeMs = 24 * 60 *
   return recoverableSessions;
 }
 function clearRecoveryState(sessionId, baseDir) {
-  const configDir = baseDir ?? getConfigDir();
-  const heartbeatPath = join30(configDir, "heartbeats", `${sessionId}.json`);
-  const statePath = join30(configDir, "state", `${sessionId}.json`);
-  const { unlinkSync: unlinkSync5 } = __require("fs");
-  try {
-    if (existsSync24(heartbeatPath)) {
-      unlinkSync5(heartbeatPath);
-    }
-  } catch {}
   try {
-    if (existsSync24(statePath)) {
-      unlinkSync5(statePath);
-    }
+    const db = getDatabase();
+    db.prepare("DELETE FROM heartbeat_state WHERE session_id = ?").run(sessionId);
   } catch {}
 }
 var init_finder = __esm(async () => {
-  await init_config();
+  await init_database();
 });
 
 // packages/core/src/heartbeat/conventions.ts
@@ -94292,15 +94401,15 @@ var init_watchdog = __esm(async () => {
 });
 
 // packages/core/src/heartbeat/install-skills.ts
-import { join as join31 } from "path";
-import { homedir as homedir18 } from "os";
+import { join as join26 } from "path";
+import { homedir as homedir16 } from "os";
 async function writeSkillIfNeeded(dir, skillName, content) {
-  const { mkdir: mkdir7, writeFile: writeFile5, readFile: readFile7 } = await import("fs/promises");
-  const skillDir = join31(dir, `skill-${skillName}`);
-  const skillFile = join31(skillDir, "SKILL.md");
+  const { mkdir: mkdir7, writeFile: writeFile5, readFile: readFile6 } = await import("fs/promises");
+  const skillDir = join26(dir, `skill-${skillName}`);
+  const skillFile = join26(skillDir, "SKILL.md");
   await mkdir7(skillDir, { recursive: true });
   try {
-    const existing = await readFile7(skillFile, "utf-8");
+    const existing = await readFile6(skillFile, "utf-8");
     if (existing === content) {
       return false;
     }
@@ -94316,8 +94425,8 @@ async function writeSkillIfNeeded(dir, skillName, content) {
   }
 }
 async function installHeartbeatSkills() {
-  const baseDir = process.env.ASSISTANTS_DIR || join31(homedir18(), ".assistants");
-  const sharedSkillsDir = join31(baseDir, "shared", "skills");
+  const baseDir = process.env.ASSISTANTS_DIR || join26(homedir16(), ".assistants");
+  const sharedSkillsDir = join26(baseDir, "shared", "skills");
   const installed = [];
   const results = await Promise.all([
     writeSkillIfNeeded(sharedSkillsDir, "main-loop", MAIN_LOOP_SKILL),
@@ -94678,8 +94787,8 @@ var init_llm_response = __esm(() => {
 // packages/core/src/voice/tts.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join32 } from "path";
-import { readFileSync as readFileSync16, unlinkSync as unlinkSync5 } from "fs";
+import { join as join27 } from "path";
+import { readFileSync as readFileSync10, unlinkSync as unlinkSync3 } from "fs";
 
 class ElevenLabsTTS {
   apiKey;
@@ -94783,7 +94892,7 @@ class SystemTTS {
       if (!say) {
         throw new Error('System TTS not available: missing "say" command.');
       }
-      const output = join32(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.aiff`);
+      const output = join27(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.aiff`);
       const args = [];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -94796,8 +94905,8 @@ class SystemTTS {
       if (result.status !== 0) {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
-      const audio = readFileSync16(output);
-      unlinkSync5(output);
+      const audio = readFileSync10(output);
+      unlinkSync3(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
         format: "aiff"
@@ -94805,7 +94914,7 @@ class SystemTTS {
     }
     const espeak = findExecutable("espeak") || findExecutable("espeak-ng");
     if (espeak) {
-      const output = join32(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.wav`);
+      const output = join27(tmpdir2(), `assistants-tts-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.wav`);
       const args = ["-w", output];
       if (this.voiceId) {
         args.push("-v", this.voiceId);
@@ -94818,8 +94927,8 @@ class SystemTTS {
       if (result.status !== 0) {
         throw new Error(`System TTS failed: ${result.stderr || "unknown error"}`);
       }
-      const audio = readFileSync16(output);
-      unlinkSync5(output);
+      const audio = readFileSync10(output);
+      unlinkSync3(output);
       return {
         audio: audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength),
         format: "wav"
@@ -94835,16 +94944,16 @@ var init_tts = __esm(() => {
 // packages/core/src/voice/player.ts
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join33 } from "path";
-import { unlink as unlink2, writeFileSync as writeFileSync15, appendFileSync as appendFileSync3 } from "fs";
+import { join as join28 } from "path";
+import { unlink as unlink2, writeFileSync as writeFileSync10, appendFileSync as appendFileSync3 } from "fs";
 
 class AudioPlayer {
   currentProcess = null;
   playing = false;
   async play(audio, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join33(tmpdir3(), `assistants-audio-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
-    writeFileSync15(tempFile, Buffer.from(audio));
+    const tempFile = join28(tmpdir3(), `assistants-audio-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
+    writeFileSync10(tempFile, Buffer.from(audio));
     const player = this.resolvePlayer(format);
     if (!player) {
       throw new Error("No supported audio player found. Install afplay, ffplay, mpg123, or aplay.");
@@ -94871,8 +94980,8 @@ class AudioPlayer {
   }
   async playStream(chunks, options = {}) {
     const format = options.format ?? "mp3";
-    const tempFile = join33(tmpdir3(), `assistants-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
-    writeFileSync15(tempFile, Buffer.alloc(0));
+    const tempFile = join28(tmpdir3(), `assistants-stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${format}`);
+    writeFileSync10(tempFile, Buffer.alloc(0));
     for await (const chunk of chunks) {
       appendFileSync3(tempFile, Buffer.from(chunk));
     }
@@ -94940,8 +95049,8 @@ var init_player = __esm(() => {
 // packages/core/src/voice/recorder.ts
 import { spawn as spawn3 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join34 } from "path";
-import { readFileSync as readFileSync17, existsSync as existsSync25, unlink as unlink3 } from "fs";
+import { join as join29 } from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync20, unlink as unlink3 } from "fs";
 
 class AudioRecorder {
   currentProcess = null;
@@ -94954,7 +95063,7 @@ class AudioRecorder {
     const duration = options.durationSeconds ?? 5;
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
-    const output = join34(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join29(tmpdir4(), `assistants-record-${Date.now()}.wav`);
     this.currentOutputPath = output;
     this.stoppedIntentionally = false;
     const recorder = this.resolveRecorder(sampleRate, channels, duration, output);
@@ -94976,11 +95085,11 @@ class AudioRecorder {
         reject(error3);
       });
     });
-    if (!existsSync25(output)) {
+    if (!existsSync20(output)) {
       this.currentOutputPath = null;
       return new ArrayBuffer(0);
     }
-    const data = readFileSync17(output);
+    const data = readFileSync11(output);
     unlink3(output, () => {});
     this.currentOutputPath = null;
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -94992,7 +95101,7 @@ class AudioRecorder {
     const sampleRate = options.sampleRate ?? 16000;
     const channels = options.channels ?? 1;
     const maxDuration = options.durationSeconds ?? 30;
-    const output = join34(tmpdir4(), `assistants-record-${Date.now()}.wav`);
+    const output = join29(tmpdir4(), `assistants-record-${Date.now()}.wav`);
     this.currentOutputPath = output;
     this.stoppedIntentionally = false;
     const recorder = this.resolveVadRecorder(sampleRate, channels, maxDuration, output);
@@ -95014,11 +95123,11 @@ class AudioRecorder {
         reject(error3);
       });
     });
-    if (!existsSync25(output)) {
+    if (!existsSync20(output)) {
       this.currentOutputPath = null;
       return new ArrayBuffer(0);
     }
-    const data = readFileSync17(output);
+    const data = readFileSync11(output);
     unlink3(output, () => {});
     this.currentOutputPath = null;
     return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -95402,9 +95511,9 @@ var init_manager4 = __esm(() => {
   init_recorder();
 });
 // packages/core/src/identity/identity-manager.ts
-import { existsSync as existsSync26 } from "fs";
-import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5, rm as rm2 } from "fs/promises";
-import { join as join35 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { mkdir as mkdir7, readFile as readFile6, writeFile as writeFile5, rm as rm2 } from "fs/promises";
+import { join as join30 } from "path";
 function isValidId3(id) {
   return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN4.test(id);
 }
@@ -95425,20 +95534,20 @@ class IdentityManager {
     this.basePath = basePath;
   }
   get identitiesRoot() {
-    return join35(this.basePath, "assistants", this.assistantId, "identities");
+    return join30(this.basePath, "assistants", this.assistantId, "identities");
   }
   get indexPath() {
-    return join35(this.identitiesRoot, "index.json");
+    return join30(this.identitiesRoot, "index.json");
   }
   get activePath() {
-    return join35(this.identitiesRoot, "active.json");
+    return join30(this.identitiesRoot, "active.json");
   }
   identityPath(id) {
     validateId(id, "identityId");
-    return join35(this.identitiesRoot, `${id}.json`);
+    return join30(this.identitiesRoot, `${id}.json`);
   }
   assistantConfigPath() {
-    return join35(this.basePath, "assistants", this.assistantId, "config.json");
+    return join30(this.basePath, "assistants", this.assistantId, "config.json");
   }
   async initialize() {
     await mkdir7(this.identitiesRoot, { recursive: true });
@@ -95564,11 +95673,11 @@ class IdentityManager {
 `);
   }
   async readIndex() {
-    if (!existsSync26(this.indexPath)) {
+    if (!existsSync21(this.indexPath)) {
       return { identities: [] };
     }
     try {
-      const raw = await readFile7(this.indexPath, "utf-8");
+      const raw = await readFile6(this.indexPath, "utf-8");
       const data = JSON.parse(raw);
       const identities = Array.isArray(data.identities) ? data.identities : [];
       return { identities: identities.filter(isValidId3) };
@@ -95590,10 +95699,10 @@ class IdentityManager {
   }
   async readIdentity(id) {
     const path3 = this.identityPath(id);
-    if (!existsSync26(path3))
+    if (!existsSync21(path3))
       return null;
     try {
-      const raw = await readFile7(path3, "utf-8");
+      const raw = await readFile6(path3, "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -95604,10 +95713,10 @@ class IdentityManager {
     await writeFile5(this.identityPath(identity.id), JSON.stringify(identity, null, 2));
   }
   async readActive() {
-    if (!existsSync26(this.activePath))
+    if (!existsSync21(this.activePath))
       return null;
     try {
-      const raw = await readFile7(this.activePath, "utf-8");
+      const raw = await readFile6(this.activePath, "utf-8");
       const data = JSON.parse(raw);
       const id = data.id || null;
       if (id && !isValidId3(id)) {
@@ -95623,10 +95732,10 @@ class IdentityManager {
     await writeFile5(this.activePath, JSON.stringify({ id }, null, 2));
   }
   async loadAssistant() {
-    if (!existsSync26(this.assistantConfigPath()))
+    if (!existsSync21(this.assistantConfigPath()))
       return null;
     try {
-      const raw = await readFile7(this.assistantConfigPath(), "utf-8");
+      const raw = await readFile6(this.assistantConfigPath(), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -95659,49 +95768,81 @@ var init_identity_manager = __esm(() => {
 });
 
 // packages/core/src/identity/assistant-manager.ts
-import { existsSync as existsSync27 } from "fs";
-import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile6, rm as rm3 } from "fs/promises";
-import { join as join36 } from "path";
-function isValidId4(id) {
-  return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN5.test(id);
+function getDb11() {
+  return getDatabase();
 }
-function validateId2(id, idType) {
-  if (!isValidId4(id)) {
-    throw new Error(`Invalid ${idType}: "${id}" contains invalid characters. Only alphanumeric characters, hyphens, and underscores are allowed.`);
-  }
+function rowToAssistant(row) {
+  const raw = JSON.parse(row.settings);
+  const avatar = raw.__avatar;
+  const description = raw.__description;
+  const color = raw.__color;
+  const isSystem = raw.__isSystem;
+  delete raw.__avatar;
+  delete raw.__description;
+  delete raw.__color;
+  delete raw.__isSystem;
+  const settings = raw;
+  const assistant = {
+    id: row.id,
+    name: row.name,
+    settings,
+    createdAt: new Date(row.created_at).toISOString(),
+    updatedAt: new Date(row.updated_at).toISOString()
+  };
+  if (row.identity_id)
+    assistant.defaultIdentityId = row.identity_id;
+  if (avatar)
+    assistant.avatar = avatar;
+  if (description)
+    assistant.description = description;
+  if (color)
+    assistant.color = color;
+  if (isSystem)
+    assistant.isSystem = true;
+  return assistant;
+}
+function assistantToRow(assistant) {
+  const settingsObj = { ...assistant.settings };
+  if (assistant.avatar)
+    settingsObj.__avatar = assistant.avatar;
+  if (assistant.description)
+    settingsObj.__description = assistant.description;
+  if (assistant.color)
+    settingsObj.__color = assistant.color;
+  if (assistant.isSystem)
+    settingsObj.__isSystem = true;
+  return {
+    id: assistant.id,
+    name: assistant.name,
+    model: assistant.settings.model || null,
+    system_prompt: assistant.settings.systemPromptAddition || null,
+    settings: JSON.stringify(settingsObj),
+    identity_id: assistant.defaultIdentityId || null,
+    created_at: new Date(assistant.createdAt).getTime(),
+    updated_at: new Date(assistant.updatedAt).getTime()
+  };
 }
 
 class AssistantManager {
   basePath;
   assistants = new Map;
   activeId = null;
-  constructor(basePath) {
+  db;
+  constructor(basePath, db) {
     this.basePath = basePath;
-  }
-  get assistantsRoot() {
-    return join36(this.basePath, "assistants");
-  }
-  get indexPath() {
-    return join36(this.assistantsRoot, "index.json");
-  }
-  get activePath() {
-    return join36(this.basePath, "active.json");
-  }
-  assistantConfigPath(id) {
-    validateId2(id, "assistantId");
-    return join36(this.assistantsRoot, id, "config.json");
+    this.db = db || getDb11();
   }
   async initialize() {
-    await mkdir8(this.assistantsRoot, { recursive: true });
-    const index = await this.readIndex();
-    for (const id of index.assistants) {
-      const assistant = await this.readAssistant(id);
-      if (assistant) {
-        this.assistants.set(id, assistant);
-      }
+    const rows = this.db.query("SELECT * FROM assistants_config").all();
+    for (const row of rows) {
+      try {
+        const assistant = rowToAssistant(row);
+        this.assistants.set(assistant.id, assistant);
+      } catch {}
     }
     await this.seedSystemAssistants();
-    this.activeId = await this.readActive();
+    const activeRow = this.db.query("SELECT assistant_id FROM assistants_active WHERE key = 'active'").get();
+    this.activeId = activeRow?.assistant_id || null;
     if (!this.activeId || !this.assistants.has(this.activeId)) {
       await this.setActive(DEFAULT_SYSTEM_ASSISTANT_ID);
     }
@@ -95719,14 +95860,13 @@ class AssistantManager {
       createdAt: now2,
       updatedAt: now2
     };
-    await this.persistAssistant(assistant);
+    this.persistAssistant(assistant);
     this.assistants.set(id, assistant);
-    await this.appendToIndex(id);
     await this.setActive(id);
     return assistant;
   }
   async updateAssistant(id, updates) {
-    const existing = this.assistants.get(id) || await this.readAssistant(id);
+    const existing = this.assistants.get(id);
     if (!existing) {
       throw new Error(`Assistant ${id} not found`);
     }
@@ -95736,12 +95876,11 @@ class AssistantManager {
       settings: { ...existing.settings, ...updates.settings || {} },
       updatedAt: new Date().toISOString()
     };
-    await this.persistAssistant(updated);
+    this.persistAssistant(updated);
     this.assistants.set(id, updated);
     return updated;
   }
   async deleteAssistant(id) {
-    validateId2(id, "assistantId");
     if (!this.assistants.has(id)) {
       throw new Error(`Assistant ${id} not found`);
     }
@@ -95749,16 +95888,15 @@ class AssistantManager {
     if (assistant?.isSystem || isSystemAssistantId(id)) {
       throw new Error(`Cannot delete system assistant "${assistant?.name || id}". System assistants are built-in and cannot be removed.`);
     }
-    await rm3(join36(this.assistantsRoot, id), { recursive: true, force: true });
+    this.db.prepare("DELETE FROM assistants_config WHERE id = ?").run(id);
     this.assistants.delete(id);
-    await this.removeFromIndex(id);
     if (this.activeId === id) {
       const next = this.listAssistants()[0];
       await this.setActive(next?.id || null);
     }
   }
   async switchAssistant(id) {
-    const assistant = this.assistants.get(id) || await this.readAssistant(id);
+    const assistant = this.assistants.get(id);
     if (!assistant) {
       throw new Error(`Assistant ${id} not found`);
     }
@@ -95784,91 +95922,42 @@ class AssistantManager {
     for (const def of definitions) {
       if (!this.assistants.has(def.id)) {
         const assistant = buildSystemAssistant(def);
-        await this.persistAssistant(assistant);
+        this.persistAssistant(assistant);
         this.assistants.set(def.id, assistant);
-        await this.appendToIndex(def.id);
       }
     }
   }
-  async readIndex() {
-    if (!existsSync27(this.indexPath)) {
-      return { assistants: [] };
-    }
-    try {
-      const raw = await readFile8(this.indexPath, "utf-8");
-      const data = JSON.parse(raw);
-      const assistants = Array.isArray(data.assistants) ? data.assistants : [];
-      return { assistants: assistants.filter(isValidId4) };
-    } catch {
-      return { assistants: [] };
-    }
-  }
-  async appendToIndex(id) {
-    const index = await this.readIndex();
-    if (!index.assistants.includes(id)) {
-      index.assistants.push(id);
-    }
-    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
-  }
-  async removeFromIndex(id) {
-    const index = await this.readIndex();
-    index.assistants = index.assistants.filter((assistantId) => assistantId !== id);
-    await writeFile6(this.indexPath, JSON.stringify(index, null, 2));
-  }
-  async readAssistant(id) {
-    const configPath = this.assistantConfigPath(id);
-    if (!existsSync27(configPath))
-      return null;
-    try {
-      const raw = await readFile8(configPath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-  async persistAssistant(assistant) {
-    validateId2(assistant.id, "assistantId");
-    const dir = join36(this.assistantsRoot, assistant.id);
-    await mkdir8(dir, { recursive: true });
-    await writeFile6(this.assistantConfigPath(assistant.id), JSON.stringify(assistant, null, 2));
-  }
-  async readActive() {
-    if (!existsSync27(this.activePath))
-      return null;
-    try {
-      const raw = await readFile8(this.activePath, "utf-8");
-      const data = JSON.parse(raw);
-      const id = data.id || null;
-      if (id && !isValidId4(id)) {
-        return null;
-      }
-      return id;
-    } catch {
-      return null;
-    }
+  persistAssistant(assistant) {
+    const row = assistantToRow(assistant);
+    this.db.prepare(`INSERT OR REPLACE INTO assistants_config (id, name, model, system_prompt, settings, identity_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.name, row.model, row.system_prompt, row.settings, row.identity_id, row.created_at, row.updated_at);
   }
   async setActive(id) {
     this.activeId = id;
-    await writeFile6(this.activePath, JSON.stringify({ id }, null, 2));
+    if (id) {
+      this.db.prepare("INSERT OR REPLACE INTO assistants_active (key, assistant_id) VALUES ('active', ?)").run(id);
+    } else {
+      this.db.prepare("DELETE FROM assistants_active WHERE key = 'active'").run();
+    }
   }
 }
-var SAFE_ID_PATTERN5, DEFAULT_SETTINGS;
-var init_assistant_manager = __esm(() => {
+var DEFAULT_SETTINGS;
+var init_assistant_manager = __esm(async () => {
   init_src2();
   init_identity_manager();
   init_system_assistants();
-  SAFE_ID_PATTERN5 = /^[a-zA-Z0-9_-]+$/;
+  await init_database();
   DEFAULT_SETTINGS = {
     model: "claude-opus-4-5"
   };
 });
 
 // packages/core/src/identity/index.ts
-var init_identity2 = __esm(() => {
-  init_assistant_manager();
+var init_identity2 = __esm(async () => {
   init_identity_manager();
   init_templates();
   init_system_assistants();
+  await init_assistant_manager();
 });
 
 // node_modules/.pnpm/@smithy+types@4.12.0/node_modules/@smithy/types/dist-cjs/index.js
@@ -110901,7 +110990,7 @@ var require_readFile = __commonJS((exports) => {
   var promises_1 = __require("fs/promises");
   exports.filePromises = {};
   exports.fileIntercept = {};
-  var readFile9 = (path3, options) => {
+  var readFile7 = (path3, options) => {
     if (exports.fileIntercept[path3] !== undefined) {
       return exports.fileIntercept[path3];
     }
@@ -110910,7 +110999,7 @@ var require_readFile = __commonJS((exports) => {
     }
     return exports.filePromises[path3];
   };
-  exports.readFile = readFile9;
+  exports.readFile = readFile7;
 });
 
 // node_modules/.pnpm/@smithy+shared-ini-file-loader@4.4.3/node_modules/@smithy/shared-ini-file-loader/dist-cjs/index.js
@@ -110920,7 +111009,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   var getSSOTokenFromFile = require_getSSOTokenFromFile();
   var path3 = __require("path");
   var types11 = require_dist_cjs();
-  var readFile9 = require_readFile();
+  var readFile7 = require_readFile();
   var ENV_PROFILE = "AWS_PROFILE";
   var DEFAULT_PROFILE2 = "default";
   var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE2;
@@ -111004,10 +111093,10 @@ var require_dist_cjs35 = __commonJS((exports) => {
       resolvedConfigFilepath = path3.join(homeDir, configFilepath.slice(2));
     }
     const parsedFiles = await Promise.all([
-      readFile9.readFile(resolvedConfigFilepath, {
+      readFile7.readFile(resolvedConfigFilepath, {
         ignoreCache: init.ignoreCache
       }).then(parseIni).then(getConfigData).catch(swallowError$1),
-      readFile9.readFile(resolvedFilepath, {
+      readFile7.readFile(resolvedFilepath, {
         ignoreCache: init.ignoreCache
       }).then(parseIni).catch(swallowError$1)
     ]);
@@ -111018,7 +111107,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   };
   var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(types11.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
   var swallowError = () => ({});
-  var loadSsoSessionData = async (init = {}) => readFile9.readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
+  var loadSsoSessionData = async (init = {}) => readFile7.readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
   var mergeConfigFiles = (...files) => {
     const merged = {};
     for (const file of files) {
@@ -111038,10 +111127,10 @@ var require_dist_cjs35 = __commonJS((exports) => {
   };
   var externalDataInterceptor = {
     getFileRecord() {
-      return readFile9.fileIntercept;
+      return readFile7.fileIntercept;
     },
     interceptFile(path4, contents) {
-      readFile9.fileIntercept[path4] = Promise.resolve(contents);
+      readFile7.fileIntercept[path4] = Promise.resolve(contents);
     },
     getTokenRecord() {
       return getSSOTokenFromFile.tokenIntercept;
@@ -111059,7 +111148,7 @@ var require_dist_cjs35 = __commonJS((exports) => {
   Object.defineProperty(exports, "readFile", {
     enumerable: true,
     get: function() {
-      return readFile9.readFile;
+      return readFile7.readFile;
     }
   });
   exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
@@ -120701,14 +120790,14 @@ var init_validateTokenKey = __esm(() => {
 
 // node_modules/.pnpm/@aws-sdk+token-providers@3.985.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
 import { promises as fsPromises } from "fs";
-var import_shared_ini_file_loader, writeFile7, writeSSOTokenToFile = (id, ssoToken) => {
+var import_shared_ini_file_loader, writeFile6, writeSSOTokenToFile = (id, ssoToken) => {
   const tokenFilepath = import_shared_ini_file_loader.getSSOTokenFilepath(id);
   const tokenString = JSON.stringify(ssoToken, null, 2);
-  return writeFile7(tokenFilepath, tokenString);
+  return writeFile6(tokenFilepath, tokenString);
 };
 var init_writeSSOTokenToFile = __esm(() => {
   import_shared_ini_file_loader = __toESM(require_dist_cjs35(), 1);
-  ({ writeFile: writeFile7 } = fsPromises);
+  ({ writeFile: writeFile6 } = fsPromises);
 });
 
 // node_modules/.pnpm/@aws-sdk+token-providers@3.985.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
@@ -123344,8 +123433,8 @@ var require_signin = __commonJS((exports) => {
 // node_modules/.pnpm/@aws-sdk+credential-provider-login@3.972.5/node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
 import { createHash as createHash4, createPrivateKey, createPublicKey, sign } from "crypto";
 import { promises as fs2 } from "fs";
-import { homedir as homedir19 } from "os";
-import { dirname as dirname16, join as join37 } from "path";
+import { homedir as homedir17 } from "os";
+import { dirname as dirname13, join as join31 } from "path";
 var import_property_provider18, import_protocol_http11, import_shared_ini_file_loader6, LoginCredentialsFetcher;
 var init_LoginCredentialsFetcher = __esm(() => {
   import_property_provider18 = __toESM(require_dist_cjs17(), 1);
@@ -123498,17 +123587,17 @@ var init_LoginCredentialsFetcher = __esm(() => {
     }
     async saveToken(token) {
       const tokenFilePath = this.getTokenFilePath();
-      const directory = dirname16(tokenFilePath);
+      const directory = dirname13(tokenFilePath);
       try {
         await fs2.mkdir(directory, { recursive: true });
       } catch (error3) {}
       await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
     }
     getTokenFilePath() {
-      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join37(homedir19(), ".aws", "login", "cache");
+      const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join31(homedir17(), ".aws", "login", "cache");
       const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
       const loginSessionSha256 = createHash4("sha256").update(loginSessionBytes).digest("hex");
-      return join37(directory, `${loginSessionSha256}.json`);
+      return join31(directory, `${loginSessionSha256}.json`);
     }
     derToRawSignature(derSignature) {
       let offset = 2;
@@ -123814,7 +123903,7 @@ var fromWebToken = (init) => async (awsIdentityProperties) => {
 };
 
 // node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.972.5/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 var import_client17, import_property_provider21, import_shared_ini_file_loader10, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
   init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
   const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
@@ -123827,7 +123916,7 @@ var import_client17, import_property_provider21, import_shared_ini_file_loader10
   }
   const credentials = await fromWebToken({
     ...init,
-    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync18(webIdentityTokenFile, { encoding: "ascii" }),
+    webIdentityToken: import_shared_ini_file_loader10.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync12(webIdentityTokenFile, { encoding: "ascii" }),
     roleArn,
     roleSessionName
   })(awsIdentityProperties);
@@ -128163,8 +128252,8 @@ var init_s3_client = __esm(() => {
 });
 
 // packages/core/src/inbox/storage/local-cache.ts
-import { join as join38, basename as basename6 } from "path";
-import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile8, rm as rm4, readdir, stat as stat4 } from "fs/promises";
+import { join as join32, basename as basename6 } from "path";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile7, rm as rm3, readdir, stat as stat4 } from "fs/promises";
 import { createHash as createHash5 } from "crypto";
 function isValidAssistantId(id) {
   return typeof id === "string" && id.length > 0 && STRICT_ID_PATTERN.test(id);
@@ -128189,7 +128278,7 @@ function sanitizeFilename(filename) {
   const base = basename6(filename);
   return base.replace(/[/\\]/g, "_");
 }
-function getDb5(injected) {
+function getDb12(injected) {
   if (injected)
     return injected;
   return getDatabase();
@@ -128204,15 +128293,15 @@ class LocalInboxCache {
     validateAssistantId(options.assistantId);
     this.assistantId = options.assistantId;
     this.basePath = options.basePath;
-    this.cacheDir = join38(this.basePath, this.assistantId);
+    this.cacheDir = join32(this.basePath, this.assistantId);
     this.injectedDb = options.db;
   }
   db() {
-    return getDb5(this.injectedDb);
+    return getDb12(this.injectedDb);
   }
   async ensureDirectories() {
-    await mkdir9(join38(this.cacheDir, "emails"), { recursive: true });
-    await mkdir9(join38(this.cacheDir, "attachments"), { recursive: true });
+    await mkdir8(join32(this.cacheDir, "emails"), { recursive: true });
+    await mkdir8(join32(this.cacheDir, "attachments"), { recursive: true });
   }
   async loadIndex() {
     const rows = this.db().query("SELECT * FROM inbox_cache WHERE assistant_id = ? ORDER BY date DESC").all(this.assistantId);
@@ -128240,8 +128329,8 @@ class LocalInboxCache {
       throw new Error(`Failed to create safe filename for email ID: "${email.id}"`);
     }
     await this.ensureDirectories();
-    const emailPath = join38(this.cacheDir, "emails", `${filename}.json`);
-    await writeFile8(emailPath, JSON.stringify(email, null, 2));
+    const emailPath = join32(this.cacheDir, "emails", `${filename}.json`);
+    await writeFile7(emailPath, JSON.stringify(email, null, 2));
     const existing = this.db().query("SELECT * FROM inbox_cache WHERE id = ? AND assistant_id = ?").get(email.id, this.assistantId);
     if (existing) {
       const useFilename = existing.filename || filename;
@@ -128259,8 +128348,8 @@ class LocalInboxCache {
     if (!isValidMappedFilename(filename))
       return null;
     try {
-      const emailPath = join38(this.cacheDir, "emails", `${filename}.json`);
-      const content = await readFile10(emailPath, "utf-8");
+      const emailPath = join32(this.cacheDir, "emails", `${filename}.json`);
+      const content = await readFile8(emailPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -128311,10 +128400,10 @@ class LocalInboxCache {
     if (!safeFilename) {
       throw new Error("Invalid attachment filename");
     }
-    const attachmentDir = join38(this.cacheDir, "attachments", emailFilename);
-    await mkdir9(attachmentDir, { recursive: true });
-    const attachmentPath = join38(attachmentDir, safeFilename);
-    await writeFile8(attachmentPath, content);
+    const attachmentDir = join32(this.cacheDir, "attachments", emailFilename);
+    await mkdir8(attachmentDir, { recursive: true });
+    const attachmentPath = join32(attachmentDir, safeFilename);
+    await writeFile7(attachmentPath, content);
     return attachmentPath;
   }
   async getAttachmentPath(emailId, filename) {
@@ -128327,7 +128416,7 @@ class LocalInboxCache {
       return null;
     }
     try {
-      const attachmentPath = join38(this.cacheDir, "attachments", emailFilename, safeFilename);
+      const attachmentPath = join32(this.cacheDir, "attachments", emailFilename, safeFilename);
       await stat4(attachmentPath);
       return attachmentPath;
     } catch {
@@ -128350,10 +128439,10 @@ class LocalInboxCache {
       const filename = row.filename || emailIdToFilename(row.id);
       if (isValidMappedFilename(filename)) {
         try {
-          await rm4(join38(this.cacheDir, "emails", `${filename}.json`));
+          await rm3(join32(this.cacheDir, "emails", `${filename}.json`));
         } catch {}
         try {
-          await rm4(join38(this.cacheDir, "attachments", filename), { recursive: true });
+          await rm3(join32(this.cacheDir, "attachments", filename), { recursive: true });
         } catch {}
       }
     }
@@ -128365,20 +128454,20 @@ class LocalInboxCache {
   async getCacheSize() {
     let totalSize = 0;
     try {
-      const emailsDir = join38(this.cacheDir, "emails");
+      const emailsDir = join32(this.cacheDir, "emails");
       const files = await readdir(emailsDir);
       for (const file of files) {
-        const fileStat = await stat4(join38(emailsDir, file));
+        const fileStat = await stat4(join32(emailsDir, file));
         totalSize += fileStat.size;
       }
     } catch {}
     try {
-      const attachmentsDir = join38(this.cacheDir, "attachments");
+      const attachmentsDir = join32(this.cacheDir, "attachments");
       const dirs = await readdir(attachmentsDir);
       for (const dir of dirs) {
-        const files = await readdir(join38(attachmentsDir, dir));
+        const files = await readdir(join32(attachmentsDir, dir));
         for (const file of files) {
-          const fileStat = await stat4(join38(attachmentsDir, dir, file));
+          const fileStat = await stat4(join32(attachmentsDir, dir, file));
           totalSize += fileStat.size;
         }
       }
@@ -128387,7 +128476,7 @@ class LocalInboxCache {
   }
   async clear() {
     try {
-      await rm4(this.cacheDir, { recursive: true });
+      await rm3(this.cacheDir, { recursive: true });
     } catch {}
     this.db().prepare("DELETE FROM inbox_cache WHERE assistant_id = ?").run(this.assistantId);
     this.db().prepare("DELETE FROM inbox_sync WHERE assistant_id = ?").run(this.assistantId);
@@ -146615,8 +146704,8 @@ function many(p4) {
 function many1(p4) {
   return ab2(p4, many(p4), (head, tail) => [head, ...tail]);
 }
-function ab2(pa, pb, join39) {
-  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapInner(pb(data, ma.position), (vb, j4) => join39(ma.value, vb, data, i4, j4)));
+function ab2(pa, pb, join33) {
+  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapInner(pb(data, ma.position), (vb, j4) => join33(ma.value, vb, data, i4, j4)));
 }
 function left(pa, pb) {
   return ab2(pa, pb, (va) => va);
@@ -146624,8 +146713,8 @@ function left(pa, pb) {
 function right(pa, pb) {
   return ab2(pa, pb, (va, vb) => vb);
 }
-function abc(pa, pb, pc, join39) {
-  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j4) => join39(ma.value, mb.value, vc, data, i4, j4))));
+function abc(pa, pb, pc, join33) {
+  return (data, i4) => mapOuter(pa(data, i4), (ma) => mapOuter(pb(data, ma.position), (mb) => mapInner(pc(data, mb.position), (vc, j4) => join33(ma.value, mb.value, vc, data, i4, j4))));
 }
 function middle(pa, pb, pc) {
   return abc(pa, pb, pc, (ra, rb) => rb);
@@ -170212,7 +170301,7 @@ var init_providers = __esm(() => {
 });
 
 // packages/core/src/inbox/inbox-manager.ts
-import { join as join39 } from "path";
+import { join as join33 } from "path";
 
 class InboxManager {
   assistantId;
@@ -170386,7 +170475,7 @@ class InboxManager {
   }
 }
 function createInboxManager(assistantId, assistantName, config, configDir) {
-  const basePath = join39(configDir, "messages");
+  const basePath = join33(configDir, "messages");
   return new InboxManager({
     assistantId,
     assistantName,
@@ -172677,7 +172766,7 @@ var init_secrets_client = __esm(() => {
 });
 
 // packages/core/src/wallet/storage/local-client.ts
-function getDb6(injected) {
+function getDb13(injected) {
   if (injected)
     return injected;
   return getDatabase();
@@ -172689,7 +172778,7 @@ class LocalWalletClient {
     this.injectedDb = options.db;
   }
   db() {
-    return getDb6(this.injectedDb);
+    return getDb13(this.injectedDb);
   }
   async listCards(assistantId) {
     const rows = this.db().query("SELECT * FROM wallet_cards WHERE assistant_id = ? ORDER BY created_at DESC").all(assistantId);
@@ -173537,7 +173626,7 @@ var init_secrets_client2 = __esm(() => {
 });
 
 // packages/core/src/secrets/storage/local-client.ts
-function getDb7(injected) {
+function getDb14(injected) {
   if (injected)
     return injected;
   return getDatabase();
@@ -173549,7 +173638,7 @@ class LocalSecretsClient {
     this.injectedDb = options.db;
   }
   db() {
-    return getDb7(this.injectedDb);
+    return getDb14(this.injectedDb);
   }
   async listSecrets(scope, assistantId) {
     const items = [];
@@ -174114,7 +174203,7 @@ var init_secrets = __esm(async () => {
 function getMessagesBasePath() {
   return "";
 }
-function getDb8(injected) {
+function getDb15(injected) {
   if (injected)
     return injected;
   return getDatabase();
@@ -174163,7 +174252,7 @@ class LocalMessagesStorage {
     this.injectedDb = options.db;
   }
   db() {
-    return getDb8(this.injectedDb);
+    return getDb15(this.injectedDb);
   }
   async ensureDirectories(_assistantId) {}
   async loadRegistry() {
@@ -174410,8 +174499,8 @@ var init_local_storage = __esm(async () => {
 });
 
 // packages/core/src/messages/watcher.ts
-import { watch, existsSync as existsSync28, readdirSync as readdirSync10 } from "fs";
-import { join as join40 } from "path";
+import { watch, existsSync as existsSync22, readdirSync as readdirSync7 } from "fs";
+import { join as join34 } from "path";
 
 class InboxWatcher {
   assistantId;
@@ -174423,14 +174512,14 @@ class InboxWatcher {
   constructor(assistantId, basePath) {
     this.assistantId = assistantId;
     const base = basePath || getMessagesBasePath();
-    this.inboxPath = join40(base, assistantId, "messages");
+    this.inboxPath = join34(base, assistantId, "messages");
   }
   start() {
     if (this.running)
       return;
     this.running = true;
     this.snapshotExisting();
-    if (!existsSync28(this.inboxPath)) {
+    if (!existsSync22(this.inboxPath)) {
       this.pollForDirectory();
       return;
     }
@@ -174455,8 +174544,8 @@ class InboxWatcher {
   }
   snapshotExisting() {
     try {
-      if (existsSync28(this.inboxPath)) {
-        const files = readdirSync10(this.inboxPath);
+      if (existsSync22(this.inboxPath)) {
+        const files = readdirSync7(this.inboxPath);
         for (const file of files) {
           if (file.endsWith(".json")) {
             this.knownFiles.add(file);
@@ -174498,7 +174587,7 @@ class InboxWatcher {
         clearInterval(interval);
         return;
       }
-      if (existsSync28(this.inboxPath)) {
+      if (existsSync22(this.inboxPath)) {
         clearInterval(interval);
         this.snapshotExisting();
         this.startWatching();
@@ -175203,7 +175292,7 @@ var init_messages5 = __esm(async () => {
 function getWebhooksBasePath() {
   return "";
 }
-function getDb9(injected) {
+function getDb16(injected) {
   if (injected)
     return injected;
   return getDatabase();
@@ -175266,7 +175355,7 @@ class LocalWebhookStorage {
     this.injectedDb = options.db;
   }
   db() {
-    return getDb9(this.injectedDb);
+    return getDb16(this.injectedDb);
   }
   async ensureDirectories(_webhookId) {}
   async loadIndex() {
@@ -175400,8 +175489,8 @@ var init_local_storage2 = __esm(async () => {
 });
 
 // packages/core/src/webhooks/watcher.ts
-import { watch as watch2, existsSync as existsSync29, readdirSync as readdirSync11 } from "fs";
-import { join as join41 } from "path";
+import { watch as watch2, existsSync as existsSync23, readdirSync as readdirSync8 } from "fs";
+import { join as join35 } from "path";
 
 class WebhookEventWatcher {
   basePath;
@@ -175413,13 +175502,13 @@ class WebhookEventWatcher {
   directoryWatcher = null;
   constructor(basePath) {
     this.basePath = basePath || getWebhooksBasePath();
-    this.eventsPath = join41(this.basePath, "events");
+    this.eventsPath = join35(this.basePath, "events");
   }
   start() {
     if (this.running)
       return;
     this.running = true;
-    if (!existsSync29(this.eventsPath)) {
+    if (!existsSync23(this.eventsPath)) {
       this.pollForDirectory();
       return;
     }
@@ -175452,8 +175541,8 @@ class WebhookEventWatcher {
       this.directoryWatcher = watch2(this.eventsPath, (eventType, filename) => {
         if (!filename || eventType !== "rename")
           return;
-        const dirPath = join41(this.eventsPath, filename);
-        if (existsSync29(dirPath) && !this.watchers.has(filename)) {
+        const dirPath = join35(this.eventsPath, filename);
+        if (existsSync23(dirPath) && !this.watchers.has(filename)) {
           this.watchWebhookDir(filename);
         }
       });
@@ -175469,7 +175558,7 @@ class WebhookEventWatcher {
       });
     } catch {}
     try {
-      const dirs = readdirSync11(this.eventsPath);
+      const dirs = readdirSync8(this.eventsPath);
       for (const dir of dirs) {
         this.watchWebhookDir(dir);
       }
@@ -175478,12 +175567,12 @@ class WebhookEventWatcher {
   watchWebhookDir(webhookId) {
     if (this.watchers.has(webhookId))
       return;
-    const dirPath = join41(this.eventsPath, webhookId);
-    if (!existsSync29(dirPath))
+    const dirPath = join35(this.eventsPath, webhookId);
+    if (!existsSync23(dirPath))
       return;
     const known = new Set;
     try {
-      const files = readdirSync11(dirPath);
+      const files = readdirSync8(dirPath);
       for (const file of files) {
         if (file.endsWith(".json") && file !== "index.json") {
           known.add(file);
@@ -175523,7 +175612,7 @@ class WebhookEventWatcher {
         clearInterval(interval);
         return;
       }
-      if (existsSync29(this.eventsPath)) {
+      if (existsSync23(this.eventsPath)) {
         clearInterval(interval);
         this.startWatchingAll();
       }
@@ -176845,17 +176934,17 @@ import { spawn as spawn4 } from "child_process";
 import { createInterface } from "readline";
 import * as fs4 from "fs";
 import { stat as statPromise, open as open2 } from "fs/promises";
-import { join as join42 } from "path";
-import { homedir as homedir20 } from "os";
-import { dirname as dirname17, join as join210 } from "path";
+import { join as join36 } from "path";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname14, join as join210 } from "path";
 import { cwd } from "process";
 import { realpathSync as realpathSync2 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { randomUUID as randomUUID22 } from "crypto";
-import { appendFileSync as appendFileSync22, existsSync as existsSync210, mkdirSync as mkdirSync22 } from "fs";
-import { join as join310 } from "path";
+import { appendFileSync as appendFileSync22, existsSync as existsSync25, mkdirSync as mkdirSync22 } from "fs";
+import { join as join37 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join43 } from "path";
+import { join as join42 } from "path";
 import { fileURLToPath } from "url";
 function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
   const controller = new AbortController;
@@ -177130,7 +177219,7 @@ function shouldShowDebugMessage(message, filter) {
   return shouldShowDebugCategories(categories, filter);
 }
 function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join42(homedir20(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join36(homedir18(), ".claude");
 }
 function isEnvTruthy(envVar) {
   if (!envVar)
@@ -177345,8 +177434,8 @@ function getDebugWriter() {
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
         const path3 = getDebugLogPath();
-        if (!getFsImplementation().existsSync(dirname17(path3))) {
-          getFsImplementation().mkdirSync(dirname17(path3));
+        if (!getFsImplementation().existsSync(dirname14(path3))) {
+          getFsImplementation().mkdirSync(dirname14(path3));
         }
         getFsImplementation().appendFileSync(path3, content);
         updateLatestDebugLogSymlink();
@@ -177407,9 +177496,9 @@ function getOrCreateDebugFile() {
   if (!process.env.DEBUG_CLAUDE_AGENT_SDK) {
     return null;
   }
-  const debugDir = join310(getClaudeConfigHomeDir(), "debug");
-  debugFilePath = join310(debugDir, `sdk-${randomUUID22()}.txt`);
-  if (!existsSync210(debugDir)) {
+  const debugDir = join37(getClaudeConfigHomeDir(), "debug");
+  debugFilePath = join37(debugDir, `sdk-${randomUUID22()}.txt`);
+  if (!existsSync25(debugDir)) {
     mkdirSync22(debugDir, { recursive: true });
   }
   process.stderr.write(`SDK debug logs: ${debugFilePath}
@@ -190767,7 +190856,7 @@ var init_sdk2 = __esm(() => {
     }
     try {
       const debugLogPath = getDebugLogPath();
-      const debugLogsDir = dirname17(debugLogPath);
+      const debugLogsDir = dirname14(debugLogPath);
       const latestSymlinkPath = join210(debugLogsDir, "latest");
       if (!getFsImplementation().existsSync(debugLogsDir)) {
         getFsImplementation().mkdirSync(debugLogsDir);
@@ -191465,8 +191554,8 @@ var init_sdk2 = __esm(() => {
       let pathToClaudeCodeExecutable = options.pathToClaudeCodeExecutable;
       if (!pathToClaudeCodeExecutable) {
         const filename = fileURLToPath(import.meta.url);
-        const dirname22 = join43(filename, "..");
-        pathToClaudeCodeExecutable = join43(dirname22, "cli.js");
+        const dirname22 = join42(filename, "..");
+        pathToClaudeCodeExecutable = join42(dirname22, "cli.js");
       }
       const processEnv = { ...options.env ?? process.env };
       if (!processEnv.CLAUDE_CODE_ENTRYPOINT) {
@@ -199677,45 +199766,50 @@ var init_channels = __esm(async () => {
 });
 
 // packages/core/src/people/store.ts
-import { existsSync as existsSync31 } from "fs";
-import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile9, rm as rm5 } from "fs/promises";
-import { join as join44 } from "path";
-function isValidId5(id) {
-  return typeof id === "string" && id.length > 0 && SAFE_ID_PATTERN6.test(id);
+function getDb17() {
+  return getDatabase();
 }
-function validateId3(id) {
-  if (!isValidId5(id)) {
-    throw new Error(`Invalid person ID: "${id}" contains invalid characters.`);
+function rowToPerson(row) {
+  const person = {
+    id: row.id,
+    name: row.name,
+    status: "active",
+    createdAt: new Date(row.created_at).toISOString(),
+    updatedAt: new Date(row.updated_at).toISOString()
+  };
+  if (row.email)
+    person.email = row.email;
+  if (row.avatar_url)
+    person.avatar = row.avatar_url;
+  if (row.metadata) {
+    try {
+      const meta = JSON.parse(row.metadata);
+      if (meta.status)
+        person.status = meta.status;
+      if (meta.defaultIdentityId)
+        person.defaultIdentityId = meta.defaultIdentityId;
+    } catch {}
   }
+  return person;
 }
 
 class PeopleStore {
-  basePath;
   people = new Map;
   activeId = null;
-  constructor(basePath) {
-    this.basePath = basePath || join44(getConfigDir(), "people");
-  }
-  get indexPath() {
-    return join44(this.basePath, "index.json");
-  }
-  get activePath() {
-    return join44(this.basePath, "active.json");
-  }
-  personConfigPath(id) {
-    validateId3(id);
-    return join44(this.basePath, id, "config.json");
+  db;
+  constructor(db) {
+    this.db = db || getDb17();
   }
   async initialize() {
-    await mkdir10(this.basePath, { recursive: true });
-    const index = await this.readIndex();
-    for (const id of index.people) {
-      const person = await this.readPerson(id);
-      if (person) {
-        this.people.set(id, person);
-      }
+    const rows = this.db.query("SELECT * FROM people").all();
+    for (const row of rows) {
+      try {
+        const person = rowToPerson(row);
+        this.people.set(person.id, person);
+      } catch {}
     }
-    this.activeId = await this.readActive();
+    const activeRow = this.db.query("SELECT person_id FROM people_active WHERE key = 'active'").get();
+    this.activeId = activeRow?.person_id || null;
   }
   async create(name2, email2, avatar) {
     const id = `person_${generateId().slice(0, 12)}`;
@@ -199729,9 +199823,8 @@ class PeopleStore {
       createdAt: now2,
       updatedAt: now2
     };
-    await this.persist(person);
+    this.persistPerson(person);
     this.people.set(id, person);
-    await this.appendToIndex(id);
     return person;
   }
   async update(id, updates) {
@@ -199746,18 +199839,13 @@ class PeopleStore {
       createdAt: existing.createdAt,
       updatedAt: new Date().toISOString()
     };
-    await this.persist(updated);
+    this.persistPerson(updated);
     this.people.set(id, updated);
     return updated;
   }
   async delete(id) {
-    validateId3(id);
-    const dir = join44(this.basePath, id);
-    if (existsSync31(dir)) {
-      await rm5(dir, { recursive: true });
-    }
+    this.db.prepare("DELETE FROM people WHERE id = ?").run(id);
     this.people.delete(id);
-    await this.removeFromIndex(id);
     if (this.activeId === id) {
       await this.setActive(null);
     }
@@ -199802,66 +199890,28 @@ class PeopleStore {
       }
     }
     this.activeId = id;
-    try {
-      await writeFile9(this.activePath, JSON.stringify({ personId: id }, null, 2));
-    } catch {}
-  }
-  async readIndex() {
-    try {
-      if (existsSync31(this.indexPath)) {
-        const data = await readFile11(this.indexPath, "utf-8");
-        return JSON.parse(data);
-      }
-    } catch {}
-    return { people: [] };
-  }
-  async writeIndex(index) {
-    await writeFile9(this.indexPath, JSON.stringify(index, null, 2));
-  }
-  async appendToIndex(id) {
-    const index = await this.readIndex();
-    if (!index.people.includes(id)) {
-      index.people.push(id);
-      await this.writeIndex(index);
+    if (id) {
+      this.db.prepare("INSERT OR REPLACE INTO people_active (key, person_id) VALUES ('active', ?)").run(id);
+    } else {
+      this.db.prepare("DELETE FROM people_active WHERE key = 'active'").run();
     }
   }
-  async removeFromIndex(id) {
-    const index = await this.readIndex();
-    index.people = index.people.filter((p5) => p5 !== id);
-    await this.writeIndex(index);
-  }
-  async readActive() {
-    try {
-      if (existsSync31(this.activePath)) {
-        const data = await readFile11(this.activePath, "utf-8");
-        const parsed = JSON.parse(data);
-        return parsed.personId;
-      }
-    } catch {}
-    return null;
-  }
-  async readPerson(id) {
-    try {
-      validateId3(id);
-      const configPath = this.personConfigPath(id);
-      if (existsSync31(configPath)) {
-        const data = await readFile11(configPath, "utf-8");
-        return JSON.parse(data);
-      }
-    } catch {}
-    return null;
-  }
-  async persist(person) {
-    const dir = join44(this.basePath, person.id);
-    await mkdir10(dir, { recursive: true });
-    await writeFile9(this.personConfigPath(person.id), JSON.stringify(person, null, 2));
+  persistPerson(person) {
+    const nowMs = new Date(person.updatedAt).getTime();
+    const createdMs = new Date(person.createdAt).getTime();
+    const metadata = {};
+    if (person.status !== "active")
+      metadata.status = person.status;
+    if (person.defaultIdentityId)
+      metadata.defaultIdentityId = person.defaultIdentityId;
+    const metadataStr = Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : null;
+    this.db.prepare(`INSERT OR REPLACE INTO people (id, name, email, phone, role, notes, avatar_url, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(person.id, person.name, person.email || null, null, null, null, person.avatar || null, metadataStr, createdMs, nowMs);
   }
 }
-var SAFE_ID_PATTERN6;
 var init_store8 = __esm(async () => {
   init_src2();
-  await init_config();
-  SAFE_ID_PATTERN6 = /^[a-zA-Z0-9_-]+$/;
+  await init_database();
 });
 
 // packages/core/src/people/manager.ts
@@ -204403,7 +204453,7 @@ var init_contacts = __esm(async () => {
 });
 
 // packages/core/src/sessions/store.ts
-function rowToSession(row) {
+function rowToSession2(row) {
   return {
     id: row.id,
     cwd: row.cwd,
@@ -204429,7 +204479,7 @@ class SessionStore {
   load(id) {
     try {
       const row = this.db.query("SELECT * FROM persisted_sessions WHERE id = ?").get(id);
-      return row ? rowToSession(row) : null;
+      return row ? rowToSession2(row) : null;
     } catch {
       return null;
     }
@@ -204437,7 +204487,7 @@ class SessionStore {
   list() {
     try {
       const rows = this.db.query("SELECT * FROM persisted_sessions ORDER BY updated_at DESC").all();
-      return rows.map(rowToSession);
+      return rows.map(rowToSession2);
     } catch {
       return [];
     }
@@ -204450,7 +204500,7 @@ class SessionStore {
   listRecoverable() {
     try {
       const rows = this.db.query(`SELECT * FROM persisted_sessions WHERE status != 'closed' ORDER BY updated_at DESC`).all();
-      return rows.map(rowToSession);
+      return rows.map(rowToSession2);
     } catch {
       return [];
     }
@@ -205032,9 +205082,9 @@ var init_tools15 = __esm(() => {
 
 // packages/core/src/sessions/index.ts
 var init_sessions3 = __esm(async () => {
-  init_verification();
   init_tools15();
   await __promiseAll([
+    init_verification(),
     init_store12(),
     init_registry3()
   ]);
@@ -206112,7 +206162,7 @@ function createSelfAwarenessToolExecutors(context) {
     workspace_map: async (input) => {
       const { readdir: readdir2, stat: stat5, access } = await import("fs/promises");
       const { execSync } = await import("child_process");
-      const { join: join45, basename: basename7 } = await import("path");
+      const { join: join38, basename: basename7 } = await import("path");
       const depth = input.depth ?? 3;
       const includeGitStatus = input.include_git_status !== false;
       const includeRecentFiles = input.include_recent_files !== false;
@@ -206158,7 +206208,7 @@ function createSelfAwarenessToolExecutors(context) {
               break;
             }
             if (entry.isDirectory()) {
-              const children2 = await buildTree(join45(dir, entry.name), currentDepth + 1);
+              const children2 = await buildTree(join38(dir, entry.name), currentDepth + 1);
               nodes.push({
                 name: entry.name,
                 type: "directory",
@@ -206184,7 +206234,7 @@ function createSelfAwarenessToolExecutors(context) {
       };
       if (includeGitStatus) {
         try {
-          await access(join45(cwd2, ".git"));
+          await access(join38(cwd2, ".git"));
           gitStatus.isRepo = true;
           try {
             const branch = execSync("git branch --show-current", { cwd: cwd2, encoding: "utf-8" }).trim();
@@ -206215,7 +206265,7 @@ function createSelfAwarenessToolExecutors(context) {
             for (const entry of entries) {
               if (shouldIgnore(entry.name))
                 continue;
-              const fullPath = join45(dir, entry.name);
+              const fullPath = join38(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isFile()) {
                 try {
@@ -206249,12 +206299,12 @@ function createSelfAwarenessToolExecutors(context) {
       let projectName = basename7(cwd2);
       for (const indicator of projectIndicators) {
         try {
-          await access(join45(cwd2, indicator.file));
+          await access(join38(cwd2, indicator.file));
           projectType = indicator.type;
           if (indicator.file === "package.json") {
             try {
-              const { readFile: readFile12 } = await import("fs/promises");
-              const pkg = JSON.parse(await readFile12(join45(cwd2, indicator.file), "utf-8"));
+              const { readFile: readFile9 } = await import("fs/promises");
+              const pkg = JSON.parse(await readFile9(join38(cwd2, indicator.file), "utf-8"));
               projectName = pkg.name || projectName;
             } catch {}
           }
@@ -211036,7 +211086,6 @@ var init_capabilities2 = __esm(async () => {
 });
 
 // packages/core/src/agent/loop.ts
-import { join as join46 } from "path";
 function parseErrorCode(message) {
   const index = message.indexOf(":");
   if (index === -1)
@@ -211068,7 +211117,6 @@ var init_loop = __esm(async () => {
   init_limits();
   init_llm_response();
   init_manager4();
-  init_identity2();
   init_self_awareness();
   init_memory2();
   init_agents();
@@ -211078,8 +211126,6 @@ var init_loop = __esm(async () => {
   init_swarm2();
   init_coordinator();
   init_subagent_manager();
-  init_budget();
-  init_registry2();
   await __promiseAll([
     init_registry(),
     init_connector(),
@@ -211108,6 +211154,7 @@ var init_loop = __esm(async () => {
     init_energy2(),
     init_store3(),
     init_auto_refresh(),
+    init_identity2(),
     init_inbox(),
     init_wallet(),
     init_secrets(),
@@ -211123,7 +211170,9 @@ var init_loop = __esm(async () => {
     init_projects(),
     init_tasks2(),
     init_memory3(),
+    init_budget(),
     init_guardrails(),
+    init_registry2(),
     init_capabilities2()
   ]);
   AssistantLoop = class AssistantLoop {
@@ -213752,8 +213801,8 @@ Current state: ${voiceState.enabled ? "enabled" : "disabled"}, STT: ${voiceState
         return null;
       const intervalMs = Math.max(1000, config2.heartbeat?.intervalMs ?? 15000);
       const staleThresholdMs = Math.max(intervalMs * 2, config2.heartbeat?.staleThresholdMs ?? 120000);
-      const persistPath = config2.heartbeat?.persistPath ?? join46(this.storageDir, "heartbeats", `${this.sessionId}.json`);
-      const historyPath = config2.heartbeat?.historyPath ?? join46(this.storageDir, "heartbeats", "runs", `${this.sessionId}.jsonl`);
+      const persistPath = config2.heartbeat?.persistPath ?? `<db>:heartbeat_state:${this.sessionId}`;
+      const historyPath = config2.heartbeat?.historyPath ?? `<db>:heartbeat_history:${this.sessionId}`;
       return {
         intervalMs,
         staleThresholdMs,
@@ -214134,9 +214183,9 @@ class StatsTracker {
 }
 
 // packages/core/src/tools/connector-index.ts
-import { join as join47, dirname as dirname18 } from "path";
-import { homedir as homedir21 } from "os";
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, writeFileSync as writeFileSync16, readFileSync as readFileSync20 } from "fs";
+import { join as join38, dirname as dirname15 } from "path";
+import { homedir as homedir19 } from "os";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, writeFileSync as writeFileSync11, readFileSync as readFileSync14 } from "fs";
 var TAG_KEYWORDS, INDEX_VERSION = 1, INDEX_TTL_MS, ConnectorIndex;
 var init_connector_index = __esm(() => {
   TAG_KEYWORDS = {
@@ -214170,18 +214219,18 @@ var init_connector_index = __esm(() => {
     }
     getHomeDir() {
       const envHome = process.env.HOME || process.env.USERPROFILE;
-      return envHome && envHome.trim().length > 0 ? envHome : homedir21();
+      return envHome && envHome.trim().length > 0 ? envHome : homedir19();
     }
     getCachePath() {
-      return join47(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
+      return join38(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
     }
     loadDiskCache() {
       ConnectorIndex.indexLoaded = true;
       try {
         const cachePath = this.getCachePath();
-        if (!existsSync32(cachePath))
+        if (!existsSync26(cachePath))
           return;
-        const data = JSON.parse(readFileSync20(cachePath, "utf-8"));
+        const data = JSON.parse(readFileSync14(cachePath, "utf-8"));
         if (data.version !== INDEX_VERSION)
           return;
         if (Date.now() - data.timestamp > INDEX_TTL_MS)
@@ -214195,16 +214244,16 @@ var init_connector_index = __esm(() => {
     saveDiskCache() {
       try {
         const cachePath = this.getCachePath();
-        const cacheDir = dirname18(cachePath);
-        if (!existsSync32(cacheDir)) {
-          mkdirSync19(cacheDir, { recursive: true });
+        const cacheDir = dirname15(cachePath);
+        if (!existsSync26(cacheDir)) {
+          mkdirSync15(cacheDir, { recursive: true });
         }
         const data = {
           version: INDEX_VERSION,
           timestamp: Date.now(),
           entries: Object.fromEntries(this.entries)
         };
-        writeFileSync16(cachePath, JSON.stringify(data));
+        writeFileSync11(cachePath, JSON.stringify(data));
         ConnectorIndex.indexCache = new Map(this.entries);
       } catch {}
     }
@@ -214776,17 +214825,17 @@ var init_interviews = __esm(async () => {
 });
 
 // packages/core/src/memory/sessions.ts
-import { join as join48, dirname as dirname19 } from "path";
-import { existsSync as existsSync33, mkdirSync as mkdirSync20 } from "fs";
+import { join as join40, dirname as dirname16 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16 } from "fs";
 
 class SessionManager {
   db;
   constructor(dbPath, assistantId) {
     const baseDir = getConfigDir();
-    const path4 = dbPath || (assistantId ? join48(baseDir, "assistants", assistantId, "memory.db") : join48(baseDir, "memory.db"));
-    const dir = dirname19(path4);
-    if (!existsSync33(dir)) {
-      mkdirSync20(dir, { recursive: true });
+    const path4 = dbPath || (assistantId ? join40(baseDir, "assistants", assistantId, "memory.db") : join40(baseDir, "memory.db"));
+    const dir = dirname16(path4);
+    if (!existsSync28(dir)) {
+      mkdirSync16(dir, { recursive: true });
     }
     const runtime = getRuntime();
     this.db = runtime.openDatabase(path4);
@@ -214899,9 +214948,9 @@ var init_sessions4 = __esm(async () => {
   ]);
 });
 // packages/core/src/migration/validators.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 function assertNoExistingTarget(targetPath) {
-  if (existsSync34(targetPath)) {
+  if (existsSync29(targetPath)) {
     throw new Error(`Target already exists at ${targetPath}`);
   }
 }
@@ -214919,7 +214968,7 @@ var init_scheduler2 = __esm(async () => {
 });
 
 // packages/core/src/history/storage.ts
-function getDb10() {
+function getDb18() {
   return getDatabase();
 }
 function getHistoryPath() {
@@ -214927,7 +214976,7 @@ function getHistoryPath() {
 }
 async function loadHistory() {
   try {
-    const rows = getDb10().query(`SELECT command FROM command_history ORDER BY created_at ASC, id ASC LIMIT ${MAX_HISTORY_SIZE}`).all();
+    const rows = getDb18().query(`SELECT command FROM command_history ORDER BY created_at ASC, id ASC LIMIT ${MAX_HISTORY_SIZE}`).all();
     return rows.map((r6) => r6.command);
   } catch {
     return [];
@@ -214935,7 +214984,7 @@ async function loadHistory() {
 }
 async function saveHistory(history) {
   try {
-    const conn = getDb10();
+    const conn = getDb18();
     const trimmed = history.slice(-MAX_HISTORY_SIZE);
     conn.transaction(() => {
       conn.exec("DELETE FROM command_history");
@@ -214951,7 +215000,7 @@ async function appendToHistory(command) {
   if (!command.trim())
     return;
   try {
-    const conn = getDb10();
+    const conn = getDb18();
     conn.prepare("INSERT INTO command_history (command, created_at) VALUES (?, ?)").run(command, Date.now());
     const countRow = conn.query("SELECT COUNT(*) as cnt FROM command_history").get();
     if (countRow && countRow.cnt > MAX_HISTORY_SIZE) {
@@ -215778,12 +215827,10 @@ var init_src3 = __esm(async () => {
   init_loader();
   init_native();
   init_scope_context();
-  init_verification();
   init_injector();
   init_types11();
   init_memory2();
   init_voice();
-  init_budget();
   init_manager4();
   init_player();
   init_recorder();
@@ -215820,10 +215867,12 @@ var init_src3 = __esm(async () => {
     init_store2(),
     init_tester(),
     init_logger3(),
+    init_verification(),
     init_interviews(),
     init_store13(),
     init_sessions4(),
     init_global_memory(),
+    init_budget(),
     init_config(),
     init_client4(),
     init_registry3(),
@@ -233654,14 +233703,14 @@ var require_filesystem = __commonJS((exports, module) => {
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync22 = (path4) => {
+  var readFileSync16 = (path4) => {
     const fd = fs7.openSync(path4, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
     const bytesRead = fs7.readSync(fd, buffer, 0, MAX_LENGTH, 0);
     fs7.close(fd, () => {});
     return buffer.subarray(0, bytesRead);
   };
-  var readFile12 = (path4) => new Promise((resolve6, reject) => {
+  var readFile9 = (path4) => new Promise((resolve6, reject) => {
     fs7.open(path4, "r", (err, fd) => {
       if (err) {
         reject(err);
@@ -233677,8 +233726,8 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync22,
-    readFile: readFile12
+    readFileSync: readFileSync16,
+    readFile: readFile9
   };
 });
 
@@ -233720,7 +233769,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux: isLinux2, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile: readFile12, readFileSync: readFileSync22 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile: readFile9, readFileSync: readFileSync16 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -233800,7 +233849,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = await readFile12(LDD_PATH);
+      const lddContent = await readFile9(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e6) {}
     return cachedFamilyFilesystem;
@@ -233811,7 +233860,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync22(LDD_PATH);
+      const lddContent = readFileSync16(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e6) {}
     return cachedFamilyFilesystem;
@@ -233822,7 +233871,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = await readFile12(SELF_PATH);
+      const selfContent = await readFile9(SELF_PATH);
       const path4 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path4);
     } catch (e6) {}
@@ -233834,7 +233883,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = readFileSync22(SELF_PATH);
+      const selfContent = readFileSync16(SELF_PATH);
       const path4 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path4);
     } catch (e6) {}
@@ -233882,7 +233931,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = await readFile12(LDD_PATH);
+      const lddContent = await readFile9(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -233896,7 +233945,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync22(LDD_PATH);
+      const lddContent = readFileSync16(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -241851,13 +241900,13 @@ async function appPath(appName) {
     throw new TypeError("Please supply an app name or bundle identifier");
   }
   try {
-    const { stdout } = await import_execa.default("./main", [appName], { cwd: dirname20 });
+    const { stdout } = await import_execa.default("./main", [appName], { cwd: dirname17 });
     return stdout;
   } catch (error4) {
     throw improveError(error4);
   }
 }
-var import_execa, dirname20, improveError = (error4) => {
+var import_execa, dirname17, improveError = (error4) => {
   if (error4.exitCode === 2) {
     error4.message = "Couldn't find the app";
   }
@@ -241865,7 +241914,7 @@ var import_execa, dirname20, improveError = (error4) => {
 };
 var init_app_path = __esm(() => {
   import_execa = __toESM(require_execa(), 1);
-  dirname20 = path4.dirname(fileURLToPath5(import.meta.url));
+  dirname17 = path4.dirname(fileURLToPath5(import.meta.url));
   appPath.sync = (appName) => {
     if (process.platform !== "darwin") {
       throw new Error("macOS only");
@@ -241874,7 +241923,7 @@ var init_app_path = __esm(() => {
       throw new TypeError("Please supply an app name or bundle identifier");
     }
     try {
-      return import_execa.default.sync("./main", [appName], { cwd: dirname20 }).stdout;
+      return import_execa.default.sync("./main", [appName], { cwd: dirname17 }).stdout;
     } catch (error4) {
       throw improveError(error4);
     }
@@ -255193,8 +255242,8 @@ await __promiseAll([
 ]);
 var import_react84 = __toESM(require_react(), 1);
 import { spawn as spawn6 } from "child_process";
-import { join as join50 } from "path";
-import { homedir as homedir22 } from "os";
+import { join as join43 } from "path";
+import { homedir as homedir20 } from "os";
 
 // packages/terminal/src/components/Input.tsx
 await init_build2();
@@ -285892,8 +285941,8 @@ await init_src3();
 // packages/terminal/src/lib/budgets.ts
 init_src2();
 await init_src3();
-import { join as join49 } from "path";
-import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
+import { join as join41 } from "path";
+import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
 var PROFILES_FILE = "budgets.json";
 var SESSION_MAP_FILE = "budget-sessions.json";
 var DEFAULT_PROFILE_ID = "default";
@@ -285901,22 +285950,22 @@ function cloneConfig2(config2) {
   return JSON.parse(JSON.stringify(config2 || DEFAULT_BUDGET_CONFIG));
 }
 async function ensureDir(baseDir) {
-  await mkdir11(baseDir, { recursive: true });
+  await mkdir9(baseDir, { recursive: true });
 }
 async function readJsonFile(path6) {
   try {
-    const raw = await readFile12(path6, "utf-8");
+    const raw = await readFile9(path6, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function writeJsonFile(path6, data) {
-  await writeFile10(path6, JSON.stringify(data, null, 2), "utf-8");
+  await writeFile8(path6, JSON.stringify(data, null, 2), "utf-8");
 }
 async function loadBudgetProfiles(baseDir, seedConfig) {
   await ensureDir(baseDir);
-  const path6 = join49(baseDir, PROFILES_FILE);
+  const path6 = join41(baseDir, PROFILES_FILE);
   const data = await readJsonFile(path6);
   const profiles = Array.isArray(data?.profiles) ? data.profiles : [];
   if (profiles.length === 0) {
@@ -285936,7 +285985,7 @@ async function loadBudgetProfiles(baseDir, seedConfig) {
 }
 async function saveBudgetProfiles(baseDir, profiles) {
   await ensureDir(baseDir);
-  const path6 = join49(baseDir, PROFILES_FILE);
+  const path6 = join41(baseDir, PROFILES_FILE);
   await writeJsonFile(path6, { profiles });
 }
 async function createBudgetProfile(baseDir, name2, config2, description) {
@@ -285974,13 +286023,13 @@ async function deleteBudgetProfile(baseDir, id) {
 }
 async function loadSessionBudgetMap(baseDir) {
   await ensureDir(baseDir);
-  const path6 = join49(baseDir, SESSION_MAP_FILE);
+  const path6 = join41(baseDir, SESSION_MAP_FILE);
   const data = await readJsonFile(path6);
   return data || {};
 }
 async function saveSessionBudgetMap(baseDir, map2) {
   await ensureDir(baseDir);
-  const path6 = join49(baseDir, SESSION_MAP_FILE);
+  const path6 = join41(baseDir, SESSION_MAP_FILE);
   await writeJsonFile(path6, map2);
 }
 
@@ -287491,12 +287540,12 @@ function App2({ cwd: cwd3, version: version5 }) {
     try {
       const config2 = await loadConfig(cwd3, workspaceBaseDir);
       setCurrentConfig(config2);
-      const { readFile: readFile13, access } = await import("fs/promises");
+      const { readFile: readFile10, access } = await import("fs/promises");
       const configBaseDir = workspaceBaseDir || getConfigDir();
       const userPath = `${configBaseDir}/config.json`;
       try {
         await access(userPath);
-        const content = await readFile13(userPath, "utf-8");
+        const content = await readFile10(userPath, "utf-8");
         setUserConfig(JSON.parse(content));
       } catch {
         setUserConfig(null);
@@ -287504,7 +287553,7 @@ function App2({ cwd: cwd3, version: version5 }) {
       const projectPath = `${getProjectConfigDir(cwd3)}/config.json`;
       try {
         await access(projectPath);
-        const content = await readFile13(projectPath, "utf-8");
+        const content = await readFile10(projectPath, "utf-8");
         setProjectConfig(JSON.parse(content));
       } catch {
         setProjectConfig(null);
@@ -287512,7 +287561,7 @@ function App2({ cwd: cwd3, version: version5 }) {
       const localPath = `${getProjectConfigDir(cwd3)}/config.local.json`;
       try {
         await access(localPath);
-        const content = await readFile13(localPath, "utf-8");
+        const content = await readFile10(localPath, "utf-8");
         setLocalConfig(JSON.parse(content));
       } catch {
         setLocalConfig(null);
@@ -287599,46 +287648,46 @@ function App2({ cwd: cwd3, version: version5 }) {
     });
   }, [recoverableSessions, createSessionFromRecovery, workspaceBaseDir]);
   const handleOnboardingComplete = import_react84.useCallback(async (result) => {
-    const { existsSync: existsSync36, mkdirSync: mkdirSync21, readFileSync: readFileSync22, writeFileSync: writeFileSync17, appendFileSync: appendFileSync5 } = await import("fs");
-    const secretsPath = join50(homedir22(), ".secrets");
+    const { existsSync: existsSync27, mkdirSync: mkdirSync17, readFileSync: readFileSync16, writeFileSync: writeFileSync12, appendFileSync: appendFileSync5 } = await import("fs");
+    const secretsPath = join43(homedir20(), ".secrets");
     const providerInfo = getProviderInfo(result.provider);
     const envName = providerInfo?.apiKeyEnv || "ANTHROPIC_API_KEY";
     const keyExport = `export ${envName}="${result.apiKey}"`;
-    if (existsSync36(secretsPath)) {
-      const content = readFileSync22(secretsPath, "utf-8");
+    if (existsSync27(secretsPath)) {
+      const content = readFileSync16(secretsPath, "utf-8");
       if (content.includes(envName)) {
         const updated = content.replace(new RegExp(`^export ${envName}=.*$`, "m"), keyExport);
-        writeFileSync17(secretsPath, updated, "utf-8");
+        writeFileSync12(secretsPath, updated, "utf-8");
       } else {
         appendFileSync5(secretsPath, `
 ` + keyExport + `
 `, "utf-8");
       }
     } else {
-      writeFileSync17(secretsPath, keyExport + `
+      writeFileSync12(secretsPath, keyExport + `
 `, { mode: 384 });
     }
     for (const [name2, key] of Object.entries(result.connectorKeys)) {
       const envName2 = `${name2.toUpperCase()}_API_KEY`;
       const connKeyExport = `export ${envName2}="${key}"`;
-      const content = readFileSync22(secretsPath, "utf-8");
+      const content = readFileSync16(secretsPath, "utf-8");
       if (content.includes(envName2)) {
         const updated = content.replace(new RegExp(`^export ${envName2}=.*$`, "m"), connKeyExport);
-        writeFileSync17(secretsPath, updated, "utf-8");
+        writeFileSync12(secretsPath, updated, "utf-8");
       } else {
         appendFileSync5(secretsPath, connKeyExport + `
 `, "utf-8");
       }
     }
     const configDir = workspaceBaseDir || getConfigDir();
-    if (!existsSync36(configDir)) {
-      mkdirSync21(configDir, { recursive: true });
+    if (!existsSync27(configDir)) {
+      mkdirSync17(configDir, { recursive: true });
     }
-    const configPath = join50(configDir, "config.json");
+    const configPath = join43(configDir, "config.json");
     let existingConfig = {};
-    if (existsSync36(configPath)) {
+    if (existsSync27(configPath)) {
       try {
-        existingConfig = JSON.parse(readFileSync22(configPath, "utf-8"));
+        existingConfig = JSON.parse(readFileSync16(configPath, "utf-8"));
       } catch {}
     }
     const newConfig = {
@@ -287651,7 +287700,7 @@ function App2({ cwd: cwd3, version: version5 }) {
       },
       connectors: result.connectors.length > 0 ? result.connectors : undefined
     };
-    writeFileSync17(configPath, JSON.stringify(newConfig, null, 2), "utf-8");
+    writeFileSync12(configPath, JSON.stringify(newConfig, null, 2), "utf-8");
     await loadConfigFiles();
     process.env[envName] = result.apiKey;
     setShowOnboardingPanel(false);
@@ -287680,14 +287729,14 @@ function App2({ cwd: cwd3, version: version5 }) {
           return;
         }
         try {
-          const configPath = join50(workspaceBaseDir || getConfigDir(), "config.json");
-          const { existsSync: existsSync36, readFileSync: readFileSync22 } = await import("fs");
+          const configPath = join43(workspaceBaseDir || getConfigDir(), "config.json");
+          const { existsSync: existsSync27, readFileSync: readFileSync16 } = await import("fs");
           let needsOnboarding = false;
-          if (!existsSync36(configPath)) {
+          if (!existsSync27(configPath)) {
             needsOnboarding = true;
           } else {
             try {
-              const raw = readFileSync22(configPath, "utf-8");
+              const raw = readFileSync16(configPath, "utf-8");
               const parsed = JSON.parse(raw);
               if (!parsed.onboardingCompleted) {
                 needsOnboarding = true;
@@ -289849,8 +289898,8 @@ When done, report the result.`);
   }
   if (showConfigPanel && currentConfig) {
     const handleConfigSave = async (location, updates) => {
-      const { writeFile: writeFile11, mkdir: mkdir12 } = await import("fs/promises");
-      const { dirname: dirname21 } = await import("path");
+      const { writeFile: writeFile9, mkdir: mkdir10 } = await import("fs/promises");
+      const { dirname: dirname18 } = await import("path");
       let configPath;
       let existingConfig;
       switch (location) {
@@ -289868,8 +289917,8 @@ When done, report the result.`);
           break;
       }
       const newConfig = deepMerge(existingConfig || {}, updates);
-      await mkdir12(dirname21(configPath), { recursive: true });
-      await writeFile11(configPath, JSON.stringify(newConfig, null, 2));
+      await mkdir10(dirname18(configPath), { recursive: true });
+      await writeFile9(configPath, JSON.stringify(newConfig, null, 2));
       await loadConfigFiles();
     };
     return /* @__PURE__ */ jsx_dev_runtime51.jsxDEV(Box_default, {
@@ -290800,7 +290849,7 @@ Interactive Mode:
 // packages/terminal/src/index.tsx
 var jsx_dev_runtime52 = __toESM(require_jsx_dev_runtime(), 1);
 setRuntime(bunRuntime);
-var VERSION4 = "1.1.51";
+var VERSION4 = "1.1.53";
 var SYNC_START = "\x1B[?2026h";
 var SYNC_END = "\x1B[?2026l";
 function enableSynchronizedOutput() {
@@ -290919,4 +290968,4 @@ export {
   main
 };
 
-//# debugId=AD7A84E56D81A61E64756E2164756E21
+//# debugId=2C44C31995AA98B064756E2164756E21