@hasna/recordings 0.1.37 → 0.2.0

package/dist/server/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -19,7 +18,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/version.ts
-var VERSION = "0.1.37";
+var VERSION = "0.2.0";
 
 // src/db/remote-storage.ts
 import pg from "pg";
@@ -436,6 +435,20 @@ async function listAgents(pg2) {
   const rows = await pg2.all("SELECT * FROM agents ORDER BY last_seen_at DESC");
   return rows.map(parseAgent);
 }
+async function heartbeatAgent(pg2, idOrName) {
+  const agent = await getAgent(pg2, idOrName);
+  if (!agent)
+    return null;
+  await pg2.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", new Date().toISOString(), agent.id);
+  return getAgent(pg2, agent.id);
+}
+async function setAgentFocus(pg2, idOrName, projectId) {
+  const agent = await getAgent(pg2, idOrName);
+  if (!agent)
+    return null;
+  await pg2.run("UPDATE agents SET active_project_id = ?, last_seen_at = ? WHERE id = ?", projectId, new Date().toISOString(), agent.id);
+  return getAgent(pg2, agent.id);
+}
 async function registerProject(pg2, name, path, description) {
   if (!name || !path)
     throw new Error("name and path are required");
@@ -460,6 +473,13 @@ async function listProjects(pg2) {
   const rows = await pg2.all("SELECT * FROM projects ORDER BY updated_at DESC");
   return rows.map(parseProject);
 }
+async function saveFeedback(pg2, input) {
+  if (typeof input.message !== "string" || !input.message.trim()) {
+    throw new Error("message is required");
+  }
+  await pg2.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", input.message, input.email || null, input.category || "general", input.version || null);
+  return { saved: true };
+}
 
 // src/server/v1.ts
 function json(body, status = 200) {
@@ -504,6 +524,7 @@ async function handleV1Request(req, url) {
   const segments = path.split("/").filter(Boolean);
   const resource = segments[1];
   const id = segments[2] ? decodeURIComponent(segments[2]) : undefined;
+  const action = segments[3] ? decodeURIComponent(segments[3]) : undefined;
   try {
     if (resource === "recordings") {
       if (!id) {
@@ -561,6 +582,21 @@ async function handleV1Request(req, url) {
         }
         return error(405, `method ${method} not allowed on /v1/agents`);
       }
+      if (action === "heartbeat") {
+        if (method !== "POST")
+          return error(405, `method ${method} not allowed on /v1/agents/:id/heartbeat`);
+        const agent = await heartbeatAgent(pg2, id);
+        return agent ? json({ agent }) : error(404, "agent not found");
+      }
+      if (action === "focus") {
+        if (method !== "POST")
+          return error(405, `method ${method} not allowed on /v1/agents/:id/focus`);
+        const body = await readJson(req);
+        const agent = await setAgentFocus(pg2, id, body?.project_id ?? null);
+        return agent ? json({ agent }) : error(404, "agent not found");
+      }
+      if (action)
+        return error(404, `unknown agent action: ${action}`);
       if (method === "GET") {
         const agent = await getAgent(pg2, id);
         return agent ? json({ agent }) : error(404, "agent not found");
@@ -589,6 +625,23 @@ async function handleV1Request(req, url) {
       }
       return error(405, `method ${method} not allowed on /v1/projects/:id`);
     }
+    if (resource === "feedback") {
+      if (id)
+        return error(404, "feedback has no item routes");
+      if (method === "POST") {
+        const body = await readJson(req);
+        if (!body || typeof body.message !== "string" || !body.message.trim()) {
+          return error(400, "message is required");
+        }
+        return json(await saveFeedback(pg2, {
+          message: body.message,
+          email: body.email ?? null,
+          category: body.category ?? null,
+          version: body.version ?? null
+        }), 201);
+      }
+      return error(405, `method ${method} not allowed on /v1/feedback`);
+    }
     return error(404, `unknown /v1 resource: ${resource ?? ""}`);
   } catch (e) {
     return error(500, e.message);
@@ -5265,15 +5318,6 @@ function ensureColumn(db, table, column, definition) {
   }
   db.run(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
-function getAdapter() {
-  if (!_adapter) {
-    getDatabase();
-  }
-  return _adapter;
-}
-function getDbPath() {
-  return loadConfig().db_path;
-}
 function shortUuid2() {
   return crypto.randomUUID().slice(0, 8);
 }
@@ -5527,7 +5571,7 @@ function listAgents2(db) {
   const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
   return rows.map(parseAgent2);
 }
-function heartbeatAgent(idOrName, db) {
+function heartbeatAgent2(idOrName, db) {
   const d = db || getDatabase();
   const agent = getAgent2(idOrName, d);
   if (!agent)
@@ -5535,7 +5579,7 @@ function heartbeatAgent(idOrName, db) {
   d.query("UPDATE agents SET last_seen_at = ? WHERE id = ?").run(new Date().toISOString(), agent.id);
   return getAgent2(agent.id, d);
 }
-function setAgentFocus(idOrName, projectId, db) {
+function setAgentFocus2(idOrName, projectId, db) {
   const d = db || getDatabase();
   const agent = getAgent2(idOrName, d);
   if (!agent)
@@ -5587,6 +5631,478 @@ var init_projects = __esm(() => {
   init_database();
 });
 
+// src/db/feedback.ts
+function saveFeedback2(input) {
+  const db = getDatabase();
+  db.query("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)").run(input.message, input.email ?? null, input.category ?? "general", input.version ?? VERSION);
+}
+var init_feedback = __esm(() => {
+  init_database();
+});
+
+// src/http/client.ts
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+function normalizeMode(value) {
+  const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+  if (normalized === "local")
+    return { mode: "local", deprecatedAlias: null };
+  if (normalized === "cloud")
+    return { mode: "cloud", deprecatedAlias: null };
+  if (DEPRECATED_MODE_ALIASES.includes(normalized)) {
+    return { mode: "cloud", deprecatedAlias: normalized };
+  }
+  throw new Error(`Unknown storage mode: ${value}. Use local or cloud.`);
+}
+function defaultCloudBaseUrl(name) {
+  return `https://${name}.hasna.xyz`;
+}
+function envKeys(name) {
+  const token = envToken(name);
+  return {
+    modeKeys: [`HASNA_${token}_STORAGE_MODE`, `HASNA_${token}_MODE`, `${token}_STORAGE_MODE`, `${token}_MODE`],
+    apiUrlKeys: [`HASNA_${token}_API_URL`, `${token}_API_URL`],
+    apiKeyKeys: [`HASNA_${token}_API_KEY`, `${token}_API_KEY`]
+  };
+}
+function firstEnv(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+function toV1BaseUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("API URL must use http or https.");
+  }
+  let path = url.pathname.replace(/\/+$/, "");
+  if (path.endsWith("/v1"))
+    path = path.slice(0, -"/v1".length);
+  url.pathname = `${path}/v1`;
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveTransport(name, env = process.env) {
+  const keys = envKeys(name);
+  const modeHit = firstEnv(env, keys.modeKeys);
+  const urlHit = firstEnv(env, keys.apiUrlKeys);
+  const keyHit = firstEnv(env, keys.apiKeyKeys);
+  let mode = "local";
+  let deprecatedAlias = null;
+  let modeSource = "default";
+  if (modeHit) {
+    const normalized = normalizeMode(modeHit.value);
+    mode = normalized.mode;
+    deprecatedAlias = normalized.deprecatedAlias;
+    modeSource = modeHit.key;
+  } else if (urlHit && keyHit) {
+    mode = "cloud";
+    modeSource = "auto:api-url+api-key";
+  }
+  if (mode === "local") {
+    return { transport: "local", mode, deprecatedAlias, modeSource, baseUrl: null, apiKeyPresent: Boolean(keyHit), misconfigured: false, warning: null };
+  }
+  if (!keyHit) {
+    return {
+      transport: "local",
+      mode,
+      deprecatedAlias,
+      modeSource,
+      baseUrl: null,
+      apiKeyPresent: false,
+      misconfigured: true,
+      warning: `${modeSource}=cloud but no API key is set (${keys.apiKeyKeys[0]}). Refusing to route to cloud.`
+    };
+  }
+  const rawUrl = urlHit?.value ?? defaultCloudBaseUrl(name);
+  let baseUrl;
+  try {
+    baseUrl = toV1BaseUrl(rawUrl);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return { transport: "local", mode, deprecatedAlias, modeSource, baseUrl: null, apiKeyPresent: true, misconfigured: true, warning: `Invalid API URL: ${message}.` };
+  }
+  return { transport: "cloud-http", mode, deprecatedAlias, modeSource, baseUrl, apiKeyPresent: true, misconfigured: false, warning: null };
+}
+function appendQuery(path, query) {
+  if (!query)
+    return path;
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null || value === undefined)
+      continue;
+    if (Array.isArray(value))
+      for (const v of value)
+        params.append(key, String(v));
+    else
+      params.append(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${path}${path.includes("?") ? "&" : "?"}${qs}` : path;
+}
+function createHttpTransport(options) {
+  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const base = options.baseUrl.replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs ?? 30000;
+  const sleep = options.sleepImpl ?? defaultSleep;
+  async function once(method, rel, url, body, opts) {
+    const headers = {
+      "x-api-key": options.apiKey,
+      Authorization: `Bearer ${options.apiKey}`,
+      Accept: "application/json",
+      ...opts.headers ?? {}
+    };
+    if (opts.idempotencyKey)
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    const init = { method, headers };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    if (opts.signal) {
+      if (opts.signal.aborted)
+        controller.abort();
+      else
+        opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
+    init.signal = controller.signal;
+    let response;
+    try {
+      response = await fetchImpl(url, init);
+    } catch (error2) {
+      const err = error2 instanceof Error ? error2 : new Error(String(error2));
+      if (opts.signal?.aborted)
+        return { ok: false, retryable: false, error: err };
+      return { ok: false, retryable: true, error: err };
+    } finally {
+      clearTimeout(timer);
+      if (opts.signal)
+        opts.signal.removeEventListener("abort", onAbort);
+    }
+    const text = await response.text();
+    let parsed = undefined;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      return { ok: false, retryable: RETRY_STATUSES.has(response.status), error: new HasnaHttpError(method, rel, response.status, parsed) };
+    }
+    return { ok: true, value: parsed };
+  }
+  async function request(method, path, body, opts = {}) {
+    const upper = method.toUpperCase();
+    const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
+    const url = `${base}${rel}`;
+    const methodRetryable = IDEMPOTENT.has(upper) || Boolean(opts.idempotencyKey);
+    const maxRetries = opts.retries ?? 2;
+    const maxAttempts = methodRetryable ? maxRetries + 1 : 1;
+    let last = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const result = await once(upper, rel, url, body, opts);
+      if (result.ok)
+        return result.value;
+      last = result;
+      const canRetry = methodRetryable && result.retryable && attempt < maxAttempts;
+      if (!canRetry)
+        break;
+      const backoff = Math.min(2000, 200 * 2 ** (attempt - 1));
+      const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
+      await sleep(backoff + jitter);
+    }
+    throw last.error;
+  }
+  return {
+    baseUrl: base,
+    request,
+    get: (path, opts) => request("GET", path, undefined, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    patch: (path, body, opts) => request("PATCH", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    del: (path, body, opts) => request("DELETE", path, body, opts)
+  };
+}
+function newIdempotencyKey() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID)
+    return g.crypto.randomUUID();
+  return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function extractItems(raw, extraKeys = []) {
+  if (Array.isArray(raw))
+    return raw;
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    for (const key of [...extraKeys, "items", "data", "results", "rows", "records"]) {
+      if (Array.isArray(obj[key]))
+        return obj[key];
+    }
+  }
+  return [];
+}
+function createStorageClient(name, transport) {
+  const rp = (r) => `/${r.replace(/^\/+|\/+$/g, "")}`;
+  const ep = (r, id) => `${rp(r)}/${encodeURIComponent(String(id))}`;
+  return {
+    name,
+    baseUrl: transport.baseUrl,
+    transport,
+    async list(resource, query) {
+      const raw = await transport.get(rp(resource), { query });
+      return { items: extractItems(raw, [resource]), raw };
+    },
+    async get(resource, id) {
+      try {
+        return await transport.get(ep(resource, id));
+      } catch (error2) {
+        if (error2 instanceof HasnaHttpError && error2.status === 404)
+          return null;
+        throw error2;
+      }
+    },
+    async create(resource, body, idempotencyKey) {
+      return transport.post(rp(resource), body, { idempotencyKey: idempotencyKey ?? newIdempotencyKey() });
+    },
+    async update(resource, id, patch, method = "PATCH") {
+      const call = method === "PUT" ? transport.put : transport.patch;
+      return call(ep(resource, id), patch);
+    },
+    async delete(resource, id) {
+      try {
+        await transport.del(ep(resource, id));
+      } catch (error2) {
+        if (error2 instanceof HasnaHttpError && error2.status === 404)
+          return;
+        throw error2;
+      }
+    }
+  };
+}
+function resolveStorageClient(name, env = process.env, fetchImpl) {
+  const resolution = resolveTransport(name, env);
+  if (resolution.misconfigured) {
+    throw new Error(resolution.warning ?? `Client for '${name}' is misconfigured for cloud mode.`);
+  }
+  if (resolution.transport === "local" || !resolution.baseUrl) {
+    return { transport: "local", client: null, resolution };
+  }
+  const keys = envKeys(name);
+  const apiKey = firstEnv(env, keys.apiKeyKeys)?.value;
+  if (!apiKey)
+    throw new Error(`Client for '${name}' resolved to cloud-http without an API key.`);
+  const transport = createHttpTransport({ name, baseUrl: resolution.baseUrl, apiKey, ...fetchImpl ? { fetchImpl } : {} });
+  return { transport: "cloud-http", client: createStorageClient(name, transport), resolution };
+}
+var DEPRECATED_MODE_ALIASES, HasnaHttpError, RETRY_STATUSES, IDEMPOTENT, defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var init_client = __esm(() => {
+  DEPRECATED_MODE_ALIASES = ["self_hosted", "remote", "hybrid"];
+  HasnaHttpError = class HasnaHttpError extends Error {
+    status;
+    method;
+    path;
+    body;
+    constructor(method, path, status, body) {
+      super(`Hasna request failed: ${method} ${path} -> ${status}`);
+      this.name = "HasnaHttpError";
+      this.status = status;
+      this.method = method;
+      this.path = path;
+      this.body = body;
+    }
+  };
+  RETRY_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
+  IDEMPOTENT = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+});
+
+// src/store.ts
+function listQuery(filter) {
+  if (!filter)
+    return {};
+  return {
+    agent_id: filter.agent_id,
+    project_id: filter.project_id,
+    session_id: filter.session_id,
+    processing_mode: filter.processing_mode,
+    search: filter.search,
+    since: filter.since,
+    until: filter.until,
+    limit: filter.limit,
+    offset: filter.offset
+  };
+}
+function unwrap(res, key) {
+  if (res && typeof res === "object" && key in res) {
+    return res[key];
+  }
+  return res;
+}
+function apiStore(client) {
+  return {
+    mode: "cloud-http",
+    baseUrl: client.baseUrl,
+    async createRecording(input) {
+      const res = await client.create("recordings", input);
+      return unwrap(res, "recording");
+    },
+    async getRecording(id) {
+      const res = await client.get("recordings", id);
+      return res ? unwrap(res, "recording") : null;
+    },
+    async listRecordings(filter) {
+      const { items } = await client.list("recordings", listQuery(filter));
+      return items;
+    },
+    async searchRecordings(query, filter) {
+      const { items } = await client.list("recordings", listQuery({ ...filter ?? {}, search: query }));
+      return items;
+    },
+    async deleteRecording(id) {
+      try {
+        const res = await client.transport.del(`/recordings/${encodeURIComponent(id)}`);
+        return res?.deleted !== false;
+      } catch (error2) {
+        if (error2 && typeof error2 === "object" && error2.status === 404)
+          return false;
+        throw error2;
+      }
+    },
+    async getRecordingStats() {
+      const res = await client.transport.get("/stats");
+      return {
+        total: res.total ?? 0,
+        raw: res.raw ?? 0,
+        enhanced: res.enhanced ?? 0,
+        total_duration_ms: res.total_duration_ms ?? 0,
+        by_model: res.by_model ?? {}
+      };
+    },
+    async registerAgent(name, description, role) {
+      const res = await client.create("agents", { name, description, role });
+      return unwrap(res, "agent");
+    },
+    async getAgent(idOrName) {
+      const res = await client.get("agents", idOrName);
+      return res ? unwrap(res, "agent") : null;
+    },
+    async listAgents() {
+      const { items } = await client.list("agents");
+      return items;
+    },
+    async heartbeatAgent(idOrName) {
+      try {
+        const res = await client.transport.post(`/agents/${encodeURIComponent(idOrName)}/heartbeat`);
+        return res ? unwrap(res, "agent") : null;
+      } catch (error2) {
+        if (error2 && typeof error2 === "object" && error2.status === 404)
+          return null;
+        throw error2;
+      }
+    },
+    async setAgentFocus(idOrName, projectId) {
+      try {
+        const res = await client.transport.post(`/agents/${encodeURIComponent(idOrName)}/focus`, { project_id: projectId });
+        return res ? unwrap(res, "agent") : null;
+      } catch (error2) {
+        if (error2 && typeof error2 === "object" && error2.status === 404)
+          return null;
+        throw error2;
+      }
+    },
+    async registerProject(name, path, description) {
+      const res = await client.create("projects", { name, path, description });
+      return unwrap(res, "project");
+    },
+    async getProject(idOrPath) {
+      const res = await client.get("projects", idOrPath);
+      return res ? unwrap(res, "project") : null;
+    },
+    async listProjects() {
+      const { items } = await client.list("projects");
+      return items;
+    },
+    async saveFeedback(input) {
+      await client.create("feedback", input);
+    }
+  };
+}
+function getStore(env = process.env) {
+  if (env === process.env && cached)
+    return cached;
+  const resolved = resolveStorageClient(APP, env);
+  const store = resolved.transport === "cloud-http" ? apiStore(resolved.client) : localStore;
+  if (env === process.env)
+    cached = store;
+  return store;
+}
+var APP = "recordings", localStore, cached = null;
+var init_store = __esm(() => {
+  init_recordings();
+  init_agents();
+  init_projects();
+  init_feedback();
+  init_client();
+  localStore = {
+    mode: "local",
+    baseUrl: null,
+    async createRecording(input) {
+      return createRecording2(input);
+    },
+    async getRecording(id) {
+      return getRecording2(id);
+    },
+    async listRecordings(filter) {
+      return listRecordings2(filter);
+    },
+    async searchRecordings(query, filter) {
+      return searchRecordings(query, filter);
+    },
+    async deleteRecording(id) {
+      return deleteRecording2(id);
+    },
+    async getRecordingStats() {
+      return getRecordingStats2();
+    },
+    async registerAgent(name, description, role) {
+      return registerAgent2(name, description, role);
+    },
+    async getAgent(idOrName) {
+      return getAgent2(idOrName);
+    },
+    async listAgents() {
+      return listAgents2();
+    },
+    async heartbeatAgent(idOrName) {
+      return heartbeatAgent2(idOrName);
+    },
+    async setAgentFocus(idOrName, projectId) {
+      return setAgentFocus2(idOrName, projectId);
+    },
+    async registerProject(name, path, description) {
+      return registerProject2(name, path, description);
+    },
+    async getProject(idOrPath) {
+      return getProject2(idOrPath);
+    },
+    async listProjects() {
+      return listProjects2();
+    },
+    async saveFeedback(input) {
+      saveFeedback2(input);
+    }
+  };
+});
+
 // src/types/index.ts
 var TranscriptionError, EnhancementError;
 var init_types2 = __esm(() => {
@@ -5794,404 +6310,6 @@ var init_enhancer = __esm(() => {
   init_transcriber();
 });
 
-// src/db/storage-config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-function readEnv(name) {
-  const value = process.env[name]?.trim();
-  return value || undefined;
-}
-function normalizeMode(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
-    return normalized;
-  return;
-}
-function getStorageDatabaseEnvName() {
-  for (const name of STORAGE_DATABASE_ENV) {
-    if (readEnv(name))
-      return name;
-  }
-  return null;
-}
-function getStorageDatabaseEnv() {
-  const name = getStorageDatabaseEnvName();
-  return name ? { name } : null;
-}
-function getStorageDatabaseUrl() {
-  const env = getStorageDatabaseEnv();
-  return env ? readEnv(env.name) : undefined;
-}
-function getStorageConfigPath() {
-  const override = readEnv(RECORDINGS_STORAGE_CONFIG_ENV);
-  if (override)
-    return override;
-  return join2(homedir2(), ".hasna", "recordings", "storage", "config.json");
-}
-function getStorageConfig() {
-  const config = {
-    mode: "local",
-    postgres: {
-      host: "",
-      port: 5432,
-      username: "",
-      password_env: "RECORDINGS_DATABASE_PASSWORD",
-      ssl: true
-    }
-  };
-  const storageConfigPath = getStorageConfigPath();
-  if (existsSync2(storageConfigPath)) {
-    try {
-      const raw = JSON.parse(readFileSync2(storageConfigPath, "utf-8"));
-      const legacyDatabaseConfig = typeof raw[LEGACY_DATABASE_CONFIG_KEY] === "object" && raw[LEGACY_DATABASE_CONFIG_KEY] !== null ? raw[LEGACY_DATABASE_CONFIG_KEY] : {};
-      config.mode = normalizeMode(raw.mode) ?? config.mode;
-      config.postgres = { ...config.postgres, ...legacyDatabaseConfig, ...raw.postgres ?? {} };
-    } catch {}
-  }
-  const modeOverride = readEnv(RECORDINGS_STORAGE_MODE_ENV) ?? readEnv(RECORDINGS_STORAGE_MODE_FALLBACK_ENV);
-  const normalizedMode = normalizeMode(modeOverride);
-  if (normalizedMode) {
-    config.mode = normalizedMode;
-  } else if (getStorageDatabaseUrl() && config.mode === "local") {
-    config.mode = "hybrid";
-  }
-  return config;
-}
-function getStorageConnectionString(dbName = "recordings") {
-  const direct = getStorageDatabaseUrl();
-  if (direct)
-    return direct;
-  const config = getStorageConfig();
-  const { host, port, username, password_env, ssl } = config.postgres;
-  if (!host || !username) {
-    throw new Error("Storage database is not configured. Set HASNA_RECORDINGS_DATABASE_URL or configure ~/.hasna/recordings/storage/config.json.");
-  }
-  const password = process.env[password_env];
-  if (!password) {
-    throw new Error(`Storage database password is not set. Export ${password_env}.`);
-  }
-  const sslParam = ssl ? "?sslmode=require" : "";
-  return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
-}
-var LEGACY_DATABASE_CONFIG_KEY, RECORDINGS_STORAGE_ENV = "HASNA_RECORDINGS_DATABASE_URL", RECORDINGS_STORAGE_FALLBACK_ENV = "RECORDINGS_DATABASE_URL", RECORDINGS_STORAGE_MODE_ENV = "HASNA_RECORDINGS_STORAGE_MODE", RECORDINGS_STORAGE_MODE_FALLBACK_ENV = "RECORDINGS_STORAGE_MODE", RECORDINGS_STORAGE_CONFIG_ENV = "HASNA_RECORDINGS_STORAGE_CONFIG", STORAGE_DATABASE_ENV;
-var init_storage_config = __esm(() => {
-  LEGACY_DATABASE_CONFIG_KEY = ["r", "d", "s"].join("");
-  STORAGE_DATABASE_ENV = [RECORDINGS_STORAGE_ENV, RECORDINGS_STORAGE_FALLBACK_ENV];
-});
-
-// src/db/storage-sync.ts
-function quoteId(value) {
-  return `"${value.replace(/"/g, '""')}"`;
-}
-async function getRemoteColumns(remote, table) {
-  const rows = await remote.all(`SELECT column_name FROM information_schema.columns
-     WHERE table_schema = 'public' AND table_name = $1`, table);
-  return new Set(rows.map((row) => row.column_name));
-}
-async function upsertPg(remote, table, rows) {
-  if (rows.length === 0)
-    return 0;
-  const keyColumns = TABLE_KEYS[table] ?? ["id"];
-  const remoteColumns = await getRemoteColumns(remote, table);
-  let written = 0;
-  for (const row of rows) {
-    const columns = Object.keys(row).filter((column) => remoteColumns.has(column));
-    if (keyColumns.some((column) => !columns.includes(column)))
-      continue;
-    const values = columns.map((column) => row[column]);
-    const placeholders = columns.map((_, index) => `$${index + 1}`).join(", ");
-    const updateColumns = columns.filter((column) => !keyColumns.includes(column));
-    const updateClause = updateColumns.length > 0 ? `DO UPDATE SET ${updateColumns.map((column) => `${quoteId(column)} = EXCLUDED.${quoteId(column)}`).join(", ")}` : "DO NOTHING";
-    await remote.run(`INSERT INTO ${quoteId(table)} (${columns.map(quoteId).join(", ")})
-       VALUES (${placeholders})
-       ON CONFLICT (${keyColumns.map(quoteId).join(", ")}) ${updateClause}`, ...values);
-    written++;
-  }
-  return written;
-}
-function upsertSqlite(db, table, rows) {
-  const keyColumns = TABLE_KEYS[table] ?? ["id"];
-  let written = 0;
-  for (const row of rows) {
-    const columns = Object.keys(row);
-    if (keyColumns.some((column) => !columns.includes(column)))
-      continue;
-    const updateColumns = columns.filter((column) => !keyColumns.includes(column));
-    const updateClause = updateColumns.length > 0 ? `DO UPDATE SET ${updateColumns.map((column) => `${quoteId(column)} = excluded.${quoteId(column)}`).join(", ")}` : "DO NOTHING";
-    db.query(`INSERT INTO ${quoteId(table)} (${columns.map(quoteId).join(", ")})
-       VALUES (${columns.map(() => "?").join(", ")})
-       ON CONFLICT(${keyColumns.map(quoteId).join(", ")}) ${updateClause}`).run(...columns.map((column) => row[column]));
-    written++;
-  }
-  return written;
-}
-async function getStoragePg() {
-  return new PgAdapterAsync(getStorageConnectionString("recordings"));
-}
-async function runStorageMigrations(remote) {
-  for (const migration of PG_MIGRATIONS) {
-    await remote.exec(migration);
-  }
-}
-function getStorageStatus(db = getDatabase()) {
-  const config = getStorageConfig();
-  const activeEnv = getStorageDatabaseEnv();
-  const hasConfiguredPostgres = Boolean(config.postgres.host && config.postgres.username);
-  return {
-    configured: Boolean(activeEnv) || hasConfiguredPostgres,
-    mode: config.mode,
-    enabled: config.mode === "hybrid" || config.mode === "remote",
-    env: STORAGE_DATABASE_ENV,
-    activeEnv: activeEnv?.name ?? null,
-    service: "recordings",
-    db_path: getDbPath(),
-    tables: STORAGE_TABLES.map((table) => {
-      try {
-        const row = db.query(`SELECT COUNT(*) as count FROM ${quoteId(table)}`).get();
-        return { table, rows: row.count };
-      } catch {
-        return { table, rows: 0 };
-      }
-    })
-  };
-}
-async function pushStorageChanges(tables = [...STORAGE_TABLES]) {
-  const db = getDatabase();
-  const remote = await getStoragePg();
-  const results = [];
-  try {
-    await runStorageMigrations(remote);
-    for (const table of tables) {
-      const result = { table, direction: "push", rows_read: 0, rows_written: 0, errors: [] };
-      try {
-        const rows = db.query(`SELECT * FROM ${quoteId(table)}`).all();
-        result.rows_read = rows.length;
-        result.rows_written = await upsertPg(remote, table, rows);
-      } catch (error2) {
-        result.errors.push(error2 instanceof Error ? error2.message : String(error2));
-      }
-      results.push(result);
-    }
-  } finally {
-    await remote.close();
-  }
-  return results;
-}
-async function pullStorageChanges(tables = [...STORAGE_TABLES]) {
-  const db = getDatabase();
-  const remote = await getStoragePg();
-  const results = [];
-  try {
-    await runStorageMigrations(remote);
-    for (const table of tables) {
-      const result = { table, direction: "pull", rows_read: 0, rows_written: 0, errors: [] };
-      try {
-        const rows = await remote.all(`SELECT * FROM ${quoteId(table)}`);
-        result.rows_read = rows.length;
-        result.rows_written = upsertSqlite(db, table, rows);
-      } catch (error2) {
-        result.errors.push(error2 instanceof Error ? error2.message : String(error2));
-      }
-      results.push(result);
-    }
-  } finally {
-    await remote.close();
-  }
-  return results;
-}
-async function syncStorageChanges(tables = [...STORAGE_TABLES]) {
-  return {
-    push: await pushStorageChanges(tables),
-    pull: await pullStorageChanges(tables)
-  };
-}
-function parseStorageTables(raw) {
-  if (!raw)
-    return [...STORAGE_TABLES];
-  const requested = raw.split(",").map((table) => table.trim()).filter(Boolean);
-  if (requested.length === 0)
-    return [...STORAGE_TABLES];
-  const allowed = new Set(STORAGE_TABLES);
-  const invalid = requested.filter((table) => !allowed.has(table));
-  if (invalid.length > 0)
-    throw new Error(`Unknown recordings sync table(s): ${invalid.join(", ")}`);
-  return requested;
-}
-var STORAGE_TABLES, TABLE_KEYS;
-var init_storage_sync = __esm(() => {
-  init_database();
-  init_storage_config();
-  init_remote_storage();
-  init_pg_migrations();
-  STORAGE_TABLES = [
-    "projects",
-    "agents",
-    "recordings",
-    "recording_tags",
-    "feedback"
-  ];
-  TABLE_KEYS = {
-    projects: ["id"],
-    agents: ["id"],
-    recordings: ["id"],
-    recording_tags: ["recording_id", "tag"],
-    feedback: ["id"]
-  };
-});
-
-// src/mcp/storage-tools.ts
-function text(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
-}
-function errorText(error2) {
-  return {
-    content: [{ type: "text", text: error2 instanceof Error ? error2.message : String(error2) }],
-    isError: true
-  };
-}
-function registerRecordingsStorageTools(server) {
-  server.tool("recordings_storage_status", "Show recordings local database and storage sync status", {}, async () => {
-    try {
-      return text(getStorageStatus());
-    } catch (error2) {
-      return errorText(error2);
-    }
-  });
-  server.tool("recordings_storage_push", "Push local recordings data to PostgreSQL", {
-    tables: exports_external.string().optional().describe("Comma-separated table names")
-  }, async ({ tables }) => {
-    try {
-      return text(await pushStorageChanges(parseStorageTables(tables)));
-    } catch (error2) {
-      return errorText(error2);
-    }
-  });
-  server.tool("recordings_storage_pull", "Pull PostgreSQL recordings data into the local database", {
-    tables: exports_external.string().optional().describe("Comma-separated table names")
-  }, async ({ tables }) => {
-    try {
-      return text(await pullStorageChanges(parseStorageTables(tables)));
-    } catch (error2) {
-      return errorText(error2);
-    }
-  });
-  server.tool("recordings_storage_sync", "Push local changes, then pull remote changes", {
-    tables: exports_external.string().optional().describe("Comma-separated table names")
-  }, async ({ tables }) => {
-    try {
-      return text(await syncStorageChanges(parseStorageTables(tables)));
-    } catch (error2) {
-      return errorText(error2);
-    }
-  });
-  server.tool("recordings_storage_feedback", "Save feedback for recordings", {
-    message: exports_external.string(),
-    email: exports_external.string().optional(),
-    category: exports_external.enum(["bug", "feature", "general"]).optional()
-  }, async ({ message, email, category }) => {
-    try {
-      const adapter = getAdapter();
-      adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", message, email || null, category || "general", "recordings");
-      return text({ saved: true });
-    } catch (error2) {
-      return errorText(error2);
-    }
-  });
-}
-var init_storage_tools = __esm(() => {
-  init_zod();
-  init_database();
-  init_storage_sync();
-});
-
-// package.json
-var require_package = __commonJS((exports, module) => {
-  module.exports = {
-    name: "@hasna/recordings",
-    version: "0.1.37",
-    type: "module",
-    description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
-    repository: {
-      type: "git",
-      url: "git+https://github.com/hasna/recordings.git"
-    },
-    main: "dist/index.js",
-    types: "dist/index.d.ts",
-    bin: {
-      recordings: "dist/cli/index.js",
-      "recordings-mcp": "dist/mcp/index.js",
-      "recordings-serve": "dist/server/index.js"
-    },
-    exports: {
-      ".": {
-        import: "./dist/index.js",
-        types: "./dist/index.d.ts"
-      },
-      "./storage": {
-        import: "./dist/storage.js",
-        types: "./dist/storage.d.ts"
-      },
-      "./sdk": {
-        import: "./dist/sdk/index.js",
-        types: "./dist/sdk/index.d.ts"
-      }
-    },
-    scripts: {
-      clean: "rm -rf dist",
-      build: "bun run clean && bun run build:cli && bun run build:mcp && bun run build:serve && bun run build:lib && tsc --emitDeclarationOnly --outDir dist",
-      "build:cli": "bun build src/cli/index.ts --target=bun --outfile=dist/cli/index.js --external=commander --external=chalk --external=openai",
-      "build:mcp": "bun build src/mcp/index.ts --target=bun --outfile=dist/mcp/index.js --external=@modelcontextprotocol/sdk --external=openai",
-      "build:serve": "bun build src/server/index.ts --target=bun --outfile=dist/server/index.js --external=@modelcontextprotocol/sdk --external=@hasna/contracts --external=openai --external=pg",
-      "build:lib": "bun build src/index.ts src/storage.ts src/sdk/index.ts --target=bun --outdir=dist --external=openai",
-      "generate:sdk": "bun run scripts/generate-sdk.ts",
-      migrate: "bun run scripts/migrate.ts",
-      typecheck: "tsc --noEmit",
-      test: "bun test",
-      "test:coverage": "bun test --coverage",
-      "dev:cli": "bun run src/cli/index.ts",
-      "dev:mcp": "bun run src/mcp/index.ts",
-      "verify:release": "bun run scripts/release-guard.ts",
-      prepack: "bun run build && bun run verify:release",
-      prepublishOnly: "bun run typecheck && bun run test",
-      postinstall: "bash scripts/install_macos_app.sh --postinstall"
-    },
-    files: [
-      "dist/",
-      "scripts/",
-      "src/native/Recordings/App/",
-      "src/native/Recordings/RecordingsLib/",
-      "src/native/Recordings/RecordingsTests/",
-      "src/native/Recordings/Package.swift",
-      "src/native/Recordings/Package.resolved",
-      "src/native/Recordings/build.sh",
-      "README.md",
-      "LICENSE"
-    ],
-    dependencies: {
-      "@hasna/contracts": "0.4.1",
-      "@hasna/events": "^0.1.11",
-      "@modelcontextprotocol/sdk": "^1.12.1",
-      chalk: "^5.4.1",
-      commander: "^13.1.0",
-      openai: "^5.1.0",
-      pg: "^8.13.3",
-      zod: "^3.24.2"
-    },
-    devDependencies: {
-      "@types/bun": "^1.2.5",
-      "@types/pg": "^8.11.11",
-      typescript: "^5.8.2"
-    },
-    publishConfig: {
-      registry: "https://registry.npmjs.org",
-      access: "public"
-    },
-    license: "Apache-2.0",
-    author: "Hasna <andrei@hasna.com>"
-  };
-});
-
 // src/mcp/index.ts
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -6205,7 +6323,7 @@ function buildServer() {
     version: VERSION
   });
   const registerTool = server.tool.bind(server);
-  function text2(content) {
+  function text(content) {
     return { content: [{ type: "text", text: content }] };
   }
   function errorResult(e) {
@@ -6298,7 +6416,7 @@ Params: none`
   };
   registerTool("describe_tool", "Get full param docs for any tool.", { name: exports_external.string() }, async (args) => {
     const doc = toolDocs[args.name];
-    return doc ? text2(doc) : text2(`Unknown tool: ${args.name}. Available: ${Object.keys(toolDocs).join(", ")}`);
+    return doc ? text(doc) : text(`Unknown tool: ${args.name}. Available: ${Object.keys(toolDocs).join(", ")}`);
   });
   registerTool("transcribe_audio", "Transcribe audio file. Auto-enhances if needed.", {
     audio_path: exports_external.string(),
@@ -6317,7 +6435,7 @@ Params: none`
         cfg.auto_enhance = false;
       const transcription = await transcribeAudio(args.audio_path, cfg);
       const processed = await processText(transcription.text, cfg);
-      const recording = createRecording2({
+      const recording = await getStore().createRecording({
         audio_path: args.audio_path,
         raw_text: transcription.text,
         processed_text: processed.mode === "enhanced" ? processed.text : undefined,
@@ -6346,7 +6464,7 @@ Params: none`
         });
       }
       const output = processed.mode === "enhanced" ? processed.text : transcription.text;
-      return text2(`${recording.id.slice(0, 8)} | ${processed.mode} | ${output}`);
+      return text(`${recording.id.slice(0, 8)} | ${processed.mode} | ${output}`);
     } catch (e) {
       return errorResult(e);
     }
@@ -6375,7 +6493,7 @@ Params: none`
           enhModel = processed.enhancement_model || undefined;
         }
       }
-      const recording = createRecording2({
+      const recording = await getStore().createRecording({
         raw_text: args.text,
         processed_text: processedText,
         processing_mode: mode,
@@ -6391,17 +6509,17 @@ Params: none`
         metadata: args.metadata
       });
       const output = processedText || args.text;
-      return text2(`${recording.id.slice(0, 8)} | ${mode} | ${output}`);
+      return text(`${recording.id.slice(0, 8)} | ${mode} | ${output}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("get_recording", "Get recording by ID or prefix.", { id: exports_external.string() }, async (args) => {
     try {
-      const r = getRecording2(args.id);
+      const r = await getStore().getRecording(args.id);
       if (!r)
-        return text2(`Not found: ${args.id}`);
-      return text2(full(r));
+        return text(`Not found: ${args.id}`);
+      return text(full(r));
     } catch (e) {
       return errorResult(e);
     }
@@ -6432,15 +6550,15 @@ Params: none`
         project_id: args.project_id,
         session_id: args.session_id
       };
-      const recordings = listRecordings2(filter);
+      const recordings = await getStore().listRecordings(filter);
       if (recordings.length === 0)
-        return text2("No recordings found.");
+        return text("No recordings found.");
       const fmt = args.full ? full : compact;
       const sep = args.full ? `
 ---
 ` : `
 `;
-      return text2(`${recordings.length} recording(s):${sep}${recordings.map(fmt).join(sep)}`);
+      return text(`${recordings.length} recording(s):${sep}${recordings.map(fmt).join(sep)}`);
     } catch (e) {
       return errorResult(e);
     }
@@ -6453,39 +6571,39 @@ Params: none`
     full: exports_external.boolean().optional()
   }, async (args) => {
     try {
-      const results = searchRecordings(args.query, {
+      const results = await getStore().searchRecordings(args.query, {
         limit: args.limit || 10,
         agent_id: args.agent_id,
         project_id: args.project_id
       });
       if (results.length === 0)
-        return text2("No results.");
+        return text("No results.");
       const fmt = args.full ? full : compact;
       const sep = args.full ? `
 ---
 ` : `
 `;
-      return text2(`${results.length} result(s):${sep}${results.map(fmt).join(sep)}`);
+      return text(`${results.length} result(s):${sep}${results.map(fmt).join(sep)}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("delete_recording", "Delete recording by ID.", { id: exports_external.string() }, async (args) => {
     try {
-      return text2(deleteRecording2(args.id) ? `Deleted ${args.id}` : `Not found: ${args.id}`);
+      return text(await getStore().deleteRecording(args.id) ? `Deleted ${args.id}` : `Not found: ${args.id}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("recording_stats", "Recording stats: count, modes, duration.", {}, async () => {
     try {
-      const s = getRecordingStats2();
+      const s = await getStore().getRecordingStats();
       let out = `Total: ${s.total} | Raw: ${s.raw} | Enhanced: ${s.enhanced} | Duration: ${(s.total_duration_ms / 1000).toFixed(1)}s`;
       if (Object.keys(s.by_model).length > 0) {
         out += `
 ` + Object.entries(s.by_model).map(([m, c]) => `${m}: ${c}`).join(", ");
       }
-      return text2(out);
+      return text(out);
     } catch (e) {
       return errorResult(e);
     }
@@ -6493,25 +6611,25 @@ Params: none`
   registerTool("detect_enhancement", "Check if text needs AI enhancement.", { text: exports_external.string() }, async (args) => {
     try {
       const r = needsEnhancement(args.text, config);
-      return text2(`${r.needs ? "Yes" : "No"}: ${r.reason}`);
+      return text(`${r.needs ? "Yes" : "No"}: ${r.reason}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("register_agent", "Register agent (idempotent).", { name: exports_external.string(), description: exports_external.string().optional(), role: exports_external.string().optional() }, async (args) => {
     try {
-      const a = registerAgent2(args.name, args.description, args.role);
-      return text2(`${a.id} | ${a.name} | ${a.role}`);
+      const a = await getStore().registerAgent(args.name, args.description, args.role);
+      return text(`${a.id} | ${a.name} | ${a.role}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("list_agents", "List registered agents.", {}, async () => {
     try {
-      const agents = listAgents2();
+      const agents = await getStore().listAgents();
       if (agents.length === 0)
-        return text2("None.");
-      return text2(agents.map((a) => `${a.id} | ${a.name} | ${a.role}`).join(`
+        return text("None.");
+      return text(agents.map((a) => `${a.id} | ${a.name} | ${a.role}`).join(`
 `));
     } catch (e) {
       return errorResult(e);
@@ -6519,28 +6637,28 @@ Params: none`
   });
   registerTool("get_agent", "Get agent by ID or name.", { id: exports_external.string() }, async (args) => {
     try {
-      const a = getAgent2(args.id);
+      const a = await getStore().getAgent(args.id);
       if (!a)
-        return text2(`Not found: ${args.id}`);
-      return text2(`${a.id} | ${a.name} | ${a.role} | ${a.last_seen_at}`);
+        return text(`Not found: ${args.id}`);
+      return text(`${a.id} | ${a.name} | ${a.role} | ${a.last_seen_at}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("register_project", "Register project (idempotent).", { name: exports_external.string(), path: exports_external.string(), description: exports_external.string().optional() }, async (args) => {
     try {
-      const p = registerProject2(args.name, args.path, args.description);
-      return text2(`${p.id.slice(0, 8)} | ${p.name} | ${p.path}`);
+      const p = await getStore().registerProject(args.name, args.path, args.description);
+      return text(`${p.id.slice(0, 8)} | ${p.name} | ${p.path}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("list_projects", "List registered projects.", {}, async () => {
     try {
-      const projects = listProjects2();
+      const projects = await getStore().listProjects();
       if (projects.length === 0)
-        return text2("None.");
-      return text2(projects.map((p) => `${p.id.slice(0, 8)} | ${p.name} | ${p.path}`).join(`
+        return text("None.");
+      return text(projects.map((p) => `${p.id.slice(0, 8)} | ${p.name} | ${p.path}`).join(`
 `));
     } catch (e) {
       return errorResult(e);
@@ -6548,20 +6666,20 @@ Params: none`
   });
   registerTool("heartbeat", "Update last_seen_at to signal agent is active. Call periodically during long tasks.", { agent_id: exports_external.string().describe("Agent ID or name") }, async (args) => {
     try {
-      const agent = heartbeatAgent(args.agent_id);
+      const agent = await getStore().heartbeatAgent(args.agent_id);
       if (!agent)
-        return text2(`Agent not found: ${args.agent_id}`);
-      return text2(`${agent.id} | ${agent.name} | last_seen: ${agent.last_seen_at}`);
+        return text(`Agent not found: ${args.agent_id}`);
+      return text(`${agent.id} | ${agent.name} | last_seen: ${agent.last_seen_at}`);
     } catch (e) {
       return errorResult(e);
     }
   });
   registerTool("set_focus", "Set active project context for this agent session.", { agent_id: exports_external.string().describe("Agent ID or name"), project_id: exports_external.string().nullable().optional().describe("Project ID to focus on, or null to clear") }, async (args) => {
     try {
-      const agent = setAgentFocus(args.agent_id, args.project_id ?? null);
+      const agent = await getStore().setAgentFocus(args.agent_id, args.project_id ?? null);
       if (!agent)
-        return text2(`Agent not found: ${args.agent_id}`);
-      return text2(args.project_id ? `Focus set: ${args.project_id}` : "Focus cleared");
+        return text(`Agent not found: ${args.agent_id}`);
+      return text(args.project_id ? `Focus set: ${args.project_id}` : "Focus cleared");
     } catch (e) {
       return errorResult(e);
     }
@@ -6571,12 +6689,18 @@ Params: none`
     email: exports_external.string().optional().describe("Contact email (optional)"),
     category: exports_external.enum(["bug", "feature", "general"]).optional().describe("Feedback category")
   }, async (params) => {
-    const adapter = getAdapter();
-    const pkg = require_package();
-    adapter.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", params.message, params.email || null, params.category || "general", pkg.version);
-    return text2("Feedback saved. Thank you!");
+    try {
+      await getStore().saveFeedback({
+        message: params.message,
+        email: params.email || null,
+        category: params.category || "general",
+        version: VERSION
+      });
+      return text("Feedback saved. Thank you!");
+    } catch (e) {
+      return errorResult(e);
+    }
   });
-  registerRecordingsStorageTools(server);
   return server;
 }
 var config;
@@ -6584,16 +6708,11 @@ var init_mcp = __esm(async () => {
   init_http();
   init_zod();
   init_config();
-  init_database();
-  init_recordings();
-  init_agents();
-  init_projects();
+  init_store();
   init_transcriber();
   init_enhancer();
-  init_storage_tools();
   config = loadConfig();
   ensureDataDir(config);
-  getDatabase(config.db_path);
   if (false) {}
 });
 
@@ -6633,7 +6752,7 @@ function checkRateLimit(ip) {
   return { allowed: true };
 }
 function buildFetch() {
-  return async function fetch(req, server) {
+  return async function fetch2(req, server) {
     const url = new URL(req.url);
     const path = url.pathname;
     const method = req.method.toUpperCase();
@@ -6704,8 +6823,8 @@ function buildFetch() {
 }
 async function startServer(port, options) {
   const hostname = options?.host || process.env.HOST || "127.0.0.1";
-  const fetch = buildFetch();
-  const server = Bun.serve({ port, hostname, fetch });
+  const fetch2 = buildFetch();
+  const server = Bun.serve({ port, hostname, fetch: fetch2 });
   const shutdown = async () => {
     try {
       const { closeCloud: closeCloud2 } = await Promise.resolve().then(() => (init_cloud(), exports_cloud));