os-dpt 0.0.1

package/server/dist/index.mjs

@@ -0,0 +1,3477 @@
+// server/load-env.ts
+for (const envPath of [".env", "../.env"]) {
+  try {
+    process.loadEnvFile(envPath);
+  } catch {
+  }
+}
+
+// server/index.ts
+import { pathToFileURL } from "node:url";
+import { serve } from "@hono/node-server";
+import { Hono as Hono10 } from "hono";
+import { HTTPException as HTTPException4 } from "hono/http-exception";
+
+// server/api/ai-providers.ts
+import { Hono } from "hono";
+
+// server/credentials/vault.ts
+import crypto2 from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+import keytar from "keytar";
+
+// server/credentials/workspaceId.ts
+import crypto from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var FILE = path.join(".os-dpt", "workspace-id");
+async function getOrCreateWorkspaceId(workspace) {
+  const filePath2 = path.join(workspace, FILE);
+  try {
+    const raw = await fs.readFile(filePath2, "utf8");
+    const id2 = raw.trim();
+    if (id2) return id2;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const id = crypto.randomUUID();
+  await fs.mkdir(path.dirname(filePath2), { recursive: true });
+  await fs.writeFile(filePath2, id + "\n", { encoding: "utf8", mode: 384 });
+  return id;
+}
+
+// server/credentials/vault.ts
+var SERVICE = "os-dpt";
+var FILE2 = path2.join(".os-dpt", "credentials.enc");
+var CredentialVault = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+  }
+  // Serializes read-modify-write cycles so concurrent setPassword /
+  // deletePassword calls don't clobber each other.
+  queue = Promise.resolve();
+  enqueue(fn) {
+    const next = this.queue.then(fn, fn);
+    this.queue = next.catch(() => {
+    });
+    return next;
+  }
+  get filePath() {
+    return path2.join(this.workspace, FILE2);
+  }
+  async account() {
+    const id = await getOrCreateWorkspaceId(this.workspace);
+    return `workspace:${id}`;
+  }
+  setPassword(connectionId, password) {
+    return this.enqueue(async () => {
+      const key = await this.masterKey();
+      const iv = crypto2.randomBytes(12);
+      const cipher = crypto2.createCipheriv("aes-256-gcm", key, iv);
+      const ciphertext = Buffer.concat([
+        cipher.update(password, "utf8"),
+        cipher.final()
+      ]);
+      const tag = cipher.getAuthTag();
+      const blob = await this.read();
+      blob.entries[connectionId] = {
+        iv: iv.toString("base64"),
+        ciphertext: ciphertext.toString("base64"),
+        tag: tag.toString("base64")
+      };
+      await this.persist(blob);
+    });
+  }
+  async getPassword(connectionId) {
+    const blob = await this.read();
+    const entry = blob.entries[connectionId];
+    if (!entry) return null;
+    const key = await this.masterKey();
+    const iv = Buffer.from(entry.iv, "base64");
+    const ciphertext = Buffer.from(entry.ciphertext, "base64");
+    const tag = Buffer.from(entry.tag, "base64");
+    const decipher = crypto2.createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString(
+      "utf8"
+    );
+  }
+  deletePassword(connectionId) {
+    return this.enqueue(async () => {
+      const blob = await this.read();
+      if (!(connectionId in blob.entries)) return;
+      delete blob.entries[connectionId];
+      await this.persist(blob);
+    });
+  }
+  async masterKey() {
+    const account = await this.account();
+    const existing = await keytar.getPassword(SERVICE, account);
+    if (existing) return Buffer.from(existing, "base64");
+    const fresh = crypto2.randomBytes(32);
+    await keytar.setPassword(SERVICE, account, fresh.toString("base64"));
+    return fresh;
+  }
+  async read() {
+    try {
+      const raw = await fs2.readFile(this.filePath, "utf8");
+      const data = JSON.parse(raw);
+      return { entries: data.entries ?? {} };
+    } catch (err) {
+      if (err.code === "ENOENT") return { entries: {} };
+      throw err;
+    }
+  }
+  async persist(blob) {
+    await fs2.mkdir(path2.dirname(this.filePath), { recursive: true });
+    await fs2.writeFile(this.filePath, JSON.stringify(blob, null, 2), {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+};
+
+// server/storage/ai-providers.ts
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
+var FILE3 = "ai-providers.json";
+var AIProviderStore = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+  }
+  get filePath() {
+    return path3.join(this.workspace, FILE3);
+  }
+  async get(id) {
+    const all = await this.list();
+    return all[id] ?? null;
+  }
+  async set(id, meta) {
+    const all = await this.list();
+    all[id] = meta;
+    await this.write(all);
+  }
+  async remove(id) {
+    const all = await this.list();
+    if (all[id] === null) return;
+    all[id] = null;
+    await this.write(all);
+  }
+  async list() {
+    const empty = {
+      anthropic: null,
+      openai: null,
+      braintrust: null
+    };
+    try {
+      const raw = await fs3.readFile(this.filePath, "utf8");
+      const data = JSON.parse(raw);
+      return {
+        anthropic: data.providers?.anthropic ?? null,
+        openai: data.providers?.openai ?? null,
+        braintrust: data.providers?.braintrust ?? null
+      };
+    } catch (err) {
+      if (err.code === "ENOENT") return empty;
+      throw err;
+    }
+  }
+  async write(providers) {
+    const cleaned = {};
+    for (const [k, v] of Object.entries(providers)) {
+      if (v !== null) cleaned[k] = v;
+    }
+    await fs3.mkdir(this.workspace, { recursive: true });
+    await fs3.writeFile(
+      this.filePath,
+      JSON.stringify({ providers: cleaned }, null, 2) + "\n",
+      "utf8"
+    );
+  }
+};
+
+// server/workspace.ts
+import { promises as fs4 } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path4 from "node:path";
+import { HTTPException } from "hono/http-exception";
+
+// shared/context.ts
+var CONTEXT_DOCS = [
+  {
+    name: "schemas",
+    title: "Schemas",
+    description: "Table and column facts the agent has learned about the data source."
+  },
+  {
+    name: "conventions",
+    title: "Conventions",
+    description: "How the team writes SQL and what business terms mean."
+  },
+  {
+    name: "feedback",
+    title: "Feedback",
+    description: "Corrections and lessons learned from running queries."
+  }
+];
+var CONTEXT_DOC_NAMES = CONTEXT_DOCS.map((d) => d.name);
+
+// server/workspace.ts
+var exec = promisify(execFile);
+var WORKSHEETS_DIR = "worksheets";
+var CONTEXT_DIR = "context";
+var CONTEXT_BY_SOURCE = "by-source";
+var OSDPT_DIR = ".os-dpt";
+var DRAFTS_DIR = path4.join(OSDPT_DIR, "drafts");
+var CHATS_DIR = path4.join(OSDPT_DIR, "chats");
+var SCHEMAS_DIR = path4.join(OSDPT_DIR, "schemas");
+var SESSION_FILE = path4.join(OSDPT_DIR, "session.json");
+var SCHEMA_FILE = path4.join(OSDPT_DIR, "schema.json");
+var HISTORY_FILE = path4.join(OSDPT_DIR, "history.db");
+var GITIGNORE = ".gitignore";
+var CONTEXT_FILES = CONTEXT_DOC_NAMES;
+var resolved = null;
+function parseWorkspaceArg(argv) {
+  const idx = argv.indexOf("--workspace");
+  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1];
+  return process.cwd();
+}
+function resolveWorkspace(argv) {
+  return path4.resolve(parseWorkspaceArg(argv));
+}
+async function initWorkspace(argv = process.argv.slice(2)) {
+  const root = resolveWorkspace(argv);
+  await fs4.mkdir(path4.join(root, WORKSHEETS_DIR), { recursive: true });
+  await fs4.mkdir(path4.join(root, DRAFTS_DIR), { recursive: true });
+  await fs4.mkdir(path4.join(root, CHATS_DIR), { recursive: true });
+  await fs4.mkdir(path4.join(root, CONTEXT_DIR), { recursive: true });
+  await fs4.mkdir(path4.join(root, SCHEMAS_DIR), { recursive: true });
+  const sessionPath = path4.join(root, SESSION_FILE);
+  try {
+    await fs4.access(sessionPath);
+  } catch {
+    await fs4.writeFile(
+      sessionPath,
+      JSON.stringify({ openTabs: [], activeSlug: null, resultsPaneSize: null }, null, 2)
+    );
+  }
+  await ensureGitRepo(root);
+  await ensureGitignored(root);
+  resolved = root;
+  return root;
+}
+async function ensureGitRepo(root) {
+  try {
+    await exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root });
+    return;
+  } catch {
+  }
+  try {
+    await exec("git", ["init"], { cwd: root });
+    console.log(`os-dpt: initialized a git repository in ${root} for worksheet history`);
+  } catch {
+    console.warn(
+      "os-dpt: git not found \u2014 worksheet history is disabled. Install git and run `git init` here to enable it."
+    );
+  }
+}
+async function ensureGitignored(root) {
+  const gitignorePath = path4.join(root, GITIGNORE);
+  let current = "";
+  try {
+    current = await fs4.readFile(gitignorePath, "utf8");
+  } catch {
+  }
+  const needs = ["/.os-dpt/"];
+  const missing = needs.filter((line) => !current.split("\n").some((l) => l.trim() === line));
+  if (missing.length === 0) return;
+  const append = (current.endsWith("\n") || current === "" ? "" : "\n") + missing.join("\n") + "\n";
+  await fs4.writeFile(gitignorePath, current + append);
+}
+function workspaceRoot() {
+  if (!resolved) throw new Error("Workspace not initialized");
+  return resolved;
+}
+function workspacePath(...segments) {
+  return path4.join(workspaceRoot(), ...segments);
+}
+var paths = {
+  worksheets: () => workspacePath(WORKSHEETS_DIR),
+  worksheet: (slug) => workspacePath(WORKSHEETS_DIR, `${slug}.sql`),
+  drafts: () => workspacePath(DRAFTS_DIR),
+  draft: (slug) => workspacePath(DRAFTS_DIR, `${slug}.sql`),
+  schemas: () => workspacePath(SCHEMAS_DIR),
+  connectionSchema: (id) => workspacePath(SCHEMAS_DIR, `${id}.json`),
+  session: () => workspacePath(SESSION_FILE),
+  schema: () => workspacePath(SCHEMA_FILE),
+  history: () => workspacePath(HISTORY_FILE),
+  chats: () => workspacePath(CHATS_DIR),
+  chat: (id) => workspacePath(CHATS_DIR, `${id}.json`),
+  context: () => workspacePath(CONTEXT_DIR),
+  // `connectionId` scopes docs to a data source; null/undefined → the
+  // workspace-root "unassigned" set.
+  contextDir: (connectionId) => connectionId ? workspacePath(CONTEXT_DIR, CONTEXT_BY_SOURCE, connectionId) : workspacePath(CONTEXT_DIR),
+  contextFile: (name, connectionId) => connectionId ? workspacePath(CONTEXT_DIR, CONTEXT_BY_SOURCE, connectionId, `${name}.md`) : workspacePath(CONTEXT_DIR, `${name}.md`)
+};
+var SLUG_RE = /^[a-z0-9][a-z0-9-_]*$/i;
+function assertSafeSlug(slug) {
+  if (!SLUG_RE.test(slug) || slug.includes("..") || slug.length > 100) {
+    throw new HTTPException(400, { message: `Invalid slug: ${slug}` });
+  }
+}
+var CHAT_ID_RE = /^[a-z0-9][a-z0-9-]*$/i;
+function assertSafeChatId(id) {
+  if (!CHAT_ID_RE.test(id) || id.includes("..") || id.length > 64) {
+    throw new HTTPException(400, { message: `Invalid chat id: ${id}` });
+  }
+}
+var CONNECTION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isSafeConnectionId(id) {
+  return CONNECTION_ID_RE.test(id);
+}
+function assertSafeConnectionId(id) {
+  if (!isSafeConnectionId(id)) {
+    throw new HTTPException(400, { message: `Invalid connection id` });
+  }
+}
+
+// server/agent/tracing.ts
+var bt = null;
+var enabled = false;
+function tracingEnabled() {
+  return enabled;
+}
+async function resolveApiKey() {
+  if (process.env.BRAINTRUST_API_KEY) return process.env.BRAINTRUST_API_KEY;
+  try {
+    const vault = new CredentialVault(workspaceRoot());
+    return await vault.getPassword("ai:braintrust");
+  } catch {
+    return null;
+  }
+}
+async function initTracing() {
+  const apiKey = await resolveApiKey();
+  if (!apiKey) {
+    enabled = false;
+    return;
+  }
+  const projectName = process.env.BRAINTRUST_PROJECT ?? "os-dpt";
+  try {
+    if (!bt) bt = await import("braintrust");
+    bt.initLogger({
+      projectName,
+      apiKey,
+      // Flush in the background so logging never adds latency to a turn.
+      asyncFlush: true
+    });
+    enabled = true;
+    console.log(`[os-dpt] Braintrust tracing enabled (project: ${projectName})`);
+  } catch (err) {
+    const code = err.code;
+    const message = code === "ERR_MODULE_NOT_FOUND" ? "the braintrust package is not installed. Run `pnpm add braintrust` (or `npm i braintrust`) in your workspace to enable tracing." : err.message;
+    console.warn(
+      "[os-dpt] Braintrust key found but tracing failed to initialize:",
+      message
+    );
+    bt = null;
+    enabled = false;
+  }
+}
+async function refreshTracing() {
+  await initTracing();
+}
+var NOOP_SPAN = { log() {
+} };
+async function traced(args, fn) {
+  if (!enabled || !bt) return fn(NOOP_SPAN);
+  return bt.traced((span) => fn(span), {
+    name: args.name,
+    type: args.type,
+    event: args.event,
+    parent: args.parent
+  });
+}
+async function startConversationSpan(args) {
+  if (!enabled || !bt) return void 0;
+  try {
+    const span = bt.startSpan({
+      name: args.name,
+      type: "task",
+      event: args.event
+    });
+    try {
+      return await span.export();
+    } finally {
+      span.end();
+    }
+  } catch (err) {
+    console.warn("[os-dpt] failed to start conversation span:", err.message);
+    return void 0;
+  }
+}
+async function flushTracing() {
+  if (!enabled || !bt) return;
+  try {
+    await bt.flush();
+  } catch {
+  }
+}
+
+// server/api/ai-providers.ts
+var AI_PROVIDER_IDS = [
+  "anthropic",
+  "openai",
+  "braintrust"
+];
+var AI_PROVIDER_LABELS = {
+  anthropic: "Anthropic",
+  openai: "OpenAI",
+  braintrust: "Braintrust"
+};
+var AI_PROVIDER_ENV_VARS = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  braintrust: "BRAINTRUST_API_KEY"
+};
+var AI_PROVIDER_KINDS = {
+  anthropic: "model",
+  openai: "model",
+  braintrust: "observability"
+};
+var vaultKey = (id) => `ai:${id}`;
+function isAIProviderId(value) {
+  return AI_PROVIDER_IDS.includes(value);
+}
+function last4(apiKey) {
+  return apiKey.slice(-4);
+}
+function toApi(id, stored) {
+  return {
+    id,
+    label: AI_PROVIDER_LABELS[id],
+    kind: AI_PROVIDER_KINDS[id],
+    envVar: AI_PROVIDER_ENV_VARS[id],
+    configured: stored !== null,
+    last4: stored?.last4,
+    updatedAt: stored?.updatedAt
+  };
+}
+var VERIFY_TIMEOUT_MS = 1e4;
+async function verifyKey(id, apiKey) {
+  const signal = AbortSignal.timeout(VERIFY_TIMEOUT_MS);
+  try {
+    if (id === "anthropic") {
+      const res2 = await fetch("https://api.anthropic.com/v1/models", {
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        signal
+      });
+      if (!res2.ok) {
+        const body = await res2.json().catch(() => null);
+        throw new Error(body?.error?.message ?? `Anthropic returned ${res2.status}`);
+      }
+      return;
+    }
+    if (id === "braintrust") {
+      const appUrl = process.env.BRAINTRUST_APP_URL ?? "https://www.braintrust.dev";
+      const res2 = await fetch(`${appUrl}/api/apikey/login`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        signal
+      });
+      if (!res2.ok) {
+        throw new Error(
+          res2.status === 401 || res2.status === 403 ? "Invalid Braintrust API key" : `Braintrust returned ${res2.status}`
+        );
+      }
+      return;
+    }
+    const res = await fetch("https://api.openai.com/v1/models", {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => null);
+      throw new Error(body?.error?.message ?? `OpenAI returned ${res.status}`);
+    }
+  } catch (err) {
+    if (err.name === "TimeoutError") {
+      throw new Error(`Request timed out after ${VERIFY_TIMEOUT_MS / 1e3}s`);
+    }
+    throw err;
+  }
+}
+function aiProvidersRouter(workspace) {
+  const router = new Hono();
+  const store = new AIProviderStore(workspace);
+  const vault = new CredentialVault(workspace);
+  router.get("/", async (c) => {
+    const all = await store.list();
+    const providers = AI_PROVIDER_IDS.map((id) => toApi(id, all[id]));
+    return c.json({ providers });
+  });
+  router.put("/:provider", async (c) => {
+    const provider = c.req.param("provider");
+    if (!isAIProviderId(provider)) {
+      return c.json({ error: `Unknown provider: ${provider}` }, 400);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+    if (apiKey === "") {
+      return c.json({ error: "Missing required field: apiKey" }, 400);
+    }
+    const previousKey = await vault.getPassword(vaultKey(provider));
+    await vault.setPassword(vaultKey(provider), apiKey);
+    const meta = {
+      last4: last4(apiKey),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await store.set(provider, meta);
+    } catch (err) {
+      const rollback = previousKey !== null ? vault.setPassword(vaultKey(provider), previousKey) : vault.deletePassword(vaultKey(provider));
+      await rollback.catch((rollbackErr) => {
+        console.warn(
+          `Failed to roll back vault entry for ${provider} after store write failed:`,
+          rollbackErr
+        );
+      });
+      throw err;
+    }
+    if (provider === "braintrust") await refreshTracing();
+    return c.json({ provider: toApi(provider, meta) });
+  });
+  router.delete("/:provider", async (c) => {
+    const provider = c.req.param("provider");
+    if (!isAIProviderId(provider)) {
+      return c.json({ error: `Unknown provider: ${provider}` }, 400);
+    }
+    await store.remove(provider);
+    await vault.deletePassword(vaultKey(provider));
+    if (provider === "braintrust") await refreshTracing();
+    return c.json({ provider: toApi(provider, null) });
+  });
+  router.post("/:provider/test", async (c) => {
+    const provider = c.req.param("provider");
+    if (!isAIProviderId(provider)) {
+      return c.json({ ok: false, error: `Unknown provider: ${provider}` }, 400);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    let apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+    if (apiKey === "") {
+      const stored = await vault.getPassword(vaultKey(provider));
+      if (stored === null) {
+        return c.json({ ok: false, error: "Missing required field: apiKey" }, 400);
+      }
+      apiKey = stored;
+    }
+    try {
+      await verifyKey(provider, apiKey);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+  });
+  return router;
+}
+
+// server/api/connections.ts
+import crypto3 from "node:crypto";
+import { promises as fs7 } from "node:fs";
+import { Hono as Hono2 } from "hono";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
+
+// server/db/introspect.ts
+var SYSTEM_SCHEMAS = /* @__PURE__ */ new Set(["information_schema", "pg_catalog", "pg_toast"]);
+var QUERY = `
+  SELECT table_schema, table_name, column_name, ordinal_position
+  FROM information_schema.columns
+  WHERE table_schema NOT IN ('information_schema', 'pg_catalog', 'pg_toast')
+    AND table_schema NOT LIKE 'pg_temp_%'
+    AND table_schema NOT LIKE 'pg_toast_temp_%'
+  ORDER BY table_schema, table_name, ordinal_position
+`;
+async function introspect(pool) {
+  const { rows } = await pool.query(QUERY);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (SYSTEM_SCHEMAS.has(row.table_schema)) continue;
+    let schema = grouped.get(row.table_schema);
+    if (!schema) {
+      schema = /* @__PURE__ */ new Map();
+      grouped.set(row.table_schema, schema);
+    }
+    let cols = schema.get(row.table_name);
+    if (!cols) {
+      cols = [];
+      schema.set(row.table_name, cols);
+    }
+    cols.push(row.column_name);
+  }
+  const ns = {};
+  for (const [schemaName, tables] of grouped) {
+    const tableNs = {};
+    for (const [tableName, cols] of tables) {
+      tableNs[tableName] = cols;
+    }
+    if (schemaName === "public") {
+      for (const [tableName, cols] of tables) {
+        ns[tableName] = cols;
+      }
+    }
+    ns[schemaName] = tableNs;
+  }
+  return ns;
+}
+
+// server/db/postgres.ts
+import pg from "pg";
+function clientConfig(conn, password) {
+  return {
+    host: conn.host,
+    port: conn.port,
+    database: conn.database,
+    user: conn.user,
+    password,
+    ssl: conn.ssl ? { rejectUnauthorized: false } : false,
+    // For read-only connections, set the GUC in the startup packet so every
+    // session this pool opens defaults to read-only. Postgres then rejects plain
+    // writes (INSERT/UPDATE/DELETE/DDL) with SQLSTATE 25006 — a guard against
+    // *accidental* writes that needs no client-side SQL parsing.
+    //
+    // Not a hard boundary: default_transaction_read_only is a USERSET GUC, so a
+    // session can re-enable writes with `SET default_transaction_read_only=off`
+    // or `BEGIN READ WRITE`. For a true read-only guarantee, connect as a DB
+    // role that lacks write privileges (or point at a read replica).
+    ...conn.accessMode === "read-only" ? { options: "-c default_transaction_read_only=on" } : {}
+  };
+}
+async function testConnection(conn, password) {
+  const client = new pg.Client({
+    ...clientConfig(conn, password),
+    connectionTimeoutMillis: 5e3
+  });
+  try {
+    await client.connect();
+    await client.query("SELECT 1");
+  } catch (err) {
+    throw normalizePgError(err);
+  } finally {
+    await client.end().catch(() => {
+    });
+  }
+}
+function normalizePgError(err) {
+  if (err instanceof AggregateError) {
+    const messages = err.errors.map((e) => e instanceof Error ? e.message : String(e)).filter(Boolean);
+    return new Error(messages.join("; ") || "Connection failed");
+  }
+  if (err instanceof Error) {
+    const code = err.code;
+    if (!err.message && code) return new Error(code);
+    return err;
+  }
+  return new Error(String(err));
+}
+function createPool(conn, password) {
+  const pool = new pg.Pool({
+    ...clientConfig(conn, password),
+    keepAlive: true,
+    keepAliveInitialDelayMillis: 1e4,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 5e3,
+    max: 5
+  });
+  pool.on("error", (err) => {
+    console.warn(`[pg pool ${conn.name}] idle client error:`, err.message);
+  });
+  return pool;
+}
+var PRE_EXECUTION_CODES = /* @__PURE__ */ new Set(["57P01", "57P02", "57P03"]);
+var SOCKET_DROP_CODES = /* @__PURE__ */ new Set(["ECONNRESET"]);
+var SOCKET_DROP_MESSAGE_PATTERNS = [
+  "Connection terminated",
+  "Client has encountered a connection error",
+  "connection terminated unexpectedly"
+];
+function hasCode(err, codes) {
+  if (!err || typeof err !== "object") return false;
+  const code = err.code;
+  return typeof code === "string" && codes.has(code);
+}
+function hasMessage(err, patterns) {
+  if (!err || typeof err !== "object") return false;
+  const msg = err.message ?? "";
+  return patterns.some((p) => msg.includes(p));
+}
+function isPreExecutionStaleError(err) {
+  return hasCode(err, PRE_EXECUTION_CODES);
+}
+function isSocketDropError(err) {
+  return hasCode(err, SOCKET_DROP_CODES) || hasMessage(err, SOCKET_DROP_MESSAGE_PATTERNS);
+}
+async function runWithRetry(pool, fn, mode = "pre-execution") {
+  try {
+    return await fn(pool);
+  } catch (err) {
+    const retry = isPreExecutionStaleError(err) || mode === "idempotent" && isSocketDropError(err);
+    if (!retry) throw err;
+    return await fn(pool);
+  }
+}
+
+// server/db/registry.ts
+var pools = /* @__PURE__ */ new Map();
+function setPool(id, pool, accessMode) {
+  const prev = pools.get(id);
+  pools.set(id, { pool, accessMode });
+  if (prev && prev.pool !== pool) {
+    void prev.pool.end().catch(() => {
+    });
+  }
+}
+function getPool(id) {
+  return pools.get(id)?.pool;
+}
+function getAccessMode(id) {
+  return pools.get(id)?.accessMode;
+}
+async function removePool(id) {
+  const entry = pools.get(id);
+  if (!entry) return;
+  pools.delete(id);
+  await entry.pool.end().catch(() => {
+  });
+}
+function activeIds() {
+  return new Set(pools.keys());
+}
+async function closeAll() {
+  const entries = Array.from(pools.values());
+  pools.clear();
+  await Promise.all(entries.map((entry) => entry.pool.end().catch(() => {
+  })));
+}
+
+// server/lib/fs-atomic.ts
+import { promises as fs5 } from "node:fs";
+import path5 from "node:path";
+import { randomBytes } from "node:crypto";
+async function writeAtomic(filePath2, content) {
+  const dir = path5.dirname(filePath2);
+  const tmp = path5.join(dir, `.${path5.basename(filePath2)}.${randomBytes(4).toString("hex")}.tmp`);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(tmp, content);
+  await fs5.rename(tmp, filePath2);
+}
+
+// server/storage/connections.ts
+import { promises as fs6 } from "node:fs";
+import path6 from "node:path";
+function normalize(conn) {
+  return {
+    ...conn,
+    accessMode: conn.accessMode === "read-only" ? "read-only" : "read-write"
+  };
+}
+var FILE4 = "connections.json";
+var ConnectionStore = class {
+  constructor(workspace) {
+    this.workspace = workspace;
+  }
+  // Serializes read-modify-write cycles so concurrent add/remove calls
+  // don't clobber each other.
+  queue = Promise.resolve();
+  enqueue(fn) {
+    const next = this.queue.then(fn, fn);
+    this.queue = next.catch(() => {
+    });
+    return next;
+  }
+  get filePath() {
+    return path6.join(this.workspace, FILE4);
+  }
+  async list() {
+    try {
+      const raw = await fs6.readFile(this.filePath, "utf8");
+      const data = JSON.parse(raw);
+      return Array.isArray(data.connections) ? data.connections.map(normalize) : [];
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async get(id) {
+    const all = await this.list();
+    return all.find((c) => c.id === id) ?? null;
+  }
+  add(conn) {
+    return this.enqueue(async () => {
+      const existing = await this.list();
+      await this.write([...existing.filter((c) => c.id !== conn.id), conn]);
+    });
+  }
+  remove(id) {
+    return this.enqueue(async () => {
+      const existing = await this.list();
+      await this.write(existing.filter((c) => c.id !== id));
+    });
+  }
+  // Apply a partial patch to one connection's metadata. Returns the updated
+  // record, or null if no connection has that id. id/createdAt are immutable.
+  update(id, patch) {
+    return this.enqueue(async () => {
+      const existing = await this.list();
+      const current = existing.find((c) => c.id === id);
+      if (!current) return null;
+      const updated = normalize({ ...current, ...patch, id: current.id });
+      await this.write(existing.map((c) => c.id === id ? updated : c));
+      return updated;
+    });
+  }
+  async write(connections) {
+    await fs6.mkdir(this.workspace, { recursive: true });
+    await fs6.writeFile(
+      this.filePath,
+      JSON.stringify({ connections }, null, 2) + "\n",
+      "utf8"
+    );
+  }
+};
+
+// server/api/connections.ts
+var MAX_ROWS = 1e3;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertSafeConnectionId2(id) {
+  if (!UUID_RE.test(id)) {
+    throw new HTTPException2(400, { message: `Invalid connection id` });
+  }
+}
+async function writeConnectionSchema(id, schema) {
+  await writeAtomic(paths.connectionSchema(id), JSON.stringify(schema, null, 2));
+}
+function parseInput(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new Error("Invalid request body");
+  }
+  const b = body;
+  const requireStr = (v, field) => {
+    if (typeof v !== "string" || v.trim() === "") {
+      throw new Error(`Missing required field: ${field}`);
+    }
+    return v.trim();
+  };
+  const parsePort = (v) => {
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+      throw new Error(`Invalid port: must be an integer in [1, 65535]`);
+    }
+    return n;
+  };
+  return {
+    name: requireStr(b.name, "name"),
+    driver: "postgres",
+    host: requireStr(b.host, "host"),
+    port: parsePort(b.port ?? 5432),
+    database: requireStr(b.database, "database"),
+    user: requireStr(b.user, "user"),
+    password: typeof b.password === "string" ? b.password : "",
+    ssl: Boolean(b.ssl),
+    // Secure by default: a new connection is read-only unless the caller
+    // explicitly asks for "read-write". The client dialog sends an explicit
+    // mode; this default only governs direct API callers that omit it. (Legacy
+    // *stored* connections without the field stay read-write — see
+    // storage/connections.ts — so upgrading never silently revokes writes.)
+    accessMode: b.accessMode === "read-write" ? "read-write" : "read-only"
+  };
+}
+function parsePatch(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new Error("Invalid request body");
+  }
+  const b = body;
+  const patch = {};
+  const requireStr = (v, field) => {
+    if (typeof v !== "string" || v.trim() === "") {
+      throw new Error(`Missing required field: ${field}`);
+    }
+    return v.trim();
+  };
+  if ("name" in b) patch.name = requireStr(b.name, "name");
+  if ("host" in b) patch.host = requireStr(b.host, "host");
+  if ("port" in b) {
+    const n = typeof b.port === "number" ? b.port : Number(b.port);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+      throw new Error("Invalid port: must be an integer in [1, 65535]");
+    }
+    patch.port = n;
+  }
+  if ("database" in b) patch.database = requireStr(b.database, "database");
+  if ("user" in b) patch.user = requireStr(b.user, "user");
+  if ("ssl" in b) patch.ssl = Boolean(b.ssl);
+  if ("accessMode" in b) {
+    if (b.accessMode !== "read-only" && b.accessMode !== "read-write") {
+      throw new Error("accessMode must be 'read-only' or 'read-write'");
+    }
+    patch.accessMode = b.accessMode;
+  }
+  const password = typeof b.password === "string" && b.password !== "" ? b.password : void 0;
+  return { patch, password };
+}
+function toApi2(conn, active) {
+  return { ...conn, active: active.has(conn.id) };
+}
+function buildProbe(input) {
+  return {
+    id: "probe",
+    name: input.name,
+    driver: "postgres",
+    host: input.host,
+    port: input.port,
+    database: input.database,
+    user: input.user,
+    ssl: input.ssl,
+    accessMode: input.accessMode,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function connectStored(id, store, vault, mode = "replace") {
+  const conn = await store.get(id);
+  if (!conn) return { ok: false, error: "not_found", status: 404 };
+  const password = await vault.getPassword(id);
+  if (password === null) {
+    return { ok: false, error: "missing_credentials", status: 400 };
+  }
+  const pool = createPool(conn, password);
+  try {
+    const client = await pool.connect();
+    try {
+      await client.query("SELECT 1");
+    } finally {
+      client.release();
+    }
+    if (mode === "claim" && getPool(id)) {
+      await pool.end().catch(() => {
+      });
+      return { ok: true };
+    }
+    setPool(id, pool, conn.accessMode);
+    void introspect(pool).then((ns) => writeConnectionSchema(id, ns)).catch((err) => console.warn(`[introspect ${id}]`, err));
+    return { ok: true };
+  } catch (err) {
+    await pool.end().catch(() => {
+    });
+    return { ok: false, error: normalizePgError(err).message, status: 400 };
+  }
+}
+async function autoConnectAll(workspace) {
+  const store = new ConnectionStore(workspace);
+  const vault = new CredentialVault(workspace);
+  const connections = await store.list();
+  await Promise.all(
+    connections.map(async (conn) => {
+      if (getPool(conn.id)) return;
+      const result = await connectStored(conn.id, store, vault, "claim");
+      if (result.ok) {
+        console.log(`[auto-connect] ${conn.name} (${conn.id})`);
+      } else if (result.error !== "missing_credentials") {
+        console.warn(`[auto-connect] ${conn.name}: ${result.error}`);
+      }
+    })
+  );
+}
+function connectionsRouter(workspace) {
+  const router = new Hono2();
+  const store = new ConnectionStore(workspace);
+  const vault = new CredentialVault(workspace);
+  router.get("/", async (c) => {
+    const connections = await store.list();
+    const active = activeIds();
+    return c.json({ connections: connections.map((conn) => toApi2(conn, active)) });
+  });
+  router.post("/", async (c) => {
+    let input;
+    try {
+      input = parseInput(await c.req.json());
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+    const stored = {
+      id: crypto3.randomUUID(),
+      name: input.name,
+      driver: "postgres",
+      host: input.host,
+      port: input.port,
+      database: input.database,
+      user: input.user,
+      ssl: input.ssl,
+      accessMode: input.accessMode,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await store.add(stored);
+    if (input.password) await vault.setPassword(stored.id, input.password);
+    return c.json({ connection: toApi2(stored, activeIds()) }, 201);
+  });
+  router.patch("/:id", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    let parsed;
+    try {
+      parsed = parsePatch(await c.req.json());
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+    const updated = await store.update(id, parsed.patch);
+    if (!updated) return c.json({ error: "not_found" }, 404);
+    if (parsed.password !== void 0) {
+      await vault.setPassword(id, parsed.password);
+    }
+    if (getPool(id)) {
+      const result = await connectStored(id, store, vault);
+      if (!result.ok) {
+        await removePool(id);
+        return c.json({ ok: false, error: result.error }, 400);
+      }
+    }
+    return c.json({ connection: toApi2(updated, activeIds()) });
+  });
+  router.delete("/:id", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    await removePool(id);
+    await vault.deletePassword(id);
+    await store.remove(id);
+    await fs7.rm(paths.connectionSchema(id), { force: true }).catch(() => {
+    });
+    return c.json({ ok: true });
+  });
+  router.post("/test", async (c) => {
+    let input;
+    try {
+      input = parseInput(await c.req.json());
+    } catch (err) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+    try {
+      await testConnection(buildProbe(input), input.password);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+  });
+  router.post("/:id/test", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    let input;
+    try {
+      input = parseInput(await c.req.json());
+    } catch (err) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+    let password = input.password;
+    if (!password) {
+      const stored = await vault.getPassword(id);
+      if (stored === null) {
+        return c.json(
+          { ok: false, error: "No stored password \u2014 enter one to test." },
+          400
+        );
+      }
+      password = stored;
+    }
+    try {
+      await testConnection(buildProbe(input), password);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err.message }, 400);
+    }
+  });
+  router.post("/:id/connect", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    const result = await connectStored(id, store, vault);
+    if (result.ok) return c.json({ ok: true });
+    if (result.error === "not_found") return c.json({ error: "not_found" }, 404);
+    return c.json({ ok: false, error: result.error }, 400);
+  });
+  router.post("/:id/query", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    const pool = getPool(id);
+    if (!pool) return c.json({ ok: false, error: "not_connected" }, 409);
+    let sql;
+    try {
+      const body = await c.req.json();
+      if (typeof body.sql !== "string" || body.sql.trim() === "") {
+        return c.json({ ok: false, error: "Missing sql" }, 400);
+      }
+      sql = body.sql;
+    } catch {
+      return c.json({ ok: false, error: "Invalid JSON body" }, 400);
+    }
+    const started = Date.now();
+    try {
+      const result = await runWithRetry(
+        pool,
+        (p) => p.query({ text: sql, rowMode: "array" })
+      );
+      const durationMs = Date.now() - started;
+      const allRows = Array.isArray(result.rows) ? result.rows : [];
+      const truncated = allRows.length > MAX_ROWS;
+      const rows = truncated ? allRows.slice(0, MAX_ROWS) : allRows;
+      const payload = {
+        ok: true,
+        columns: (result.fields ?? []).map((f) => ({
+          name: f.name,
+          dataTypeID: f.dataTypeID
+        })),
+        rows,
+        rowCount: typeof result.rowCount === "number" ? result.rowCount : rows.length,
+        durationMs,
+        truncated
+      };
+      return c.json(payload);
+    } catch (err) {
+      const normalized = normalizePgError(err);
+      const code = err?.code;
+      return c.json({ ok: false, error: normalized.message, code }, 200);
+    }
+  });
+  router.get("/:id/schema", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    try {
+      const raw = await fs7.readFile(paths.connectionSchema(id), "utf8");
+      return c.json(JSON.parse(raw));
+    } catch {
+      return c.json({});
+    }
+  });
+  router.post("/:id/schema/refresh", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    const pool = getPool(id);
+    if (!pool) return c.json({ ok: false, error: "not_connected" }, 409);
+    try {
+      const schema = await runWithRetry(pool, (p) => introspect(p), "idempotent");
+      await writeConnectionSchema(id, schema);
+      return c.json(schema);
+    } catch (err) {
+      return c.json({ ok: false, error: normalizePgError(err).message }, 500);
+    }
+  });
+  router.post("/:id/disconnect", async (c) => {
+    const id = c.req.param("id");
+    assertSafeConnectionId2(id);
+    await removePool(id);
+    return c.json({ ok: true });
+  });
+  return router;
+}
+
+// server/api/worksheets.ts
+import { Hono as Hono3 } from "hono";
+import { promises as fs9 } from "node:fs";
+import path8 from "node:path";
+
+// server/lib/slug.ts
+function slugify(name) {
+  const base = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return base || "worksheet";
+}
+function dedupeSlug(slug, existing) {
+  if (!existing.has(slug)) return slug;
+  let n = 2;
+  while (existing.has(`${slug}-${n}`)) n++;
+  return `${slug}-${n}`;
+}
+
+// server/history/record.ts
+import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
+
+// server/history/db.ts
+import Database from "better-sqlite3";
+var SCHEMA = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+PRAGMA synchronous = NORMAL;
+
+CREATE TABLE IF NOT EXISTS blobs (
+  sha       TEXT PRIMARY KEY,
+  bytes     BLOB NOT NULL,
+  size      INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS entries (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  worksheet TEXT NOT NULL,
+  ts        INTEGER NOT NULL,
+  source    TEXT NOT NULL,
+  blob_sha  TEXT NOT NULL REFERENCES blobs(sha),
+  size      INTEGER NOT NULL,
+  label     TEXT,
+  meta      TEXT,
+  preview   TEXT NOT NULL DEFAULT ''
+);
+
+CREATE INDEX IF NOT EXISTS idx_entries_worksheet_ts ON entries(worksheet, ts DESC);
+`;
+var db = null;
+function openHistoryDb() {
+  if (db) return db;
+  db = new Database(paths.history());
+  db.exec(SCHEMA);
+  return db;
+}
+function closeHistoryDb() {
+  if (!db) return;
+  db.close();
+  db = null;
+}
+
+// server/history/dedup.ts
+var TTL_MS = 5e3;
+var recent = /* @__PURE__ */ new Map();
+function noteRecentWrite(slug, sha) {
+  let set = recent.get(slug);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    recent.set(slug, set);
+  }
+  set.add(sha);
+  const t = setTimeout(() => {
+    const s = recent.get(slug);
+    if (!s) return;
+    s.delete(sha);
+    if (s.size === 0) recent.delete(slug);
+  }, TTL_MS);
+  t.unref?.();
+}
+function isRecentWrite(slug, sha) {
+  return recent.get(slug)?.has(sha) ?? false;
+}
+
+// server/history/record.ts
+var MERGE_WINDOW_MS = 1e4;
+var MAX_ENTRIES_PER_WORKSHEET = 50;
+var MAX_ENTRY_SIZE = 256 * 1024;
+var PREVIEW_MAX_LEN = 120;
+var SOURCE_RANK = {
+  autosave: 0,
+  external: 1,
+  snapshot: 1,
+  save: 2,
+  revert: 3
+};
+function sha256(s) {
+  return createHash("sha256").update(s, "utf8").digest("hex");
+}
+function buildPreview(content) {
+  const line = content.split("\n").find((l) => l.trim().length > 0) ?? "";
+  return line.length > PREVIEW_MAX_LEN ? line.slice(0, PREVIEW_MAX_LEN) + "\u2026" : line;
+}
+function recordHistory(opts) {
+  assertSafeSlug(opts.worksheet);
+  const size = Buffer.byteLength(opts.content, "utf8");
+  if (size > MAX_ENTRY_SIZE) {
+    console.warn(`[history] skipping ${opts.worksheet}: ${size} bytes exceeds cap`);
+    return { recorded: false, skipped: "oversize" };
+  }
+  const db2 = openHistoryDb();
+  const ts = opts.ts ?? Date.now();
+  const sha = sha256(opts.content);
+  const prev = db2.prepare(
+    `SELECT id, ts, source, blob_sha FROM entries WHERE worksheet = ? ORDER BY ts DESC LIMIT 1`
+  ).get(opts.worksheet);
+  if (prev && prev.blob_sha === sha) {
+    if (SOURCE_RANK[opts.source] > SOURCE_RANK[prev.source]) {
+      db2.prepare(
+        `UPDATE entries SET ts = ?, source = ?, label = COALESCE(?, label), meta = COALESCE(?, meta)
+           WHERE id = ?`
+      ).run(
+        ts,
+        opts.source,
+        opts.label ?? null,
+        opts.meta ? JSON.stringify(opts.meta) : null,
+        prev.id
+      );
+    }
+    return { recorded: true };
+  }
+  const canCoalesce = !!prev && opts.source === "autosave" && prev.source === "autosave" && ts - prev.ts < MERGE_WINDOW_MS;
+  const compressed = gzipSync(Buffer.from(opts.content, "utf8"));
+  const preview = buildPreview(opts.content);
+  const insertBlob = db2.prepare(
+    `INSERT OR IGNORE INTO blobs (sha, bytes, size) VALUES (?, ?, ?)`
+  );
+  const insertEntry = db2.prepare(
+    `INSERT INTO entries (worksheet, ts, source, blob_sha, size, label, meta, preview)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const deleteById = db2.prepare(`DELETE FROM entries WHERE id = ?`);
+  const tx = db2.transaction(() => {
+    insertBlob.run(sha, compressed, size);
+    const coalesced = !!(canCoalesce && prev) && deleteById.run(prev.id).changes > 0;
+    insertEntry.run(
+      opts.worksheet,
+      ts,
+      opts.source,
+      sha,
+      size,
+      opts.label ?? null,
+      opts.meta ? JSON.stringify(opts.meta) : null,
+      preview
+    );
+    const evicted = enforcePerWorksheetCap(opts.worksheet);
+    if (coalesced || evicted) gcOrphanBlobs();
+  });
+  tx();
+  noteRecentWrite(opts.worksheet, sha);
+  return { recorded: true };
+}
+function enforcePerWorksheetCap(worksheet) {
+  const db2 = openHistoryDb();
+  const { n } = db2.prepare(`SELECT COUNT(*) as n FROM entries WHERE worksheet = ?`).get(worksheet);
+  if (n <= MAX_ENTRIES_PER_WORKSHEET) return false;
+  const result = db2.prepare(
+    `DELETE FROM entries WHERE id IN (
+         SELECT id FROM entries WHERE worksheet = ? ORDER BY ts ASC LIMIT ?
+       )`
+  ).run(worksheet, n - MAX_ENTRIES_PER_WORKSHEET);
+  return result.changes > 0;
+}
+function gcOrphanBlobs() {
+  const db2 = openHistoryDb();
+  db2.prepare(
+    `DELETE FROM blobs WHERE sha NOT IN (SELECT DISTINCT blob_sha FROM entries)`
+  ).run();
+}
+
+// server/history/query.ts
+import { gunzipSync } from "node:zlib";
+function rowToEntry(row) {
+  return {
+    id: row.id,
+    worksheet: row.worksheet,
+    ts: row.ts,
+    source: row.source,
+    size: row.size,
+    label: row.label,
+    meta: row.meta ? JSON.parse(row.meta) : null,
+    preview: row.preview,
+    contentSha: row.blob_sha
+  };
+}
+function listEntries(worksheet) {
+  assertSafeSlug(worksheet);
+  const db2 = openHistoryDb();
+  const rows = db2.prepare(
+    `SELECT id, worksheet, ts, source, blob_sha, size, label, meta, preview
+         FROM entries WHERE worksheet = ? ORDER BY ts DESC`
+  ).all(worksheet);
+  return rows.map(rowToEntry);
+}
+function hasEntries(worksheet) {
+  assertSafeSlug(worksheet);
+  const db2 = openHistoryDb();
+  const row = db2.prepare(`SELECT 1 as one FROM entries WHERE worksheet = ? LIMIT 1`).get(worksheet);
+  return !!row;
+}
+function getEntry(worksheet, id) {
+  assertSafeSlug(worksheet);
+  const db2 = openHistoryDb();
+  const row = db2.prepare(
+    `SELECT e.id, e.worksheet, e.ts, e.source, e.blob_sha, e.size, e.label, e.meta, e.preview, b.bytes
+         FROM entries e JOIN blobs b ON b.sha = e.blob_sha
+         WHERE e.worksheet = ? AND e.id = ?`
+  ).get(worksheet, id);
+  if (!row) return null;
+  const content = gunzipSync(row.bytes).toString("utf8");
+  return { ...rowToEntry(row), content };
+}
+async function revertToEntry(worksheet, id) {
+  const entry = getEntry(worksheet, id);
+  if (!entry) return null;
+  recordHistory({
+    worksheet,
+    source: "revert",
+    content: entry.content,
+    meta: { revertedFromEntryId: id }
+  });
+  await writeAtomic(paths.worksheet(worksheet), entry.content);
+  return entry;
+}
+function deleteWorksheetHistory(worksheet) {
+  assertSafeSlug(worksheet);
+  const db2 = openHistoryDb();
+  const tx = db2.transaction(() => {
+    db2.prepare(`DELETE FROM entries WHERE worksheet = ?`).run(worksheet);
+    db2.prepare(
+      `DELETE FROM blobs WHERE sha NOT IN (SELECT DISTINCT blob_sha FROM entries)`
+    ).run();
+  });
+  tx();
+}
+
+// server/storage/worksheet-names.ts
+import { promises as fs8 } from "node:fs";
+import path7 from "node:path";
+var FILE5 = path7.join(".os-dpt", "worksheet-names.json");
+function filePath() {
+  return path7.join(workspaceRoot(), FILE5);
+}
+async function readNames() {
+  try {
+    const raw = await fs8.readFile(filePath(), "utf8");
+    const data = JSON.parse(raw);
+    return data.names ?? {};
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function getName(slug) {
+  const all = await readNames();
+  return all[slug] ?? null;
+}
+async function writeNames(all) {
+  await writeAtomic(filePath(), JSON.stringify({ names: all }, null, 2) + "\n");
+}
+var queue = Promise.resolve();
+function enqueue(fn) {
+  const next = queue.then(fn, fn);
+  queue = next.catch(() => {
+  });
+  return next;
+}
+function setName(slug, name) {
+  return enqueue(async () => {
+    const all = await readNames();
+    if (all[slug] === name) return;
+    all[slug] = name;
+    await writeNames(all);
+  });
+}
+function deleteName(slug) {
+  return enqueue(async () => {
+    const all = await readNames();
+    if (!(slug in all)) return;
+    delete all[slug];
+    await writeNames(all);
+  });
+}
+
+// server/agent/naming.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+
+// server/agent/provider.ts
+import Anthropic from "@anthropic-ai/sdk";
+var DEFAULT_MODEL = process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4-6";
+var DEFAULT_MAX_TOKENS = 4096;
+var MissingApiKeyError = class extends Error {
+  constructor() {
+    super("Anthropic API key not configured. Add one in Settings \u2192 AI providers.");
+    this.name = "MissingApiKeyError";
+  }
+};
+var cachedKey = null;
+async function getAnthropicKey() {
+  if (cachedKey) return cachedKey;
+  const vault = new CredentialVault(workspaceRoot());
+  const key = await vault.getPassword("ai:anthropic");
+  if (!key) throw new MissingApiKeyError();
+  cachedKey = key;
+  return key;
+}
+var CACHE_CONTROL = { type: "ephemeral" };
+function cachedSystem(system) {
+  return [{ type: "text", text: system, cache_control: CACHE_CONTROL }];
+}
+function withConversationCacheBreakpoint(messages) {
+  if (messages.length === 0) return messages;
+  const out = messages.slice();
+  const last = out[out.length - 1];
+  const blocks = typeof last.content === "string" ? [{ type: "text", text: last.content }] : last.content.slice();
+  if (blocks.length === 0) return messages;
+  blocks[blocks.length - 1] = {
+    ...blocks[blocks.length - 1],
+    cache_control: CACHE_CONTROL
+  };
+  out[out.length - 1] = { ...last, content: blocks };
+  return out;
+}
+async function streamAssistantMessage(p) {
+  const client = new Anthropic({ apiKey: p.apiKey });
+  const model = p.model ?? DEFAULT_MODEL;
+  const maxTokens = p.maxTokens ?? DEFAULT_MAX_TOKENS;
+  return traced(
+    {
+      name: "anthropic.messages",
+      type: "llm",
+      event: {
+        input: [
+          { role: "system", content: p.system },
+          ...p.messages
+        ],
+        metadata: {
+          model,
+          max_tokens: maxTokens,
+          provider: "anthropic",
+          tools: p.tools.map((t) => t.name)
+        }
+      }
+    },
+    async (span) => {
+      const stream = client.messages.stream({
+        model,
+        max_tokens: maxTokens,
+        system: cachedSystem(p.system),
+        messages: withConversationCacheBreakpoint(p.messages),
+        tools: p.tools,
+        // One tool_use per assistant turn so the loop can cleanly handle the
+        // ask_user_question pause without leaving sibling tool_use blocks
+        // without matching tool_results.
+        tool_choice: { type: "auto", disable_parallel_tool_use: true }
+      });
+      if (p.onTextDelta) {
+        stream.on("text", (delta) => p.onTextDelta?.(delta));
+      }
+      const message = await stream.finalMessage();
+      const usage = message.usage;
+      const cachedRead = usage.cache_read_input_tokens ?? 0;
+      const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+      const promptTokens = (usage.input_tokens ?? 0) + cachedRead + cacheCreation;
+      const completionTokens = usage.output_tokens ?? 0;
+      span.log({
+        output: message.content,
+        metadata: { stop_reason: message.stop_reason },
+        metrics: {
+          prompt_tokens: promptTokens,
+          completion_tokens: completionTokens,
+          total_tokens: promptTokens + completionTokens,
+          prompt_cached_tokens: cachedRead,
+          prompt_cache_creation_tokens: cacheCreation
+        }
+      });
+      return { message, model, usage };
+    }
+  );
+}
+
+// server/agent/naming.ts
+var NAMING_MODEL = "claude-haiku-4-5-20251001";
+var MAX_INPUT_CHARS = 2e3;
+var MAX_NAME_CHARS = 60;
+var SQL_SYSTEM_PROMPT = "You name SQL queries. Given a SQL snippet, respond with a concise 2-5 word title in Title Case. No quotes, no punctuation, no preamble. Just the title.";
+var CHAT_SYSTEM_PROMPT = "You name chat conversations. Given the user's first message, respond with a concise 2-5 word title in Title Case summarizing the topic. No quotes, no punctuation, no preamble. Just the title.";
+function sanitize(raw) {
+  let s = raw.trim();
+  s = s.replace(/^["'`“”‘’]+|["'`“”‘’]+$/g, "");
+  s = s.replace(/\s+/g, " ").trim();
+  s = s.replace(/[.!?;:,]+$/, "").trim();
+  if (s.length > MAX_NAME_CHARS) s = s.slice(0, MAX_NAME_CHARS).trim();
+  return s;
+}
+async function generateTitle(input, systemPrompt) {
+  const apiKey = await getAnthropicKey();
+  const snippet = input.length > MAX_INPUT_CHARS ? input.slice(0, MAX_INPUT_CHARS) : input;
+  const client = new Anthropic2({ apiKey });
+  const msg = await client.messages.create({
+    model: NAMING_MODEL,
+    max_tokens: 32,
+    system: systemPrompt,
+    messages: [{ role: "user", content: snippet }]
+  });
+  const text = msg.content.map((block) => block.type === "text" ? block.text : "").join("");
+  const name = sanitize(text);
+  if (!name) throw new Error("Empty name from model");
+  return name;
+}
+function generateWorksheetName(sql) {
+  return generateTitle(sql, SQL_SYSTEM_PROMPT);
+}
+function generateChatTitle(prompt) {
+  return generateTitle(prompt, CHAT_SYSTEM_PROMPT);
+}
+
+// server/api/worksheets.ts
+var app = new Hono3();
+var MAX_NAME_LEN = 80;
+async function listMetas() {
+  const dir = paths.worksheets();
+  const entries = await fs9.readdir(dir).catch(() => []);
+  const sqls = entries.filter((f) => f.endsWith(".sql"));
+  const names = await readNames();
+  const metas = await Promise.all(
+    sqls.map(async (f) => {
+      const slug = f.slice(0, -4);
+      const stat = await fs9.stat(path8.join(dir, f));
+      return {
+        slug,
+        name: names[slug] ?? slug,
+        updatedAt: stat.mtime.toISOString()
+      };
+    })
+  );
+  metas.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return metas;
+}
+async function metaFor(slug) {
+  const stat = await fs9.stat(paths.worksheet(slug));
+  const name = await getName(slug) ?? slug;
+  return { slug, name, updatedAt: stat.mtime.toISOString() };
+}
+async function readDraft(slug) {
+  try {
+    return await fs9.readFile(paths.draft(slug), "utf8");
+  } catch {
+    return null;
+  }
+}
+app.get("/", async (c) => {
+  return c.json({ worksheets: await listMetas() });
+});
+var SEARCH_MAX_HITS = 50;
+var SEARCH_SNIPPET_LEN = 120;
+app.get("/search", async (c) => {
+  const q = (c.req.query("q") ?? "").trim();
+  if (q === "") return c.json({ hits: [] });
+  const needle = q.toLowerCase();
+  const metas = await listMetas();
+  const hits = [];
+  for (const meta of metas) {
+    if (hits.length >= SEARCH_MAX_HITS) break;
+    const slugHit = meta.slug.toLowerCase().includes(needle);
+    let content = "";
+    try {
+      content = await fs9.readFile(paths.worksheet(meta.slug), "utf8");
+    } catch {
+    }
+    const lower = content.toLowerCase();
+    const idx = lower.indexOf(needle);
+    if (!slugHit && idx === -1) continue;
+    let snippet = "";
+    let lineNumber;
+    if (idx !== -1) {
+      const lineStart = lower.lastIndexOf("\n", idx) + 1;
+      const lineEndRaw = lower.indexOf("\n", idx);
+      const lineEnd = lineEndRaw === -1 ? content.length : lineEndRaw;
+      const line = content.slice(lineStart, lineEnd);
+      snippet = line.length > SEARCH_SNIPPET_LEN ? line.slice(0, SEARCH_SNIPPET_LEN) + "\u2026" : line;
+      lineNumber = lower.slice(0, lineStart).split("\n").length;
+    }
+    hits.push({ slug: meta.slug, name: meta.name, snippet, lineNumber });
+  }
+  return c.json({ hits });
+});
+app.post("/", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const desired = slugify(body.name ?? "untitled");
+  const existing = new Set((await listMetas()).map((m) => m.slug));
+  const slug = dedupeSlug(desired, existing);
+  recordHistory({ worksheet: slug, source: "save", content: "" });
+  await writeAtomic(paths.worksheet(slug), "");
+  return c.json(await metaFor(slug));
+});
+app.get("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const file = paths.worksheet(slug);
+  let content;
+  try {
+    content = await fs9.readFile(file, "utf8");
+  } catch {
+    return c.json({ error: "not_found" }, 404);
+  }
+  const stat = await fs9.stat(file);
+  if (!hasEntries(slug)) {
+    recordHistory({ worksheet: slug, source: "snapshot", content, ts: stat.mtimeMs });
+  }
+  const draftContent = await readDraft(slug);
+  const meta = await metaFor(slug);
+  const payload = { meta, content, draftContent };
+  return c.json(payload);
+});
+app.put("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const { content } = await c.req.json();
+  const result = recordHistory({ worksheet: slug, source: "save", content });
+  await writeAtomic(paths.worksheet(slug), content);
+  const meta = await metaFor(slug);
+  return c.json({ ...meta, historySkipped: result.skipped ?? null });
+});
+app.patch("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const body = await c.req.json().catch(() => ({}));
+  const raw = (body.name ?? "").trim();
+  if (!raw) return c.json({ error: "empty_name" }, 400);
+  const name = raw.length > MAX_NAME_LEN ? raw.slice(0, MAX_NAME_LEN) : raw;
+  await setName(slug, name);
+  return c.json(await metaFor(slug));
+});
+app.post("/:slug/auto-name", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const existing = await getName(slug);
+  if (existing && existing !== slug) {
+    return c.json({ name: existing, skipped: true, reason: "already-named" });
+  }
+  const body = await c.req.json().catch(() => ({}));
+  let sql = (body.sql ?? "").trim();
+  if (!sql) {
+    try {
+      sql = (await fs9.readFile(paths.draft(slug), "utf8")).trim();
+    } catch {
+    }
+  }
+  if (!sql) {
+    try {
+      sql = (await fs9.readFile(paths.worksheet(slug), "utf8")).trim();
+    } catch {
+      return c.json({ error: "not_found" }, 404);
+    }
+  }
+  if (!sql) {
+    return c.json({ name: slug, skipped: true, reason: "empty" });
+  }
+  try {
+    const name = await generateWorksheetName(sql);
+    await setName(slug, name);
+    return c.json({ name, skipped: false });
+  } catch (err) {
+    const message = err.message;
+    console.warn(`auto-name failed for ${slug}:`, message);
+    return c.json({ name: slug, skipped: true, reason: "model-error", error: message });
+  }
+});
+app.delete("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  await fs9.rm(paths.worksheet(slug), { force: true });
+  await fs9.rm(paths.draft(slug), { force: true });
+  deleteWorksheetHistory(slug);
+  await deleteName(slug);
+  return c.json({ ok: true });
+});
+var worksheets_default = app;
+
+// server/api/drafts.ts
+import { Hono as Hono4 } from "hono";
+import { promises as fs10 } from "node:fs";
+var app2 = new Hono4();
+app2.put("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const { content } = await c.req.json();
+  const result = recordHistory({ worksheet: slug, source: "autosave", content });
+  await writeAtomic(paths.draft(slug), content);
+  return c.json({ ok: true, historySkipped: result.skipped ?? null });
+});
+app2.delete("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  await fs10.rm(paths.draft(slug), { force: true });
+  return c.json({ ok: true });
+});
+var drafts_default = app2;
+
+// server/api/session.ts
+import { Hono as Hono5 } from "hono";
+import { promises as fs11 } from "node:fs";
+var app3 = new Hono5();
+var EMPTY = { openTabs: [], activeSlug: null, resultsPaneSize: null };
+app3.get("/", async (c) => {
+  try {
+    const raw = await fs11.readFile(paths.session(), "utf8");
+    return c.json(JSON.parse(raw));
+  } catch {
+    return c.json(EMPTY);
+  }
+});
+app3.put("/", async (c) => {
+  const body = await c.req.json();
+  await writeAtomic(paths.session(), JSON.stringify(body, null, 2));
+  return c.json({ ok: true });
+});
+var session_default = app3;
+
+// server/api/schema.ts
+import { Hono as Hono6 } from "hono";
+import { promises as fs12 } from "node:fs";
+var app4 = new Hono6();
+var EMPTY2 = {};
+app4.get("/", async (c) => {
+  try {
+    const raw = await fs12.readFile(paths.schema(), "utf8");
+    return c.json(JSON.parse(raw));
+  } catch {
+    return c.json(EMPTY2);
+  }
+});
+var schema_default = app4;
+
+// server/api/history.ts
+import { Hono as Hono7 } from "hono";
+import { promises as fs13 } from "node:fs";
+
+// server/history/git.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import path9 from "node:path";
+var exec2 = promisify2(execFile2);
+var MAX_BUFFER = 4 * 1024 * 1024;
+var TIMEOUT_MS = 5e3;
+function worksheetRelPath(slug) {
+  return path9.posix.join("worksheets", `${slug}.sql`);
+}
+var HEADER = "__osdpt_commit__\0";
+var HEADER_LINE = /^__osdpt_commit__\0[0-9a-f]{40}\0/;
+async function listGitCommits(slug) {
+  const cwd = workspaceRoot();
+  try {
+    const { stdout } = await exec2(
+      "git",
+      [
+        "log",
+        // --follow walks through renames so a worksheet's pre-rename history
+        // still shows up in the timeline.
+        "--follow",
+        // --raw lines (`:mode mode srcSha dstSha STATUS\tpath`) give us the
+        // post-change blob sha per commit, so the client can drop entries
+        // identical to the current editor buffer.
+        "--raw",
+        "--no-abbrev",
+        `--format=__osdpt_commit__%x00%H%x00%ct%x00%an%x00%s`,
+        "--",
+        worksheetRelPath(slug)
+      ],
+      { cwd, maxBuffer: MAX_BUFFER, timeout: TIMEOUT_MS }
+    );
+    const items = [];
+    let pending = null;
+    const flush = () => {
+      if (pending) items.push(pending);
+      pending = null;
+    };
+    for (const line of stdout.split("\n")) {
+      if (HEADER_LINE.test(line)) {
+        flush();
+        const [sha, ct, an, subject] = line.slice(HEADER.length).split("\0");
+        pending = {
+          kind: "git",
+          sha,
+          ts: Number(ct) * 1e3,
+          author: an || null,
+          subject: subject || "",
+          contentSha: null
+        };
+      } else if (line.startsWith(":") && pending && pending.contentSha === null) {
+        const prefix = line.split("	", 1)[0];
+        const dst = prefix.split(" ")[3];
+        if (dst && /^[0-9a-f]{40}$/.test(dst)) pending.contentSha = dst;
+      }
+    }
+    flush();
+    return items;
+  } catch {
+    return [];
+  }
+}
+async function readFileAtCommit(sha, slug) {
+  const cwd = workspaceRoot();
+  try {
+    const { stdout } = await exec2("git", ["show", `${sha}:${worksheetRelPath(slug)}`], {
+      cwd,
+      maxBuffer: MAX_BUFFER,
+      timeout: TIMEOUT_MS
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+
+// server/history/timeline.ts
+async function buildTimeline(slug) {
+  const entries = listEntries(slug);
+  const commits = await listGitCommits(slug);
+  const items = [
+    ...entries.map((entry) => ({ kind: "history", entry })),
+    ...commits
+  ];
+  items.sort((a, b) => {
+    const at = a.kind === "history" ? a.entry.ts : a.ts;
+    const bt2 = b.kind === "history" ? b.entry.ts : b.ts;
+    return bt2 - at;
+  });
+  return items;
+}
+
+// server/api/history.ts
+var app5 = new Hono7();
+app5.get("/:slug", (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  return c.json({ entries: listEntries(slug) });
+});
+app5.get("/:slug/timeline", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  return c.json({ items: await buildTimeline(slug) });
+});
+app5.get("/:slug/entry/:id", (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const id = Number(c.req.param("id"));
+  if (!Number.isInteger(id) || id <= 0) return c.json({ error: "bad_id" }, 400);
+  const entry = getEntry(slug, id);
+  if (!entry) return c.json({ error: "not_found" }, 404);
+  return c.json({ entry });
+});
+app5.get("/:slug/git/:sha", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const sha = c.req.param("sha");
+  if (!/^[a-f0-9]{7,40}$/.test(sha)) return c.json({ error: "bad_sha" }, 400);
+  const content = await readFileAtCommit(sha, slug);
+  if (content === null) return c.json({ error: "not_found" }, 404);
+  return c.json({ sha, content });
+});
+app5.post("/:slug/revert/:id", async (c) => {
+  const slug = c.req.param("slug");
+  assertSafeSlug(slug);
+  const id = Number(c.req.param("id"));
+  if (!Number.isInteger(id) || id <= 0) return c.json({ error: "bad_id" }, 400);
+  const entry = await revertToEntry(slug, id);
+  if (!entry) return c.json({ error: "not_found" }, 404);
+  const stat = await fs13.stat(paths.worksheet(slug));
+  const meta = { slug, name: slug, updatedAt: stat.mtime.toISOString() };
+  return c.json({ meta, content: entry.content });
+});
+var history_default = app5;
+
+// server/api/agent.ts
+import { Hono as Hono8 } from "hono";
+import { streamSSE } from "hono/streaming";
+
+// shared/agent.ts
+function emptyTotals() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    costUsd: 0,
+    calls: 0
+  };
+}
+
+// server/agent/pricing.ts
+var PRICING = {
+  "claude-opus-4-7": {
+    inputPer1M: 15,
+    outputPer1M: 75,
+    cacheWritePer1M: 18.75,
+    cacheReadPer1M: 1.5
+  },
+  "claude-sonnet-4-6": {
+    inputPer1M: 3,
+    outputPer1M: 15,
+    cacheWritePer1M: 3.75,
+    cacheReadPer1M: 0.3
+  },
+  "claude-haiku-4-5": {
+    inputPer1M: 1,
+    outputPer1M: 5,
+    cacheWritePer1M: 1.25,
+    cacheReadPer1M: 0.1
+  }
+};
+var FALLBACK = PRICING["claude-sonnet-4-6"];
+function ratesFor(model) {
+  const direct = PRICING[model];
+  if (direct) return direct;
+  for (const key of Object.keys(PRICING)) {
+    if (model.startsWith(key)) return PRICING[key];
+  }
+  return FALLBACK;
+}
+function costFromUsage(model, usage) {
+  const r = ratesFor(model);
+  const input = usage.input_tokens ?? 0;
+  const output = usage.output_tokens ?? 0;
+  const cacheWrite = usage.cache_creation_input_tokens ?? 0;
+  const cacheRead = usage.cache_read_input_tokens ?? 0;
+  return (input * r.inputPer1M + output * r.outputPer1M + cacheWrite * r.cacheWritePer1M + cacheRead * r.cacheReadPer1M) / 1e6;
+}
+
+// server/agent/prompt.ts
+function buildSystemPrompt(session) {
+  const { worksheetSlug, connectionId } = session.meta;
+  const bound = !!worksheetSlug;
+  const lines = [
+    "You are os-dpt's chat-to-SQL agent. You help the user explore and query their database from a local SQL editor.",
+    "",
+    "Operating principles:",
+    "- Be conservative with assumptions. If you do not know a table, column, or business term, call get_schema or get_context before guessing.",
+    "- If you are still ambiguous after those, call ask_user_question instead of guessing.",
+    '- Persist durable knowledge via update_context the moment you learn it, in the same turn \u2014 do NOT wait for the user to ask, and do NOT wait for an explicit "remember this" / "update our context". When the user surfaces a fact or rule in the course of normal analysis, that surfacing IS the trigger; saving is your job, not theirs. Concrete triggers, each one \u2192 save:',
+    `  - The user tells you how to treat the data going forward \u2014 a standing rule: an exclusion, filter, default scope, or an "always/never do X" (e.g. 'strip out our internal test traffic', 'revenue means net of refunds', 'only count paid accounts') \u2192 conventions.md. These must be applied by default in every future session, so file them as conventions \u2014 NOT as a passing schemas.md note.`,
+    "  - You enumerate or clarify a table/column's meaning or its set of values \u2192 schemas.md",
+    "  - The user corrects you, or a run_sql result contradicts an assumption \u2192 feedback.md",
+    "  - A run_sql error reveals a schema or convention fact \u2192 feedback.md",
+    "  - You learn how the team writes SQL or what a business term means \u2192 conventions.md",
+    "  - You discover a data-quality quirk (NULLs, sentinel values like a literal 'Unknown', year/period handling, per-source anomalies) \u2192 schemas.md or feedback.md. If the takeaway is a recurring filter the user will always want applied (e.g. excluding internal/test traffic), ALSO record it as a standing rule in conventions.md, not only as a schema note.",
+    "  Rule of thumb: descriptive facts (what the data IS) \u2192 schemas.md/feedback.md; prescriptive rules (how to always query or treat it) \u2192 conventions.md. A recurring exclusion is a convention.",
+    "  After you save, tell the user in one short line what you persisted and where, so they know it will carry forward. Saving is cheap and git-tracked, so the user can always review or revert; prefer over-saving to losing the finding."
+  ];
+  if (bound) {
+    lines.push(
+      "- Prefer iterating: write_sql \u2192 run_sql \u2192 inspect \u2192 write_sql again. Drafts are non-destructive; the user commits with Cmd+S."
+    );
+  } else {
+    lines.push(
+      "- This chat is a standalone explore-and-visualize surface with no worksheet attached. You cannot stage SQL into an editor (write_sql is unavailable). Run read-only SELECTs with run_sql and present findings with render_chart and concise prose. If the user wants to keep a query, tell them to open a worksheet."
+    );
+  }
+  lines.push(
+    "- Keep prose terse. The user sees your tool calls in the UI; do not narrate every step.",
+    "",
+    "Tool usage notes:"
+  );
+  if (bound) {
+    lines.push(
+      "- write_sql stages the full worksheet contents into a draft (overwrite, not patch). Always include the complete query."
+    );
+  }
+  lines.push(
+    "- run_sql results are capped to 50 rows by default; add LIMIT or aggregation if you need a broader view.",
+    "- run_sql executes whatever SQL you pass, including DDL and DML, against the role the user connected with. Treat exploration as read-only \u2014 use SELECT. Before any INSERT/UPDATE/DELETE/TRUNCATE/CREATE/DROP/ALTER, call ask_user_question to confirm.",
+    "- ask_user_question pauses the loop entirely \u2014 only one question per call, and use it sparingly.",
+    "- render_chart draws a chart inline in the chat. After run_sql, when a picture beats a table (trends \u2192 line/area, comparisons \u2192 bar, proportions \u2192 pie), call it with pre-aggregated rows. Pass the data inline, shaped to small row objects (e.g. {month, revenue}); don't dump raw wide rows."
+  );
+  const ctx = [];
+  if (worksheetSlug) ctx.push(`- Active worksheet: ${worksheetSlug}`);
+  if (connectionId) ctx.push(`- Active connection: ${connectionId}`);
+  if (ctx.length > 0) {
+    lines.push("", "Current chat bindings:", ...ctx);
+  } else {
+    lines.push(
+      "",
+      "No worksheet or connection is bound to this chat. Ask the user before running SQL."
+    );
+  }
+  return lines.join("\n");
+}
+
+// server/agent/session.ts
+import { promises as fs14 } from "node:fs";
+import crypto4 from "node:crypto";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function freshMeta(input) {
+  const now = nowIso();
+  return {
+    id: crypto4.randomUUID(),
+    createdAt: now,
+    updatedAt: now,
+    title: input.title ?? null,
+    titleGenerated: false,
+    worksheetSlug: input.worksheetSlug ?? null,
+    standalone: input.standalone ?? false,
+    connectionId: input.connectionId ?? null,
+    pending: null,
+    usage: [],
+    totals: emptyTotals(),
+    traceParent: null
+  };
+}
+function ensureUsageFields(session) {
+  if (!Array.isArray(session.meta.usage)) session.meta.usage = [];
+  if (!session.meta.totals) session.meta.totals = emptyTotals();
+  if (typeof session.meta.standalone !== "boolean") session.meta.standalone = false;
+  if (typeof session.meta.titleGenerated !== "boolean") {
+    session.meta.titleGenerated = session.meta.title != null;
+  }
+  return session;
+}
+async function createChat(input) {
+  const session = { meta: freshMeta(input), messages: [] };
+  await persist(session);
+  return session;
+}
+async function getChat(id) {
+  assertSafeChatId(id);
+  try {
+    const raw = await fs14.readFile(paths.chat(id), "utf8");
+    return ensureUsageFields(JSON.parse(raw));
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function listChats() {
+  const entries = await fs14.readdir(paths.chats()).catch(() => []);
+  const out = [];
+  for (const f of entries) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const raw = await fs14.readFile(paths.chat(f.slice(0, -5)), "utf8");
+      const data = ensureUsageFields(JSON.parse(raw));
+      out.push(data.meta);
+    } catch {
+    }
+  }
+  out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return out;
+}
+async function deleteChat(id) {
+  assertSafeChatId(id);
+  await fs14.rm(paths.chat(id), { force: true });
+}
+async function appendMessage(session, message) {
+  session.messages.push(message);
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function setPending(session, pending) {
+  session.meta.pending = pending;
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function clearPending(session) {
+  session.meta.pending = null;
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function recordUsage(session, entry) {
+  session.meta.usage.push(entry);
+  const t = session.meta.totals;
+  t.inputTokens += entry.inputTokens;
+  t.outputTokens += entry.outputTokens;
+  t.cacheCreationTokens += entry.cacheCreationTokens;
+  t.cacheReadTokens += entry.cacheReadTokens;
+  t.costUsd += entry.costUsd;
+  t.calls += 1;
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function setTitle(session, title, generated = false) {
+  session.meta.title = title;
+  if (generated) session.meta.titleGenerated = true;
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function setConnection(session, connectionId) {
+  session.meta.connectionId = connectionId;
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function persistSession(session) {
+  session.meta.updatedAt = nowIso();
+  await persist(session);
+}
+async function persist(session) {
+  assertSafeChatId(session.meta.id);
+  await writeAtomic(paths.chat(session.meta.id), JSON.stringify(session, null, 2));
+}
+
+// server/agent/tools/get_context.ts
+import { promises as fs15 } from "node:fs";
+async function readOne(file, connectionId) {
+  try {
+    return await fs15.readFile(paths.contextFile(file, connectionId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+var getContextTool = {
+  name: "get_context",
+  description: "Read the agent's persisted context (markdown files in the workspace's context/ directory). These contain prior learnings about schemas, project conventions, and user feedback. Context is scoped to the data source bound to this chat; if no connection is bound, the workspace-level (unassigned) docs are read instead. Call this near the start of a session and any time you might be missing context for a request.",
+  input_schema: {
+    type: "object",
+    properties: {
+      files: {
+        type: "array",
+        description: "Subset of context files to read. Defaults to all files when omitted.",
+        items: { type: "string", enum: [...CONTEXT_FILES] }
+      }
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = rawInput ?? {};
+    const bound = ctx.session.meta.connectionId;
+    const connectionId = bound && isSafeConnectionId(bound) ? bound : null;
+    const requested = input.files && input.files.length > 0 ? input.files : [...CONTEXT_FILES];
+    const sections = [];
+    let present = 0;
+    for (const f of requested) {
+      const body = await readOne(f, connectionId);
+      if (body === null) {
+        sections.push(`## ${f}.md
+(not yet written)`);
+      } else {
+        present += 1;
+        sections.push(`## ${f}.md
+${body.trim()}`);
+      }
+    }
+    return {
+      toolResult: sections.join("\n\n"),
+      isError: false,
+      uiSummary: `Read ${present}/${requested.length} context files`
+    };
+  }
+};
+
+// server/agent/tools/update_context.ts
+import { promises as fs16 } from "node:fs";
+function isContextFile(v) {
+  return CONTEXT_FILES.includes(v);
+}
+var updateContextTool = {
+  name: "update_context",
+  description: "Write to one of the agent's context files (schemas.md, conventions.md, feedback.md). Call this the moment you learn something durable \u2014 without waiting to be asked: a clarified schema fact or value set, a project convention, a user correction, a data-quality quirk, or an error pattern from running SQL. Saving is cheap and git-tracked; prefer over-saving to losing a finding. Prefer 'append' for new findings; use 'replace' only when restructuring an entire file. Writes are scoped to the data source bound to this chat; with no connection bound they go to the workspace-level (unassigned) docs.",
+  input_schema: {
+    type: "object",
+    required: ["file", "mode", "content"],
+    properties: {
+      file: {
+        type: "string",
+        enum: [...CONTEXT_FILES],
+        description: "schemas.md = table/column facts; conventions.md = how the team writes SQL / what business terms mean; feedback.md = corrections and run_sql errors and what was learned."
+      },
+      mode: {
+        type: "string",
+        enum: ["append", "replace"]
+      },
+      content: {
+        type: "string",
+        description: "Markdown to append (added under a dated heading) or replace the whole file with."
+      }
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = rawInput ?? {};
+    const bound = ctx.session.meta.connectionId;
+    const connectionId = bound && isSafeConnectionId(bound) ? bound : null;
+    if (typeof input.file !== "string" || !isContextFile(input.file)) {
+      return {
+        toolResult: `Invalid file: must be one of ${CONTEXT_FILES.join(", ")}`,
+        isError: true,
+        uiSummary: "update_context: invalid file"
+      };
+    }
+    if (input.mode !== "append" && input.mode !== "replace") {
+      return {
+        toolResult: "Invalid mode: must be 'append' or 'replace'",
+        isError: true,
+        uiSummary: "update_context: invalid mode"
+      };
+    }
+    if (typeof input.content !== "string" || input.content.trim() === "") {
+      return {
+        toolResult: "Invalid content: must be non-empty string",
+        isError: true,
+        uiSummary: "update_context: empty content"
+      };
+    }
+    const target = paths.contextFile(input.file, connectionId);
+    let next;
+    if (input.mode === "replace") {
+      next = input.content.endsWith("\n") ? input.content : input.content + "\n";
+    } else {
+      let current = "";
+      try {
+        current = await fs16.readFile(target, "utf8");
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const block = `## ${stamp}
+
+${input.content.trim()}
+`;
+      next = current === "" ? block : current.replace(/\n*$/, "\n\n") + block;
+    }
+    await writeAtomic(target, next);
+    return {
+      toolResult: `Wrote ${next.length} bytes to context/${input.file}.md (${input.mode})`,
+      isError: false,
+      uiSummary: `Updated context/${input.file}.md (${input.mode})`
+    };
+  }
+};
+
+// server/agent/tools/get_schema.ts
+var cache = /* @__PURE__ */ new Map();
+var TTL_MS2 = 6e4;
+function cacheKey(connId, schemas) {
+  return `${connId}::${schemas.slice().sort().join(",")}`;
+}
+async function introspect2(connId, schemas) {
+  const pool = getPool(connId);
+  if (!pool) throw new Error(`Connection not active: ${connId}`);
+  const sql = `
+    SELECT table_schema, table_name, column_name, data_type, is_nullable
+    FROM information_schema.columns
+    WHERE table_schema = ANY($1)
+    ORDER BY table_schema, table_name, ordinal_position
+  `;
+  const { rows } = await pool.query(sql, [schemas]);
+  const tree = {};
+  for (const r of rows) {
+    const s = tree[r.table_schema] ??= {};
+    const t = s[r.table_name] ??= { columns: [] };
+    t.columns.push({
+      name: r.column_name,
+      type: r.data_type,
+      nullable: r.is_nullable === "YES"
+    });
+  }
+  return tree;
+}
+function summarize(tree, includeCols) {
+  const out = [];
+  for (const schema of Object.keys(tree).sort()) {
+    out.push(`# ${schema}`);
+    for (const table of Object.keys(tree[schema]).sort()) {
+      const cols = tree[schema][table].columns;
+      if (includeCols) {
+        out.push(
+          `- ${table}(${cols.map((c) => `${c.name} ${c.type}${c.nullable ? "" : " NOT NULL"}`).join(", ")})`
+        );
+      } else {
+        out.push(`- ${table} [${cols.length} cols]`);
+      }
+    }
+  }
+  return out.join("\n");
+}
+var getSchemaTool = {
+  name: "get_schema",
+  description: "Introspect the live database schema via information_schema. Use this when you need to know what tables and columns exist before writing SQL. Results are cached per session for a minute. Defaults to the active connection bound to this chat and the 'public' schema.",
+  input_schema: {
+    type: "object",
+    properties: {
+      connection_id: {
+        type: "string",
+        description: "Connection UUID to introspect. Defaults to the chat's bound connection."
+      },
+      schemas: {
+        type: "array",
+        items: { type: "string" },
+        description: "Postgres schemas to include. Defaults to ['public']."
+      },
+      include_columns: {
+        type: "boolean",
+        description: "If true, return column names + types. If false, return only table names with column counts. Defaults to true."
+      }
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = rawInput ?? {};
+    const connId = input.connection_id ?? ctx.session.meta.connectionId;
+    if (!connId) {
+      return {
+        toolResult: "No connection bound. Ask the user which connection to use, or set connection_id explicitly.",
+        isError: true,
+        uiSummary: "get_schema: no connection"
+      };
+    }
+    const schemas = input.schemas && input.schemas.length > 0 ? input.schemas : ["public"];
+    const includeCols = input.include_columns ?? true;
+    const key = cacheKey(connId, schemas);
+    let entry = cache.get(key);
+    if (!entry || Date.now() - entry.at > TTL_MS2) {
+      try {
+        entry = { at: Date.now(), tree: await introspect2(connId, schemas) };
+        cache.set(key, entry);
+      } catch (err) {
+        return {
+          toolResult: `Schema introspection failed: ${err.message}`,
+          isError: true,
+          uiSummary: "get_schema: failed"
+        };
+      }
+    }
+    const tableCount = Object.values(entry.tree).reduce(
+      (n, s) => n + Object.keys(s).length,
+      0
+    );
+    return {
+      toolResult: summarize(entry.tree, includeCols),
+      isError: false,
+      uiSummary: `Loaded ${tableCount} tables from ${schemas.join(", ")}`
+    };
+  }
+};
+
+// server/agent/tools/ask_user_question.ts
+var askUserQuestionTool = {
+  name: "ask_user_question",
+  description: "Ask the user a clarifying question when you lack context to proceed safely. Calling this PAUSES the agent \u2014 no further tools run this turn and the user is prompted to reply. Use it for genuine ambiguity (which table did they mean, what time window, etc.), not for confirmation of obvious next steps.",
+  input_schema: {
+    type: "object",
+    required: ["question"],
+    properties: {
+      question: {
+        type: "string",
+        description: "One specific question, phrased plainly."
+      }
+    }
+  },
+  async execute(rawInput) {
+    const input = rawInput ?? {};
+    const question = typeof input.question === "string" ? input.question.trim() : "";
+    if (question === "") {
+      return {
+        toolResult: "Invalid question: must be non-empty string",
+        isError: true,
+        uiSummary: "ask_user_question: empty"
+      };
+    }
+    return {
+      toolResult: "(awaiting user response)",
+      isError: false,
+      uiSummary: question,
+      pause: { question }
+    };
+  }
+};
+
+// server/agent/tools/write_sql.ts
+var writeSqlTool = {
+  name: "write_sql",
+  description: "Stage SQL into the editor. Writes to the worksheet's draft (autosave channel), so the user sees the SQL appear in the editor without losing their saved version until they hit Cmd+S. Defaults to the chat's bound worksheet. Pass the COMPLETE worksheet contents \u2014 drafts are overwrites, not patches.",
+  input_schema: {
+    type: "object",
+    required: ["sql"],
+    properties: {
+      sql: {
+        type: "string",
+        description: "Full SQL text to stage into the worksheet draft."
+      },
+      worksheet_slug: {
+        type: "string",
+        description: "Worksheet to write to. Defaults to the chat's bound worksheet."
+      }
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = rawInput ?? {};
+    if (typeof input.sql !== "string") {
+      return {
+        toolResult: "Invalid sql: must be a string",
+        isError: true,
+        uiSummary: "write_sql: invalid sql"
+      };
+    }
+    const slug = input.worksheet_slug ?? ctx.session.meta.worksheetSlug;
+    if (!slug) {
+      return {
+        toolResult: "No worksheet bound. Ask the user which worksheet to write to, or set worksheet_slug.",
+        isError: true,
+        uiSummary: "write_sql: no worksheet"
+      };
+    }
+    try {
+      assertSafeSlug(slug);
+    } catch (err) {
+      return {
+        toolResult: `Invalid worksheet slug: ${err.message}`,
+        isError: true,
+        uiSummary: "write_sql: bad slug"
+      };
+    }
+    await writeAtomic(paths.draft(slug), input.sql);
+    return {
+      toolResult: `Wrote ${input.sql.length} bytes to draft for worksheet '${slug}'.`,
+      isError: false,
+      uiSummary: `Staged ${input.sql.length} chars into '${slug}' draft`,
+      events: [{ type: "sql_written", worksheetSlug: slug, sql: input.sql }]
+    };
+  }
+};
+
+// server/db/sql-safety.ts
+var READ_ONLY_LEADERS = /* @__PURE__ */ new Set([
+  "select",
+  "with",
+  "table",
+  "values",
+  "show",
+  "explain"
+]);
+function stripComments(sql) {
+  return sql.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\n]*/g, " ");
+}
+function isReadOnlyStatement(sql) {
+  const oneStatement = stripComments(sql).trim().replace(/;\s*$/, "");
+  if (oneStatement === "") return false;
+  if (oneStatement.includes(";")) return false;
+  const leader = oneStatement.toLowerCase().match(/^[a-z]+/)?.[0];
+  if (!leader || !READ_ONLY_LEADERS.has(leader)) return false;
+  if (leader === "explain" && /\banalyze\b/i.test(oneStatement)) return false;
+  return true;
+}
+
+// server/agent/tools/run_sql.ts
+var DEFAULT_ROW_LIMIT = 50;
+var MAX_ROW_LIMIT = 500;
+var MAX_RESULT_CHARS = 16e3;
+function format(rows, columns, rowCount) {
+  const header = `columns: ${columns.join(", ")}
+rowCount: ${rowCount ?? rows.length}
+`;
+  const body = rows.map((r) => JSON.stringify(r)).join("\n");
+  let out = header + (body ? `rows:
+${body}` : "(no rows)");
+  if (out.length > MAX_RESULT_CHARS) {
+    out = out.slice(0, MAX_RESULT_CHARS) + "\n\u2026(truncated)";
+  }
+  return out;
+}
+var runSqlTool = {
+  name: "run_sql",
+  description: "Execute SQL against the active database connection and return the result. Use this to validate queries you've written and to inspect data. If the query errors, capture what you learned by calling update_context against feedback.md so future runs avoid the same mistake. Row results are capped (default 50, max 500) \u2014 add LIMIT or aggregation if you need a wider view. IMPORTANT: this tool executes the SQL verbatim against whatever role the connection uses. Connections default to read-only, which rejects anything but a single read statement (SELECT/WITH/SHOW/EXPLAIN/TABLE/VALUES). On a read-write connection it will also run DDL (CREATE/DROP/ALTER) and DML (INSERT/UPDATE/DELETE/TRUNCATE), so before running anything that mutates data or schema, call ask_user_question to confirm.",
+  input_schema: {
+    type: "object",
+    required: ["sql"],
+    properties: {
+      sql: { type: "string", description: "SQL to execute." },
+      connection_id: {
+        type: "string",
+        description: "Connection UUID. Defaults to the chat's bound connection."
+      },
+      row_limit: {
+        type: "number",
+        description: `Cap on rows returned to the agent (default ${DEFAULT_ROW_LIMIT}, max ${MAX_ROW_LIMIT}).`
+      }
+    }
+  },
+  async execute(rawInput, ctx) {
+    const input = rawInput ?? {};
+    if (typeof input.sql !== "string" || input.sql.trim() === "") {
+      return {
+        toolResult: "Invalid sql: must be a non-empty string",
+        isError: true,
+        uiSummary: "run_sql: empty sql"
+      };
+    }
+    const connId = input.connection_id ?? ctx.session.meta.connectionId;
+    if (!connId) {
+      return {
+        toolResult: "No connection bound. Ask the user which connection to use, or set connection_id.",
+        isError: true,
+        uiSummary: "run_sql: no connection"
+      };
+    }
+    const pool = getPool(connId);
+    if (!pool) {
+      return {
+        toolResult: `Connection not active: ${connId}. The user must connect it before SQL can run.`,
+        isError: true,
+        uiSummary: "run_sql: connection inactive"
+      };
+    }
+    if (getAccessMode(connId) === "read-only" && !isReadOnlyStatement(input.sql)) {
+      return {
+        toolResult: "This connection is read-only, so only a single read statement (SELECT / WITH / SHOW / EXPLAIN / TABLE / VALUES) is allowed. Do not attempt to bypass this. If the user wants to run writes or DDL, tell them to switch the connection to read-write in the Connections view.",
+        isError: true,
+        uiSummary: "run_sql: blocked (read-only connection)"
+      };
+    }
+    const cap = Math.min(
+      MAX_ROW_LIMIT,
+      Math.max(1, Math.floor(input.row_limit ?? DEFAULT_ROW_LIMIT))
+    );
+    try {
+      const res = await pool.query(input.sql);
+      const columns = res.fields.map((f) => f.name);
+      const capped = res.rows.slice(0, cap);
+      const truncated = res.rows.length > cap;
+      const note = truncated ? `
+(showing ${cap} of ${res.rows.length} rows)` : "";
+      return {
+        toolResult: format(capped, columns, res.rowCount) + note,
+        isError: false,
+        uiSummary: `Ran SQL: ${columns.length} cols, ${res.rowCount ?? capped.length} rows`
+      };
+    } catch (err) {
+      const message = normalizePgError(err).message;
+      return {
+        toolResult: `Query failed: ${message}`,
+        isError: true,
+        uiSummary: `run_sql error: ${message}`
+      };
+    }
+  }
+};
+
+// server/agent/tools/render_chart.ts
+var CHART_TYPES = ["bar", "line", "area", "pie"];
+var MAX_ROWS2 = 500;
+var MAX_SERIES = 8;
+function parseSeries(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return "series must be a non-empty array of { key, label? }";
+  }
+  if (raw.length > MAX_SERIES) {
+    return `too many series (${raw.length}); cap is ${MAX_SERIES}`;
+  }
+  const out = [];
+  for (const item of raw) {
+    if (typeof item === "string") {
+      out.push({ key: item });
+      continue;
+    }
+    if (item && typeof item === "object" && typeof item.key === "string") {
+      const s = item;
+      out.push(s.label ? { key: s.key, label: s.label } : { key: s.key });
+      continue;
+    }
+    return "each series must be a string key or an object with a string `key`";
+  }
+  return out;
+}
+function parseData(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return "data must be a non-empty array of row objects";
+  }
+  if (raw.length > MAX_ROWS2) {
+    return `too many rows (${raw.length}); cap is ${MAX_ROWS2}. Aggregate or LIMIT before charting.`;
+  }
+  for (const row of raw) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      return "each data element must be a plain object keyed by column name";
+    }
+  }
+  return raw;
+}
+var renderChartTool = {
+  name: "render_chart",
+  description: `Render a chart inline in the chat to visualize query results. Supply the data rows directly (shaped from your run_sql results) along with the chart spec \u2014 the chart is self-contained. Use this after run_sql when a visualization communicates the answer better than a table: trends over time (line/area), category comparisons (bar), or proportions (pie). Keep data small and pre-aggregated (cap ${MAX_ROWS2} rows). Each data row is an object keyed by column name, e.g. \`[{ "month": "Jan", "revenue": 120 }, \u2026]\`. \`x\` names the category column; \`series\` names the numeric column(s) to plot. For pie charts only the first series is used.`,
+  input_schema: {
+    type: "object",
+    required: ["type", "x", "series", "data"],
+    properties: {
+      type: {
+        type: "string",
+        enum: CHART_TYPES,
+        description: "Chart kind: bar, line, area, or pie."
+      },
+      title: { type: "string", description: "Optional title shown above the chart." },
+      x: {
+        type: "string",
+        description: "Row key for the category axis (x-axis for bar/line/area; slice label for pie)."
+      },
+      series: {
+        type: "array",
+        description: "Numeric series to plot. Each item is { key, label? } or a bare column-name string.",
+        items: {
+          type: "object",
+          required: ["key"],
+          properties: {
+            key: { type: "string", description: "Row key holding this series' value." },
+            label: { type: "string", description: "Legend/tooltip label (defaults to key)." }
+          }
+        }
+      },
+      data: {
+        type: "array",
+        description: "Row objects to chart, keyed by column name.",
+        items: { type: "object" }
+      }
+    }
+  },
+  async execute(rawInput) {
+    const input = rawInput ?? {};
+    if (typeof input.type !== "string" || !CHART_TYPES.includes(input.type)) {
+      return {
+        toolResult: `Invalid type: must be one of ${CHART_TYPES.join(", ")}`,
+        isError: true,
+        uiSummary: "render_chart: bad type"
+      };
+    }
+    if (typeof input.x !== "string" || input.x.trim() === "") {
+      return {
+        toolResult: "Invalid x: must be a non-empty string naming the category column",
+        isError: true,
+        uiSummary: "render_chart: bad x"
+      };
+    }
+    const series = parseSeries(input.series);
+    if (typeof series === "string") {
+      return { toolResult: `Invalid series: ${series}`, isError: true, uiSummary: "render_chart: bad series" };
+    }
+    const data = parseData(input.data);
+    if (typeof data === "string") {
+      return { toolResult: `Invalid data: ${data}`, isError: true, uiSummary: "render_chart: bad data" };
+    }
+    const spec = {
+      type: input.type,
+      x: input.x,
+      series,
+      data,
+      ...typeof input.title === "string" && input.title.trim() !== "" ? { title: input.title } : {}
+    };
+    const seriesLabel = series.map((s) => s.label ?? s.key).join(", ");
+    return {
+      toolResult: `Rendered ${spec.type} chart of ${seriesLabel} by ${spec.x} (${data.length} rows) in the chat.`,
+      isError: false,
+      uiSummary: `Charted ${seriesLabel} by ${spec.x} (${spec.type})`,
+      events: [{ type: "chart_rendered", spec }]
+    };
+  }
+};
+
+// server/agent/tools/index.ts
+var TOOLS = [
+  getContextTool,
+  updateContextTool,
+  getSchemaTool,
+  askUserQuestionTool,
+  writeSqlTool,
+  runSqlTool,
+  renderChartTool
+];
+var TOOL_BY_NAME = Object.fromEntries(
+  TOOLS.map((t) => [t.name, t])
+);
+function findTool(name) {
+  return TOOL_BY_NAME[name];
+}
+function anthropicToolDefs(opts = {}) {
+  const { worksheetBound = true } = opts;
+  return TOOLS.filter((t) => worksheetBound || t.name !== "write_sql").map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema
+  }));
+}
+
+// server/agent/loop.ts
+var MAX_STEPS = 20;
+function toolUseBlocks(msg) {
+  return msg.content.filter(
+    (b) => b.type === "tool_use"
+  );
+}
+function latestUserInput(session) {
+  const last = session.messages[session.messages.length - 1];
+  if (!last || last.role !== "user") return null;
+  return last.content;
+}
+async function conversationParent(session) {
+  if (!tracingEnabled()) return void 0;
+  if (session.meta.traceParent) return session.meta.traceParent;
+  const first = session.messages.find((m) => m.role === "user");
+  const handle = await startConversationSpan({
+    name: "conversation",
+    event: {
+      input: first ? first.content : null,
+      metadata: {
+        chatId: session.meta.id,
+        title: session.meta.title,
+        worksheetSlug: session.meta.worksheetSlug,
+        connectionId: session.meta.connectionId,
+        standalone: session.meta.standalone
+      }
+    }
+  });
+  if (handle) {
+    session.meta.traceParent = handle;
+    await persistSession(session);
+  }
+  return handle;
+}
+async function runAgentTurn(opts) {
+  const parent = await conversationParent(opts.session);
+  return traced(
+    {
+      name: "agent.turn",
+      type: "task",
+      parent,
+      event: {
+        input: latestUserInput(opts.session),
+        metadata: {
+          chatId: opts.session.meta.id,
+          worksheetSlug: opts.session.meta.worksheetSlug,
+          connectionId: opts.session.meta.connectionId,
+          standalone: opts.session.meta.standalone
+        }
+      }
+    },
+    () => runTurn(opts)
+  );
+}
+async function runTurn(opts) {
+  const { session, emit } = opts;
+  let apiKey;
+  try {
+    apiKey = await getAnthropicKey();
+  } catch (err) {
+    await emit({ type: "error", message: err.message });
+    return;
+  }
+  const system = buildSystemPrompt(session);
+  const tools = anthropicToolDefs({ worksheetBound: !!session.meta.worksheetSlug });
+  for (let step = 0; step < MAX_STEPS; step += 1) {
+    let final;
+    let model;
+    let usage;
+    let textEmitChain = Promise.resolve();
+    try {
+      const result = await streamAssistantMessage({
+        apiKey,
+        system,
+        tools,
+        messages: session.messages,
+        onTextDelta: (delta) => {
+          textEmitChain = textEmitChain.then(
+            () => Promise.resolve(emit({ type: "text_delta", text: delta }))
+          );
+        }
+      });
+      await textEmitChain;
+      final = result.message;
+      model = result.model;
+      usage = result.usage;
+    } catch (err) {
+      await emit({ type: "error", message: err.message });
+      return;
+    }
+    await appendMessage(session, { role: "assistant", content: final.content });
+    const entry = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      model,
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0,
+      cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
+      cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+      costUsd: costFromUsage(model, usage)
+    };
+    await recordUsage(session, entry);
+    await emit({ type: "usage", entry, totals: session.meta.totals });
+    const toolUses = toolUseBlocks(final);
+    if (toolUses.length === 0) {
+      await emit({ type: "done" });
+      return;
+    }
+    const resultBlocks = [];
+    let paused = null;
+    for (const block of toolUses) {
+      const tool = findTool(block.name);
+      if (!tool) {
+        await emit({
+          type: "tool_result",
+          toolUseId: block.id,
+          name: block.name,
+          ok: false,
+          summary: `Unknown tool: ${block.name}`
+        });
+        resultBlocks.push({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: `Unknown tool: ${block.name}`,
+          is_error: true
+        });
+        continue;
+      }
+      await emit({
+        type: "tool_start",
+        toolUseId: block.id,
+        name: tool.name,
+        input: block.input
+      });
+      let execution;
+      try {
+        execution = await traced(
+          {
+            name: `tool.${tool.name}`,
+            type: "tool",
+            event: { input: block.input }
+          },
+          async (span) => {
+            const result = await tool.execute(block.input, { session });
+            span.log({
+              output: result.toolResult,
+              metadata: { isError: result.isError, summary: result.uiSummary }
+            });
+            return result;
+          }
+        );
+      } catch (err) {
+        const message = err.message;
+        await emit({
+          type: "tool_result",
+          toolUseId: block.id,
+          name: tool.name,
+          ok: false,
+          summary: `${tool.name} threw: ${message}`
+        });
+        resultBlocks.push({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: `Tool threw: ${message}`,
+          is_error: true
+        });
+        continue;
+      }
+      if (execution.events) {
+        for (const e of execution.events) await emit(e);
+      }
+      await emit({
+        type: "tool_result",
+        toolUseId: block.id,
+        name: tool.name,
+        ok: !execution.isError,
+        summary: execution.uiSummary
+      });
+      resultBlocks.push({
+        type: "tool_result",
+        tool_use_id: block.id,
+        content: execution.toolResult,
+        is_error: execution.isError
+      });
+      if (execution.pause) {
+        paused = {
+          toolUseId: block.id,
+          question: execution.pause.question
+        };
+      }
+    }
+    await appendMessage(session, { role: "user", content: resultBlocks });
+    if (paused) {
+      await setPending(session, {
+        toolUseId: paused.toolUseId,
+        question: paused.question,
+        askedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await emit({
+        type: "ask_user",
+        toolUseId: paused.toolUseId,
+        question: paused.question
+      });
+      return;
+    }
+  }
+  await emit({
+    type: "error",
+    message: `Agent exceeded ${MAX_STEPS} steps without finishing.`
+  });
+}
+async function resumeWithAnswer(opts) {
+  const { session, userAnswer, emit } = opts;
+  const pending = session.meta.pending;
+  if (!pending) {
+    await emit({ type: "error", message: "No pending question to resume." });
+    return;
+  }
+  const last = session.messages[session.messages.length - 1];
+  if (last && last.role === "user" && Array.isArray(last.content)) {
+    for (const block of last.content) {
+      if (block.type === "tool_result" && block.tool_use_id === pending.toolUseId) {
+        block.content = `User answered: ${userAnswer}`;
+        block.is_error = false;
+      }
+    }
+  }
+  await persistSession(session);
+  await clearPending(session);
+  await runAgentTurn({ session, emit });
+}
+
+// server/api/agent.ts
+var app6 = new Hono8();
+var sessionLocks = /* @__PURE__ */ new Map();
+async function withSessionLock(id, fn) {
+  const prev = sessionLocks.get(id) ?? Promise.resolve();
+  const ours = prev.catch(() => {
+  }).then(fn);
+  sessionLocks.set(id, ours);
+  try {
+    return await ours;
+  } finally {
+    if (sessionLocks.get(id) === ours) sessionLocks.delete(id);
+  }
+}
+app6.get("/sessions", async (c) => {
+  const sessions = await listChats();
+  return c.json({ sessions });
+});
+function addTotals(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheCreationTokens: a.cacheCreationTokens + b.cacheCreationTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    costUsd: a.costUsd + b.costUsd,
+    calls: a.calls + b.calls
+  };
+}
+app6.get("/usage", async (c) => {
+  const slug = c.req.query("worksheetSlug");
+  const all = await listChats();
+  const sessions = slug ? all.filter((s) => s.worksheetSlug === slug) : all;
+  const totals = sessions.reduce(
+    (acc, s) => addTotals(acc, s.totals),
+    emptyTotals()
+  );
+  const bySession = sessions.map((s) => ({
+    id: s.id,
+    title: s.title,
+    worksheetSlug: s.worksheetSlug,
+    updatedAt: s.updatedAt,
+    totals: s.totals
+  }));
+  return c.json({ totals, bySession });
+});
+app6.get("/sessions/:id/usage", async (c) => {
+  const session = await getChat(c.req.param("id"));
+  if (!session) return c.json({ error: "not_found" }, 404);
+  return c.json({
+    totals: session.meta.totals,
+    entries: session.meta.usage
+  });
+});
+app6.post("/sessions", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const session = await createChat({
+    worksheetSlug: body.worksheetSlug ?? null,
+    connectionId: body.connectionId ?? null,
+    title: body.title ?? null,
+    standalone: body.standalone ?? false
+  });
+  return c.json(session, 201);
+});
+app6.get("/sessions/:id", async (c) => {
+  const session = await getChat(c.req.param("id"));
+  if (!session) return c.json({ error: "not_found" }, 404);
+  return c.json(session);
+});
+app6.patch("/sessions/:id", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json().catch(() => ({}));
+  return withSessionLock(id, async () => {
+    const session = await getChat(id);
+    if (!session) return c.json({ error: "not_found" }, 404);
+    if ("connectionId" in body) {
+      const cid = body.connectionId;
+      if (cid !== null && typeof cid !== "string") {
+        return c.json({ error: "connectionId must be a string or null" }, 400);
+      }
+      if (cid !== null && !activeIds().has(cid)) {
+        return c.json({ error: "connection is not active" }, 400);
+      }
+      await setConnection(session, cid);
+    }
+    return c.json(session.meta);
+  });
+});
+app6.delete("/sessions/:id", async (c) => {
+  await deleteChat(c.req.param("id"));
+  return c.json({ ok: true });
+});
+function firstUserText(messages) {
+  const first = messages.find((m) => m.role === "user");
+  if (!first) return "";
+  const { content } = first;
+  if (typeof content === "string") return content.trim();
+  if (Array.isArray(content)) {
+    return content.map(
+      (b) => b && typeof b === "object" && "type" in b && b.type === "text" && "text" in b ? String(b.text) : ""
+    ).join("").trim();
+  }
+  return "";
+}
+app6.post("/sessions/:id/auto-name", async (c) => {
+  const id = c.req.param("id");
+  return withSessionLock(id, async () => {
+    const session = await getChat(id);
+    if (!session) return c.json({ error: "not_found" }, 404);
+    if (session.meta.titleGenerated) {
+      return c.json({
+        title: session.meta.title,
+        skipped: true,
+        reason: "already-named"
+      });
+    }
+    const prompt = firstUserText(session.messages);
+    if (!prompt) {
+      return c.json({ title: session.meta.title, skipped: true, reason: "empty" });
+    }
+    try {
+      const title = await generateChatTitle(prompt);
+      await setTitle(session, title, true);
+      return c.json({ title, skipped: false });
+    } catch (err) {
+      const message = err.message;
+      console.warn(`auto-name chat ${id} failed:`, message);
+      return c.json({
+        title: session.meta.title,
+        skipped: true,
+        reason: "model-error",
+        error: message
+      });
+    }
+  });
+});
+app6.post("/sessions/:id/messages", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json().catch(() => ({}));
+  const message = typeof body.message === "string" ? body.message.trim() : "";
+  if (message === "") {
+    return c.json({ error: "Missing required field: message" }, 400);
+  }
+  const initial = await getChat(id);
+  if (!initial) return c.json({ error: "not_found" }, 404);
+  if (initial.meta.pending) {
+    return c.json(
+      {
+        error: "Session is waiting on a pending question. POST /respond to answer it first."
+      },
+      409
+    );
+  }
+  return streamSSE(c, async (stream) => {
+    const emit = async (event) => {
+      await stream.writeSSE({ data: JSON.stringify(event) });
+    };
+    try {
+      await withSessionLock(id, async () => {
+        const session = await getChat(id);
+        if (!session) {
+          await emit({ type: "error", message: "Session no longer exists." });
+          return;
+        }
+        if (session.meta.pending) {
+          await emit({
+            type: "error",
+            message: "Session is waiting on a pending question \u2014 answer via /respond first."
+          });
+          return;
+        }
+        await appendMessage(session, { role: "user", content: message });
+        if (!session.meta.title) {
+          await setTitle(session, message.slice(0, 60));
+        }
+        await runAgentTurn({ session, emit });
+      });
+    } catch (err) {
+      await emit({ type: "error", message: err.message });
+    }
+  });
+});
+app6.post("/sessions/:id/respond", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json().catch(() => ({}));
+  const answer = typeof body.answer === "string" ? body.answer.trim() : "";
+  if (answer === "") {
+    return c.json({ error: "Missing required field: answer" }, 400);
+  }
+  const initial = await getChat(id);
+  if (!initial) return c.json({ error: "not_found" }, 404);
+  if (!initial.meta.pending) {
+    return c.json({ error: "No pending question to answer." }, 409);
+  }
+  return streamSSE(c, async (stream) => {
+    const emit = async (event) => {
+      await stream.writeSSE({ data: JSON.stringify(event) });
+    };
+    try {
+      await withSessionLock(id, async () => {
+        const session = await getChat(id);
+        if (!session) {
+          await emit({ type: "error", message: "Session no longer exists." });
+          return;
+        }
+        if (!session.meta.pending) {
+          await emit({
+            type: "error",
+            message: "No pending question to answer (already resolved)."
+          });
+          return;
+        }
+        await resumeWithAnswer({ session, userAnswer: answer, emit });
+      });
+    } catch (err) {
+      await emit({ type: "error", message: err.message });
+    }
+  });
+});
+var agent_default = app6;
+
+// server/api/context.ts
+import { Hono as Hono9 } from "hono";
+import { promises as fs17 } from "node:fs";
+import { HTTPException as HTTPException3 } from "hono/http-exception";
+var app7 = new Hono9();
+var MAX_DOC_BYTES = 256 * 1024;
+function defFor(name) {
+  return CONTEXT_DOCS.find((d) => d.name === name);
+}
+function scopeOf(c) {
+  const id = c.req.query("connectionId");
+  if (!id) return null;
+  assertSafeConnectionId(id);
+  return id;
+}
+async function readMeta(name, connectionId) {
+  const def = CONTEXT_DOCS.find((d) => d.name === name);
+  try {
+    const st = await fs17.stat(paths.contextFile(name, connectionId));
+    return { ...def, updatedAt: st.mtime.toISOString(), size: st.size };
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return { ...def, updatedAt: null, size: 0 };
+  }
+}
+async function readContent(name, connectionId) {
+  try {
+    return await fs17.readFile(paths.contextFile(name, connectionId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return "";
+    throw err;
+  }
+}
+app7.get("/", async (c) => {
+  const connectionId = scopeOf(c);
+  const docs = await Promise.all(CONTEXT_DOCS.map((d) => readMeta(d.name, connectionId)));
+  return c.json({ connectionId, docs });
+});
+app7.get("/:name", async (c) => {
+  const name = c.req.param("name");
+  if (!defFor(name)) throw new HTTPException3(404, { message: `Unknown context doc: ${name}` });
+  const docName = name;
+  const connectionId = scopeOf(c);
+  const [meta, content] = await Promise.all([
+    readMeta(docName, connectionId),
+    readContent(docName, connectionId)
+  ]);
+  return c.json({ meta, content });
+});
+app7.put("/:name", async (c) => {
+  const name = c.req.param("name");
+  if (!defFor(name)) throw new HTTPException3(404, { message: `Unknown context doc: ${name}` });
+  const docName = name;
+  const connectionId = scopeOf(c);
+  const body = await c.req.json().catch(() => ({}));
+  if (typeof body.content !== "string") {
+    throw new HTTPException3(400, { message: "content must be a string" });
+  }
+  if (Buffer.byteLength(body.content, "utf8") > MAX_DOC_BYTES) {
+    throw new HTTPException3(413, { message: "context doc exceeds 256 KiB" });
+  }
+  const text = body.content === "" ? "" : body.content.replace(/\n*$/, "") + "\n";
+  await writeAtomic(paths.contextFile(docName, connectionId), text);
+  const meta = await readMeta(docName, connectionId);
+  return c.json({ meta });
+});
+var context_default = app7;
+
+// server/history/watcher.ts
+import { promises as fs18, watch } from "node:fs";
+import path10 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+var SLUG_RE2 = /^[a-z0-9][a-z0-9_-]*$/i;
+var watcher = null;
+function startWorksheetsWatcher() {
+  const dir = paths.worksheets();
+  watcher = watch(dir, (eventType, filename) => {
+    if (!filename || !filename.endsWith(".sql")) return;
+    if (eventType !== "change" && eventType !== "rename") return;
+    const slug = filename.slice(0, -4);
+    if (!SLUG_RE2.test(slug)) return;
+    void handleEvent(slug, path10.join(dir, filename));
+  });
+  watcher.on("error", (err) => {
+    console.warn("[history watcher]", err.message);
+  });
+}
+async function handleEvent(slug, filePath2) {
+  let content;
+  try {
+    content = await fs18.readFile(filePath2, "utf8");
+  } catch {
+    return;
+  }
+  const sha = createHash2("sha256").update(content, "utf8").digest("hex");
+  if (isRecentWrite(slug, sha)) return;
+  recordHistory({ worksheet: slug, source: "external", content });
+}
+function stopWorksheetsWatcher() {
+  watcher?.close();
+  watcher = null;
+}
+
+// server/static.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path11 from "node:path";
+function defaultClientDir() {
+  if (process.env.OSDPT_CLIENT_DIST) return path11.resolve(process.env.OSDPT_CLIENT_DIST);
+  return fileURLToPath(new URL("./client", import.meta.url));
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8"
+};
+function contentType(file) {
+  return MIME[path11.extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+function cacheControl(urlPath) {
+  return urlPath.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache";
+}
+function serveClient(app8, clientDir = defaultClientDir()) {
+  if (!existsSync(path11.join(clientDir, "index.html"))) return false;
+  const indexHtml = path11.join(clientDir, "index.html");
+  app8.get("*", async (c) => {
+    if (c.req.path.startsWith("/api")) return c.notFound();
+    const rel = decodeURIComponent(c.req.path).replace(/^\/+/, "");
+    const candidate = path11.resolve(clientDir, rel);
+    const isInside = candidate === clientDir || candidate.startsWith(clientDir + path11.sep);
+    let file = indexHtml;
+    if (isInside && rel !== "" && existsSync(candidate) && !candidate.endsWith(path11.sep)) {
+      file = candidate;
+    }
+    try {
+      const body = await readFile(file);
+      return new Response(body, {
+        status: 200,
+        headers: {
+          "content-type": contentType(file),
+          "cache-control": cacheControl(c.req.path)
+        }
+      });
+    } catch {
+      return c.notFound();
+    }
+  });
+  return true;
+}
+
+// server/lib/open-browser.ts
+import { spawn } from "node:child_process";
+function openBrowser(url) {
+  const platform = process.platform;
+  const [cmd, args] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+      child.on("error", () => resolve(false));
+      child.unref();
+      setTimeout(() => resolve(true), 0);
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+// server/index.ts
+var DEFAULT_PORT = 3756;
+function listen(app8, port) {
+  return new Promise((resolve, reject) => {
+    let retried = false;
+    const attempt = (p) => {
+      const server = serve({ fetch: app8.fetch, port: p, hostname: "127.0.0.1" });
+      server.once("listening", () => resolve(server));
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && !retried) {
+          retried = true;
+          attempt(0);
+        } else {
+          reject(err);
+        }
+      });
+    };
+    attempt(port);
+  });
+}
+async function startServer(argv = process.argv.slice(2)) {
+  const workspace = await initWorkspace(argv);
+  await initTracing();
+  openHistoryDb();
+  startWorksheetsWatcher();
+  void autoConnectAll(workspace);
+  const app8 = new Hono10();
+  app8.get("/api/health", (c) => c.json({ ok: true, workspace }));
+  app8.route("/api/connections", connectionsRouter(workspace));
+  app8.route("/api/ai-providers", aiProvidersRouter(workspace));
+  app8.route("/api/worksheets", worksheets_default);
+  app8.route("/api/drafts", drafts_default);
+  app8.route("/api/session", session_default);
+  app8.route("/api/schema", schema_default);
+  app8.route("/api/history", history_default);
+  app8.route("/api/agent", agent_default);
+  app8.route("/api/context", context_default);
+  app8.onError((err, c) => {
+    if (err instanceof HTTPException4) return err.getResponse();
+    console.error("[os-dpt]", err);
+    return c.json({ error: err.message }, 500);
+  });
+  serveClient(app8);
+  const preferredPort = Number(process.env.PORT ?? DEFAULT_PORT);
+  const server = await listen(app8, preferredPort);
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : preferredPort;
+  const url = `http://127.0.0.1:${port}`;
+  let shuttingDown = false;
+  const close = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    stopWorksheetsWatcher();
+    closeHistoryDb();
+    await flushTracing();
+    await closeAll();
+    await new Promise((res) => server.close(() => res()));
+  };
+  return { url, port, workspace, close };
+}
+var isMain = process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  const boot = await startServer();
+  console.log(`os-dpt server listening on ${boot.url}`);
+  console.log(`workspace: ${boot.workspace}`);
+  const shutdown = async (signal) => {
+    console.log(`
+received ${signal}, closing pools\u2026`);
+    await boot.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  openBrowser,
+  startServer
+};