@askexenow/exe-os 0.9.295 → 0.9.296

package/dist/chunk-WUKHLCBE.js

@@ -0,0 +1,3313 @@
+import {
+  assertValidDbPath
+} from "./chunk-2I23RPSI.js";
+import {
+  listBackups
+} from "./chunk-2E43UXRH.js";
+import {
+  getEmotionalBaseline,
+  renderEmotionalBaselineSection
+} from "./chunk-PNQDP3OA.js";
+import {
+  isDaemonAlive
+} from "./chunk-7HLWBYH7.js";
+import {
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
+import {
+  EXE_AI_DIR,
+  loadConfigSync
+} from "./chunk-R36FAN53.js";
+import {
+  atomicWriteJson
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/database.ts
+import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
+import { createClient } from "@libsql/client";
+import { homedir, totalmem } from "os";
+import { join } from "path";
+
+// src/lib/db-retry.ts
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 250;
+var MAX_JITTER_MS = 400;
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// src/lib/employees.ts
+import { readFile, mkdir } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+import os from "os";
+
+// src/lib/identity.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { readdirSync } from "fs";
+import path from "path";
+import { createHash } from "crypto";
+var IDENTITY_DIR = path.join(EXE_AI_DIR, "identity");
+function ensureDir() {
+  if (!existsSync(IDENTITY_DIR)) {
+    mkdirSync(IDENTITY_DIR, { recursive: true });
+  }
+}
+function identityPath(agentId) {
+  return path.join(IDENTITY_DIR, `${agentId}.md`);
+}
+function sanitizeIdentityBody(body) {
+  return body.replace(/<!--[\s\S]*?-->/g, "").trim();
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return {
+      frontmatter: {
+        role: "unknown",
+        title: "Unknown",
+        agent_id: "unknown",
+        org_level: "specialist",
+        created_by: "system",
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      body: sanitizeIdentityBody(raw)
+    };
+  }
+  const yamlStr = match[1];
+  const body = sanitizeIdentityBody(match[2]);
+  const fm = {};
+  for (const line of yamlStr.split("\n")) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  return {
+    frontmatter: {
+      role: fm.role ?? "unknown",
+      title: fm.title ?? "Unknown",
+      agent_id: fm.agent_id ?? "unknown",
+      org_level: fm.org_level ?? "specialist",
+      created_by: fm.created_by ?? "system",
+      updated_at: fm.updated_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      tone: fm.tone,
+      vocabulary: fm.vocabulary,
+      response_style: fm.response_style,
+      communication_patterns: fm.communication_patterns
+    },
+    body
+  };
+}
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function getIdentity(agentId) {
+  const filePath = identityPath(agentId);
+  if (!existsSync(filePath)) return null;
+  const raw = readFileSync(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  return {
+    agentId,
+    frontmatter,
+    body,
+    raw,
+    contentHash: contentHash(raw)
+  };
+}
+async function updateIdentity(agentId, content, updatedBy) {
+  ensureDir();
+  const filePath = identityPath(agentId);
+  const hash = contentHash(content);
+  writeFileSync(filePath, content, "utf-8");
+  try {
+    const client = getClient();
+    await client.execute({
+      sql: `INSERT INTO identity (agent_id, content_hash, updated_at, updated_by)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(agent_id) DO UPDATE SET
+              content_hash = excluded.content_hash,
+              updated_at = excluded.updated_at,
+              updated_by = excluded.updated_by`,
+      args: [agentId, hash, (/* @__PURE__ */ new Date()).toISOString(), updatedBy]
+    });
+  } catch {
+  }
+}
+function listIdentities() {
+  ensureDir();
+  const files = readdirSync(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
+  const results = [];
+  for (const file of files) {
+    const agentId = file.replace(".md", "");
+    const identity = getIdentity(agentId);
+    if (!identity) continue;
+    const lines = identity.body.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+    const summary = lines[0]?.trim().slice(0, 120) ?? identity.frontmatter.title;
+    results.push({
+      agentId,
+      // User-facing/team-facing title only. `frontmatter.role` is internal
+      // routing metadata and must not leak as an external title.
+      title: identity.frontmatter.title,
+      summary
+    });
+  }
+  return results;
+}
+function getIdentityInjection(agentId) {
+  const own = getIdentity(agentId);
+  const all = listIdentities();
+  const parts = [];
+  if (own) {
+    parts.push(`## Your Identity (exe.md)
+These define WHO YOU ARE. Non-negotiable. Permanent.
+
+${own.body}`);
+    const personaLines = [];
+    if (own.frontmatter.tone) personaLines.push(`- **Tone:** ${own.frontmatter.tone}`);
+    if (own.frontmatter.vocabulary) personaLines.push(`- **Vocabulary:** ${own.frontmatter.vocabulary}`);
+    if (own.frontmatter.response_style) personaLines.push(`- **Response style:** ${own.frontmatter.response_style}`);
+    if (own.frontmatter.communication_patterns) personaLines.push(`- **Communication patterns:** ${own.frontmatter.communication_patterns}`);
+    if (personaLines.length > 0) {
+      parts.push(`## Persona
+How you communicate \u2014 these shape every response.
+
+${personaLines.join("\n")}`);
+    }
+    const emotionalBaseline = getEmotionalBaseline(own.frontmatter.role);
+    if (emotionalBaseline) {
+      parts.push(renderEmotionalBaselineSection(emotionalBaseline));
+    }
+  }
+  const teamLines = all.filter((a) => a.agentId !== agentId).map((a) => `- ${a.agentId} (${a.title}): ${a.summary}`);
+  if (teamLines.length > 0) {
+    parts.push(`## Team Identities
+${teamLines.join("\n")}`);
+  }
+  return parts.join("\n\n");
+}
+
+// src/lib/employees.ts
+var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+var DEFAULT_BOOT_TIMEOUT_MS = 45e3;
+var DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+var COORDINATOR_ROLE = "COO";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function getCoordinatorDisplayTitle(employees = loadEmployeesSync()) {
+  const coordinator = getCoordinatorEmployee(employees);
+  if (coordinator) {
+    try {
+      const identity = getIdentity(coordinator.name);
+      if (identity?.frontmatter?.title) return identity.frontmatter.title;
+    } catch {
+    }
+  }
+  return "Coordinator";
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+var MANAGER_ROLES = /* @__PURE__ */ new Map([
+  ["coo", /* @__PURE__ */ new Set(["cto", "cmo", "gm", "principal engineer", "content production specialist", "staff code reviewer", "ai product lead", "specialist"])],
+  ["cto", /* @__PURE__ */ new Set(["principal engineer", "staff code reviewer", "specialist"])],
+  ["cmo", /* @__PURE__ */ new Set(["content production specialist", "specialist"])],
+  ["gm", /* @__PURE__ */ new Set(["specialist"])]
+]);
+function canManage(callerName, callerRole, targetName, employees = loadEmployeesSync()) {
+  if (canCoordinate(callerName, callerRole, employees)) return true;
+  const targetBase = baseAgentName(targetName, employees);
+  const targetEmp = getEmployee(employees, targetBase);
+  if (!targetEmp) return false;
+  const normalizedCallerRole = normalizeRole(callerRole);
+  const allowedSubordinates = MANAGER_ROLES.get(normalizedCallerRole);
+  if (!allowedSubordinates) return false;
+  return allowedSubordinates.has(normalizeRole(targetEmp.role));
+}
+var VALID_AGENT_NAME = /^[a-z][a-z0-9]*$/;
+var VALID_AGENT_NAME_DESCRIPTION = "Name must start with a letter and contain only lowercase letters and digits (no hyphens, underscores, or spaces).";
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!VALID_AGENT_NAME.test(name)) {
+    return {
+      valid: false,
+      error: VALID_AGENT_NAME_DESCRIPTION
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir(path2.dirname(employeesPath), { recursive: true });
+  await atomicWriteJson(employeesPath, employees);
+}
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
+var MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set([
+  "principal engineer",
+  "content production specialist",
+  "staff code reviewer"
+]);
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function shouldAutoInstance(agentName, employees) {
+  const multi = isMultiInstance(agentName, employees);
+  if (!multi) return { autoInstance: false, maxAutoInstances: void 0 };
+  let max = 10;
+  try {
+    const config = loadConfigSync();
+    max = config.sessionLifecycle?.maxAutoInstances ?? 10;
+  } catch {
+  }
+  return { autoInstance: true, maxAutoInstances: max };
+}
+function addEmployee(employees, employee) {
+  const { systemPrompt: _legacyPrompt, ...rest } = employee;
+  const normalized = { ...rest, name: employee.name.toLowerCase() };
+  if (!VALID_AGENT_NAME.test(normalized.name)) {
+    throw new Error(
+      `Invalid agent name '${normalized.name}' \u2014 must be lowercase letters and digits only (no hyphens, underscores, or spaces). Example: 'davinci', not 'da-vinci'.`
+    );
+  }
+  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
+    throw new Error(`Employee '${normalized.name}' already exists`);
+  }
+  return [...employees, normalized];
+}
+var IDENTITY_DIR2 = path2.join(EXE_AI_DIR, "identity");
+var TEAM_SECTION_RE = /^## Team\b.*$/m;
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path2.join(IDENTITY_DIR2, `${coordinator.name}.md`);
+  if (!existsSync2(idPath)) return;
+  const content = readFileSync2(idPath, "utf-8");
+  if (content.includes(`**${capitalize(employee.name)}`)) return;
+  const teamMatch = content.match(TEAM_SECTION_RE);
+  if (!teamMatch || teamMatch.index === void 0) return;
+  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
+  const nextHeading = afterTeam.match(/\n## /);
+  const entry = `
+**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
+`;
+  let updated;
+  if (nextHeading && nextHeading.index !== void 0) {
+    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
+    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
+  } else {
+    updated = content.trimEnd() + "\n" + entry;
+  }
+  writeFileSync2(idPath, updated, "utf-8");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function hireEmployee(employee) {
+  const employees = await loadEmployees();
+  const updated = addEmployee(employees, employee);
+  await saveEmployees(updated);
+  try {
+    appendToCoordinatorTeam(employee);
+  } catch {
+  }
+  try {
+    const { loadAgentConfig, saveAgentConfig } = await import("./lib/agent-config.js");
+    const config = loadAgentConfig();
+    const name = employee.name.toLowerCase();
+    if (!config[name] && config["default"]) {
+      config[name] = { ...config["default"] };
+      saveAgentConfig(config);
+    }
+  } catch {
+  }
+  return updated;
+}
+async function normalizeRosterCase(rosterPath) {
+  const employees = await loadEmployees(rosterPath);
+  let changed = false;
+  for (const emp of employees) {
+    if (emp.name !== emp.name.toLowerCase()) {
+      const oldName = emp.name;
+      emp.name = emp.name.toLowerCase();
+      changed = true;
+      try {
+        const identityDir = path2.join(os.homedir(), ".exe-os", "identity");
+        const oldPath = path2.join(identityDir, `${oldName}.md`);
+        const newPath = path2.join(identityDir, `${emp.name}.md`);
+        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+          renameSync(oldPath, newPath);
+        } else if (existsSync2(oldPath) && oldPath !== newPath) {
+          const content = readFileSync2(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
+  }
+  return changed;
+}
+function findExeBin() {
+  try {
+    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path2.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path2.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+
+// src/lib/database-adapter.ts
+import os2 from "os";
+import path3 from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var VIEW_MAPPINGS = [
+  { view: "memories", source: "graph.memory_records" },
+  { view: "tasks", source: "graph.tasks" },
+  { view: "behaviors", source: "graph.behaviors" },
+  { view: "entities", source: "graph.entities" },
+  { view: "relationships", source: "graph.relationships" },
+  { view: "entity_memories", source: "graph.entity_memories" },
+  { view: "entity_aliases", source: "graph.entity_aliases" },
+  { view: "notifications", source: "graph.notifications" },
+  { view: "messages", source: "graph.messages" },
+  { view: "users", source: "wiki.users" },
+  { view: "workspaces", source: "wiki.workspaces" },
+  { view: "workspace_users", source: "wiki.workspace_users" },
+  { view: "documents", source: "wiki.workspace_documents" },
+  { view: "chats", source: "wiki.workspace_chats" }
+];
+var UPSERT_KEYS = {
+  memories: ["id"],
+  tasks: ["id"],
+  behaviors: ["id"],
+  entities: ["id"],
+  relationships: ["id"],
+  entity_aliases: ["alias"],
+  notifications: ["id"],
+  messages: ["id"],
+  users: ["id"],
+  workspaces: ["id"],
+  workspace_users: ["id"],
+  documents: ["id"],
+  chats: ["id"]
+};
+var BOOLEAN_COLUMNS_BY_TABLE = {
+  memories: /* @__PURE__ */ new Set(["has_error", "draft"]),
+  behaviors: /* @__PURE__ */ new Set(["active"]),
+  notifications: /* @__PURE__ */ new Set(["read"]),
+  users: /* @__PURE__ */ new Set(["has_personal_memory"])
+};
+var BOOLEAN_COLUMN_NAMES = new Set(
+  Object.values(BOOLEAN_COLUMNS_BY_TABLE).flatMap((cols) => [...cols])
+);
+var IMMEDIATE_FALLBACK_PATTERNS = [
+  /\bPRAGMA\b/i,
+  /\bsqlite_master\b/i,
+  /(?:^|[.\s])(?:memories|conversations|entities)_fts\b/i,
+  /\bMATCH\b/i,
+  /\bvector_distance_cos\s*\(/i,
+  /\bjson_extract\s*\(/i,
+  /\bjulianday\s*\(/i,
+  /\bstrftime\s*\(/i,
+  /\blast_insert_rowid\s*\(/i
+];
+var prismaClientPromise = null;
+var compatibilityBootstrapPromise = null;
+function quotedIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function unqualifiedTableName(name) {
+  const raw = name.trim().replace(/^"|"$/g, "");
+  const parts = raw.split(".");
+  return parts[parts.length - 1].replace(/^"|"$/g, "").toLowerCase();
+}
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/u, "");
+}
+function appendClause(sql, clause) {
+  const trimmed = stripTrailingSemicolon(sql);
+  const returningMatch = /\sRETURNING\b[\s\S]*$/iu.exec(trimmed);
+  if (!returningMatch) {
+    return `${trimmed}${clause}`;
+  }
+  const idx = returningMatch.index;
+  return `${trimmed.slice(0, idx)}${clause}${trimmed.slice(idx)}`;
+}
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { kind: "positional", sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  if (Array.isArray(stmt.args) || stmt.args === void 0) {
+    return { kind: "positional", sql, args: stmt.args ?? [] };
+  }
+  return { kind: "named", sql, args: stmt.args };
+}
+function rewriteBooleanLiterals(sql) {
+  let out = sql;
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const scoped = `((?:\\b[a-z_][a-z0-9_]*\\.)?${column})`;
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*0\\b`, "giu"), "$1 = FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*1\\b`, "giu"), "$1 = TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*0\\b`, "giu"), "$1 != FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*1\\b`, "giu"), "$1 != TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*0\\b`, "giu"), "$1 <> FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*1\\b`, "giu"), "$1 <> TRUE");
+  }
+  return out;
+}
+function rewriteInsertOrIgnore(sql) {
+  if (!/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu.test(sql)) {
+    return sql;
+  }
+  const replaced = sql.replace(/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu, "INSERT INTO");
+  return /\bON\s+CONFLICT\b/iu.test(replaced) ? replaced : appendClause(replaced, " ON CONFLICT DO NOTHING");
+}
+function rewriteInsertOrReplace(sql) {
+  const match = /^\s*INSERT\s+OR\s+REPLACE\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)([\s\S]*)$/iu.exec(sql);
+  if (!match) {
+    return sql;
+  }
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const remainder = match[3];
+  const tableName = unqualifiedTableName(rawTable);
+  const conflictKeys = UPSERT_KEYS[tableName];
+  if (!conflictKeys?.length) {
+    return sql;
+  }
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  const updateColumns = columns.filter((col) => !conflictKeys.includes(col));
+  const conflictTarget = conflictKeys.map(quotedIdentifier).join(", ");
+  const updateClause = updateColumns.length === 0 ? " DO NOTHING" : ` DO UPDATE SET ${updateColumns.map((col) => `${quotedIdentifier(col)} = EXCLUDED.${quotedIdentifier(col)}`).join(", ")}`;
+  return `INSERT INTO ${rawTable} (${rawColumns})${appendClause(remainder, ` ON CONFLICT (${conflictTarget})${updateClause}`)}`;
+}
+function rewriteSql(sql) {
+  let out = sql;
+  out = out.replace(/\bdatetime\(\s*['"]now['"]\s*\)/giu, "CURRENT_TIMESTAMP");
+  out = out.replace(/\bvector32\s*\(\s*\?\s*\)/giu, "?");
+  out = rewriteBooleanLiterals(out);
+  out = rewriteInsertOrReplace(out);
+  out = rewriteInsertOrIgnore(out);
+  return stripTrailingSemicolon(out);
+}
+function toBoolean(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "bigint") return value !== 0n;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false") return false;
+    if (normalized === "1" || normalized === "true") return true;
+  }
+  return Boolean(value);
+}
+function countQuestionMarks(sql, end) {
+  let count = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < end; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function findBooleanPlaceholderIndexes(sql) {
+  const indexes = /* @__PURE__ */ new Set();
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const pattern = new RegExp(`(?:\\b[a-z_][a-z0-9_]*\\.)?${column}\\s*=\\s*\\?`, "giu");
+    for (const match of sql.matchAll(pattern)) {
+      const matchText = match[0];
+      const qIndex = match.index + matchText.lastIndexOf("?");
+      indexes.add(countQuestionMarks(sql, qIndex + 1));
+    }
+  }
+  return indexes;
+}
+function coerceInsertBooleanArgs(sql, args) {
+  const match = /^\s*INSERT(?:\s+OR\s+(?:IGNORE|REPLACE))?\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  for (const [index, column] of columns.entries()) {
+    if (boolColumns.has(column) && index < args.length) {
+      args[index] = toBoolean(args[index]);
+    }
+  }
+}
+function coerceUpdateBooleanArgs(sql, args) {
+  const match = /^\s*UPDATE\s+([A-Za-z0-9_."]+)\s+SET\s+([\s\S]+?)(?:\s+WHERE\b|$)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const setClause = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const assignments = setClause.split(",");
+  let placeholderIndex = 0;
+  for (const assignment of assignments) {
+    if (!assignment.includes("?")) continue;
+    placeholderIndex += 1;
+    const colMatch = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*\.)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\?/iu.exec(assignment);
+    if (colMatch && boolColumns.has(colMatch[1])) {
+      args[placeholderIndex - 1] = toBoolean(args[placeholderIndex - 1]);
+    }
+  }
+}
+function coerceBooleanArgs(sql, args) {
+  const nextArgs = [...args];
+  coerceInsertBooleanArgs(sql, nextArgs);
+  coerceUpdateBooleanArgs(sql, nextArgs);
+  const placeholderIndexes = findBooleanPlaceholderIndexes(sql);
+  for (const index of placeholderIndexes) {
+    if (index > 0 && index <= nextArgs.length) {
+      nextArgs[index - 1] = toBoolean(nextArgs[index - 1]);
+    }
+  }
+  return nextArgs;
+}
+function convertQuestionMarksToDollarParams(sql) {
+  let out = "";
+  let placeholder = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      out += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      out += ch;
+      if (ch === "*" && next === "/") {
+        out += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      out += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      out += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      placeholder += 1;
+      out += `$${placeholder}`;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function translateStatementForPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    throw new Error("Named SQL parameters are not supported by the Prisma adapter.");
+  }
+  const rewrittenSql = rewriteSql(normalized.sql);
+  const coercedArgs = coerceBooleanArgs(rewrittenSql, normalized.args);
+  return {
+    sql: convertQuestionMarksToDollarParams(rewrittenSql),
+    args: coercedArgs
+  };
+}
+function shouldBypassPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    return true;
+  }
+  return IMMEDIATE_FALLBACK_PATTERNS.some((pattern) => pattern.test(normalized.sql));
+}
+function shouldFallbackOnError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /42P01|42883|42601|does not exist|syntax error|not supported|Named SQL parameters are not supported/iu.test(message);
+}
+function isReadQuery(sql) {
+  const trimmed = sql.trimStart();
+  return /^(SELECT|WITH|SHOW|EXPLAIN|VALUES)\b/iu.test(trimmed) || /\bRETURNING\b/iu.test(trimmed);
+}
+function buildRow(row, columns) {
+  const values = columns.map((column) => row[column]);
+  return Object.assign(values, row);
+}
+function buildResultSet(rows, rowsAffected = 0) {
+  const columns = rows[0] ? Object.keys(rows[0]) : [];
+  const resultRows = rows.map((row) => buildRow(row, columns));
+  return {
+    columns,
+    columnTypes: columns.map(() => ""),
+    rows: resultRows,
+    rowsAffected,
+    lastInsertRowid: void 0,
+    toJSON() {
+      return {
+        columns,
+        columnTypes: columns.map(() => ""),
+        rows,
+        rowsAffected,
+        lastInsertRowid: void 0
+      };
+    }
+  };
+}
+async function loadPrismaClient() {
+  if (!prismaClientPromise) {
+    prismaClientPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const module2 = await import(pathToFileURL(explicitPath).href);
+        const PrismaClient2 = module2.PrismaClient ?? module2.default?.PrismaClient;
+        if (!PrismaClient2) {
+          throw new Error(`No PrismaClient export found at ${explicitPath}`);
+        }
+        return new PrismaClient2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path3.join(os2.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path3.join(exeDbRoot, "package.json"));
+      const prismaEntry = requireFromExeDb.resolve("@prisma/client");
+      const module = await import(pathToFileURL(prismaEntry).href);
+      const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
+      if (!PrismaClient) {
+        throw new Error(`No PrismaClient export found in ${prismaEntry}`);
+      }
+      return new PrismaClient();
+    })();
+  }
+  return prismaClientPromise;
+}
+async function ensureCompatibilityViews(prisma) {
+  if (!compatibilityBootstrapPromise) {
+    compatibilityBootstrapPromise = (async () => {
+      for (const mapping of VIEW_MAPPINGS) {
+        const relation = mapping.source.replace(/"/g, "");
+        const rows = await prisma.$queryRawUnsafe(
+          "SELECT to_regclass($1)::text AS regclass",
+          relation
+        );
+        if (!rows[0]?.regclass) {
+          continue;
+        }
+        await prisma.$executeRawUnsafe(
+          `CREATE OR REPLACE VIEW public.${quotedIdentifier(mapping.view)} AS SELECT * FROM ${mapping.source}`
+        );
+      }
+    })();
+  }
+  return compatibilityBootstrapPromise;
+}
+async function executeOnPrisma(executor, stmt) {
+  const translated = translateStatementForPostgres(stmt);
+  if (isReadQuery(translated.sql)) {
+    const rows = await executor.$queryRawUnsafe(
+      translated.sql,
+      ...translated.args
+    );
+    return buildResultSet(rows, /\bRETURNING\b/iu.test(translated.sql) ? rows.length : 0);
+  }
+  const rowsAffected = await executor.$executeRawUnsafe(translated.sql, ...translated.args);
+  return buildResultSet([], rowsAffected);
+}
+function splitSqlStatements(sql) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      current += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      current += ch;
+      if (ch === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      current += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      current += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === ";") {
+      if (current.trim()) {
+        parts.push(current.trim());
+      }
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+async function createPrismaDbAdapter(fallbackClient) {
+  const prisma = await loadPrismaClient();
+  await ensureCompatibilityViews(prisma);
+  let closed = false;
+  const fallbackExecute = async (stmt, error) => {
+    if (!fallbackClient) {
+      if (error) throw error;
+      throw new Error("No fallback SQLite client is available for this Prisma-routed query.");
+    }
+    if (error) {
+      process.stderr.write(
+        `[database-adapter] Falling back to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+    return fallbackClient.execute(stmt);
+  };
+  const adapter = {
+    async execute(stmt) {
+      if (shouldBypassPostgres(stmt)) {
+        return fallbackExecute(stmt);
+      }
+      try {
+        return await executeOnPrisma(prisma, stmt);
+      } catch (error) {
+        if (shouldFallbackOnError(error)) {
+          return fallbackExecute(stmt, error);
+        }
+        throw error;
+      }
+    },
+    async batch(stmts, mode) {
+      if (stmts.some((stmt) => shouldBypassPostgres(stmt))) {
+        if (!fallbackClient) {
+          throw new Error("Cannot batch unsupported SQLite-only statements without a fallback client.");
+        }
+        return fallbackClient.batch(stmts, mode);
+      }
+      try {
+        if (prisma.$transaction) {
+          return await prisma.$transaction(async (tx) => {
+            const results2 = [];
+            for (const stmt of stmts) {
+              results2.push(await executeOnPrisma(tx, stmt));
+            }
+            return results2;
+          });
+        }
+        const results = [];
+        for (const stmt of stmts) {
+          results.push(await executeOnPrisma(prisma, stmt));
+        }
+        return results;
+      } catch (error) {
+        if (fallbackClient && shouldFallbackOnError(error)) {
+          process.stderr.write(
+            `[database-adapter] Falling back batch to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw error;
+      }
+    },
+    async migrate(stmts) {
+      if (fallbackClient) {
+        return fallbackClient.migrate(stmts);
+      }
+      return adapter.batch(stmts, "deferred");
+    },
+    async transaction(mode) {
+      if (!fallbackClient) {
+        throw new Error("Interactive transactions are only supported on the SQLite fallback client.");
+      }
+      return fallbackClient.transaction(mode);
+    },
+    async executeMultiple(sql) {
+      if (fallbackClient && shouldBypassPostgres(sql)) {
+        return fallbackClient.executeMultiple(sql);
+      }
+      for (const statement of splitSqlStatements(sql)) {
+        await adapter.execute(statement);
+      }
+    },
+    async sync() {
+      if (fallbackClient) {
+        return fallbackClient.sync();
+      }
+      return { frame_no: 0, frames_synced: 0 };
+    },
+    close() {
+      closed = true;
+      prismaClientPromise = null;
+      compatibilityBootstrapPromise = null;
+      void prisma.$disconnect?.();
+    },
+    get closed() {
+      return closed;
+    },
+    get protocol() {
+      return "prisma-postgres";
+    }
+  };
+  return adapter;
+}
+
+// src/lib/database.ts
+function _checkDaemonAliveSync() {
+  return isDaemonAlive().alive;
+}
+var _debugDb = process.env.EXE_DEBUG === "1";
+function logCatchDebug(context, err) {
+  if (_debugDb) {
+    process.stderr.write(
+      `[database] ${context}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function isAlreadyExistsSchemaError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("duplicate column") || msg.includes("already exists");
+}
+function rethrowUnlessAlreadyExists(context, err) {
+  if (isAlreadyExistsSchemaError(err)) {
+    logCatchDebug(context, err);
+    return;
+  }
+  process.stderr.write(
+    `[database] ERROR: ${context} failed: ${err instanceof Error ? err.message : String(err)}
+`
+  );
+  throw err;
+}
+async function executeAddColumn(client, sql, context = "migration add column") {
+  try {
+    await client.execute(sql);
+    return true;
+  } catch (e) {
+    rethrowUnlessAlreadyExists(context, e);
+    return false;
+  }
+}
+var _client = null;
+var _resilientClient = null;
+var _walCheckpointTimer = null;
+var _daemonClient = null;
+var _adapterClient = null;
+var _lockFd = null;
+var DB_LOCK_PATH = join(homedir(), ".exe-os", "db.lock");
+function acquireDbLock() {
+  mkdirSync2(join(homedir(), ".exe-os"), { recursive: true });
+  try {
+    _lockFd = openSync(DB_LOCK_PATH, "wx");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+      try {
+        const lockStat = statSync(DB_LOCK_PATH);
+        if (Date.now() - lockStat.mtimeMs > 6e4) {
+          unlinkSync2(DB_LOCK_PATH);
+          _lockFd = openSync(DB_LOCK_PATH, "wx");
+          return;
+        }
+      } catch (e) {
+        logCatchDebug("stale lock check", e);
+      }
+      process.stderr.write(
+        "[database] WARN: Another process holds db.lock \u2014 waiting briefly then proceeding.\n"
+      );
+      return;
+    }
+    throw err;
+  }
+}
+function releaseDbLock() {
+  if (_lockFd !== null) {
+    try {
+      closeSync(_lockFd);
+    } catch (e) {
+      logCatchDebug("lock close", e);
+    }
+    _lockFd = null;
+  }
+  try {
+    unlinkSync2(DB_LOCK_PATH);
+  } catch (e) {
+    logCatchDebug("lock unlink", e);
+  }
+}
+var CORRUPTION_ERROR_RE = /malformed|disk image|sqlite_corrupt|database is corrupt|corrupt(ed)? (database|page|index)|btree/i;
+var NON_CORRUPTION_OPEN_ERROR_RE = /not a database|file is encrypted|is encrypted|encryption|cipher|hmac|locked|database is busy|\bbusy\b|unable to open|no such file|permission denied|readonly|read-only/i;
+async function _checkDbIntegrity(client) {
+  try {
+    const intCheck = await client.execute("PRAGMA quick_check");
+    const result = String(intCheck.rows[0]?.[0] ?? "");
+    if (result !== "ok") {
+      process.stderr.write(
+        `[database] CRITICAL: quick_check failed: ${result}. DB is corrupt.
+`
+      );
+      return true;
+    }
+    return false;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (CORRUPTION_ERROR_RE.test(msg) && !NON_CORRUPTION_OPEN_ERROR_RE.test(msg)) {
+      process.stderr.write(
+        `[database] CRITICAL: quick_check reported corruption (${msg}). Will attempt backup restore.
+`
+      );
+      return true;
+    }
+    process.stderr.write(
+      `[database] CRITICAL: quick_check could not run (${msg}). Refusing to start without touching the database \u2014 likely a wrong SQLCipher key, locked/busy database, or open failure. Resolve the key/lock issue and retry; the data is intact.
+`
+    );
+    throw e;
+  }
+}
+async function _attemptBackupRestore(config) {
+  assertValidDbPath(config.dbPath, "database backup restore");
+  const backups = listBackups();
+  if (backups.length === 0) {
+    process.stderr.write(
+      `[database] CRITICAL: No backups found in ~/.exe-os/backups/ \u2014 cannot auto-restore.
+`
+    );
+    return null;
+  }
+  const timestamp = Date.now();
+  const corruptPath = `${config.dbPath}.corrupt-${timestamp}`;
+  try {
+    renameSync2(config.dbPath, corruptPath);
+    for (const suffix of ["-wal", "-shm"]) {
+      const sidePath = config.dbPath + suffix;
+      if (existsSync3(sidePath)) {
+        try {
+          renameSync2(sidePath, corruptPath + suffix);
+        } catch {
+        }
+      }
+    }
+    process.stderr.write(
+      `[database] Moved corrupt DB to ${corruptPath}
+`
+    );
+  } catch (moveErr) {
+    process.stderr.write(
+      `[database] ERROR: Failed to move corrupt DB: ${moveErr instanceof Error ? moveErr.message : String(moveErr)}
+`
+    );
+    return null;
+  }
+  for (const backup of backups) {
+    process.stderr.write(
+      `[database] Trying backup: ${backup.name} (${backup.date.toISOString()})
+`
+    );
+    try {
+      copyFileSync(backup.path, config.dbPath);
+      const backupWal = backup.path + "-wal";
+      if (existsSync3(backupWal)) {
+        copyFileSync(backupWal, config.dbPath + "-wal");
+      }
+      const opts = {
+        url: `file:${config.dbPath}`
+      };
+      if (config.encryptionKey) {
+        opts.encryptionKey = config.encryptionKey;
+      }
+      const testClient = createClient(opts);
+      await testClient.execute("PRAGMA busy_timeout = 30000");
+      await testClient.execute("PRAGMA journal_mode = WAL");
+      const isCorrupt = await _checkDbIntegrity(testClient);
+      if (isCorrupt) {
+        testClient.close();
+        try {
+          unlinkSync2(config.dbPath);
+        } catch {
+        }
+        try {
+          unlinkSync2(config.dbPath + "-wal");
+        } catch {
+        }
+        try {
+          unlinkSync2(config.dbPath + "-shm");
+        } catch {
+        }
+        process.stderr.write(
+          `[database] Backup ${backup.name} is also corrupt, trying next...
+`
+        );
+        continue;
+      }
+      const corruptStat = statSync(corruptPath);
+      const backupAge = Date.now() - backup.date.getTime();
+      const hoursLost = Math.round(backupAge / (1e3 * 60 * 60) * 10) / 10;
+      process.stderr.write(
+        `[database] RESTORED from backup: ${backup.name}
+[database] Backup date: ${backup.date.toISOString()}
+[database] Corrupt DB date: ${new Date(corruptStat.mtimeMs).toISOString()}
+[database] Estimated data loss window: ~${hoursLost} hours
+[database] Corrupt DB preserved at: ${corruptPath}
+`
+      );
+      try {
+        const { recordDbRestoreEvent } = await import("./db-restore-events-GNZS42YO.js");
+        recordDbRestoreEvent({
+          kind: "auto-restore",
+          restoredFrom: backup.name,
+          backupDate: backup.date.toISOString(),
+          hoursLost,
+          quarantinePath: corruptPath,
+          detail: `DB corruption detected at startup; restored from ${backup.name} (~${hoursLost}h data-loss window)`
+        });
+      } catch {
+      }
+      try {
+        const { pruneCorruptQuarantine } = await import("./db-backup-VUGFTPJ4.js");
+        pruneCorruptQuarantine();
+      } catch {
+      }
+      return { client: testClient };
+    } catch (restoreErr) {
+      process.stderr.write(
+        `[database] Failed to restore from ${backup.name}: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}
+`
+      );
+      try {
+        unlinkSync2(config.dbPath);
+      } catch {
+      }
+      try {
+        unlinkSync2(config.dbPath + "-wal");
+      } catch {
+      }
+      try {
+        unlinkSync2(config.dbPath + "-shm");
+      } catch {
+      }
+      continue;
+    }
+  }
+  process.stderr.write(
+    `[database] CRITICAL: All ${backups.length} backups are corrupt or unreadable. Refusing to create an empty DB.
+[database] Corrupt DB preserved at: ${corruptPath}
+`
+  );
+  try {
+    const { recordDbRestoreEvent } = await import("./db-restore-events-GNZS42YO.js");
+    recordDbRestoreEvent({
+      kind: "restore-failed",
+      quarantinePath: corruptPath,
+      detail: `DB corruption detected at startup; all ${backups.length} backups were also corrupt or unreadable`
+    });
+  } catch {
+  }
+  return null;
+}
+var WAL_ESCALATION_THRESHOLD_BYTES = 256 * 1024 * 1024;
+async function checkpointWalIfLarge(dbPath, client = getRawClient(), thresholdBytes = WAL_ESCALATION_THRESHOLD_BYTES) {
+  const walPath = `${dbPath}-wal`;
+  let walSize = 0;
+  try {
+    walSize = statSync(walPath).size;
+  } catch {
+    return "skipped";
+  }
+  if (walSize < thresholdBytes) return "skipped";
+  await client.execute("PRAGMA wal_checkpoint(RESTART)");
+  try {
+    walSize = statSync(walPath).size;
+  } catch {
+    return "restart";
+  }
+  if (walSize < thresholdBytes) return "restart";
+  await client.execute("PRAGMA wal_checkpoint(TRUNCATE)");
+  return "truncate";
+}
+var initTurso = initDatabase;
+async function initDatabase(config) {
+  assertValidDbPath(config?.dbPath, "initDatabase");
+  acquireDbLock();
+  if (existsSync3(config.dbPath)) {
+    const dbStat = statSync(config.dbPath);
+    if (dbStat.size === 0) {
+      const walPath = config.dbPath + "-wal";
+      if (existsSync3(walPath) && statSync(walPath).size > 0) {
+        const backupPath = config.dbPath + ".zeroed-" + Date.now();
+        copyFileSync(config.dbPath, backupPath);
+        unlinkSync2(config.dbPath);
+        process.stderr.write(
+          `[database] CRITICAL: DB was 0 bytes. Moved to ${backupPath}, attempting WAL recovery.
+`
+        );
+        try {
+          const { recordDbRestoreEvent } = await import("./db-restore-events-GNZS42YO.js");
+          recordDbRestoreEvent({
+            kind: "wal-recovery",
+            quarantinePath: backupPath,
+            detail: "DB was 0 bytes at startup; reconstructing from WAL"
+          });
+        } catch {
+        }
+      } else {
+        process.stderr.write(
+          `[database] CRITICAL: DB is 0 bytes and no WAL available for recovery. Data may be lost. Check backups at ${config.dbPath}.bak
+`
+        );
+        try {
+          const { recordDbRestoreEvent } = await import("./db-restore-events-GNZS42YO.js");
+          recordDbRestoreEvent({
+            kind: "zeroed-no-wal",
+            detail: "DB was 0 bytes at startup with no WAL available \u2014 data may be lost"
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+  const opts = {
+    url: `file:${config.dbPath}`
+  };
+  if (config.encryptionKey) {
+    opts.encryptionKey = config.encryptionKey;
+  }
+  _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
+  _adapterClient = _resilientClient;
+  await _client.execute("PRAGMA busy_timeout = 30000");
+  await _client.execute("PRAGMA journal_mode = WAL");
+  await _client.execute("PRAGMA synchronous = NORMAL");
+  await _client.execute("PRAGMA cache_size = -65536");
+  const _totalMem = totalmem();
+  const _mmapSize = Math.min(536870912, Math.floor(_totalMem / 4));
+  await _client.execute(`PRAGMA mmap_size = ${_mmapSize}`);
+  await _client.execute("PRAGMA temp_store = MEMORY");
+  if (process.env.EXE_IS_DAEMON === "1") {
+    await _client.execute("PRAGMA wal_autocheckpoint = 0");
+  }
+  let dbIsCorrupt = false;
+  try {
+    dbIsCorrupt = await _checkDbIntegrity(_client);
+  } catch (e) {
+    releaseDbLock();
+    throw e;
+  }
+  if (dbIsCorrupt) {
+    const restored = await _attemptBackupRestore(config);
+    if (restored) {
+      _client = restored.client;
+      _resilientClient = wrapWithRetry(_client);
+      _adapterClient = _resilientClient;
+    } else {
+      releaseDbLock();
+      throw new Error("Database quick_check reported corruption and no valid backup could be restored; refusing to create an empty DB.");
+    }
+  }
+  if (_walCheckpointTimer) clearInterval(_walCheckpointTimer);
+  _walCheckpointTimer = setInterval(() => {
+    _client?.execute("PRAGMA wal_checkpoint(PASSIVE)").then(() => {
+      if (process.env.EXE_IS_DAEMON === "1" && _client) {
+        return checkpointWalIfLarge(config.dbPath, _client).then(() => void 0);
+      }
+      return void 0;
+    }).catch(() => {
+    });
+  }, 3e4);
+  _walCheckpointTimer.unref();
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") {
+    _adapterClient = await createPrismaDbAdapter(_resilientClient);
+  }
+  try {
+    chmodSync(config.dbPath, 384);
+    for (const suffix of ["-wal", "-shm"]) {
+      try {
+        chmodSync(config.dbPath + suffix, 384);
+      } catch (chmodErr) {
+        process.stderr.write(`[database] chmod ${suffix} failed: ${chmodErr instanceof Error ? chmodErr.message : String(chmodErr)}
+`);
+      }
+    }
+  } catch (chmodErr) {
+    process.stderr.write(`[database] chmod db failed: ${chmodErr instanceof Error ? chmodErr.message : String(chmodErr)}
+`);
+  }
+  releaseDbLock();
+}
+function isInitialized() {
+  return _adapterClient !== null || _client !== null;
+}
+function setExternalClient(client) {
+  _adapterClient = client;
+}
+var SOFT_DELETE_RETENTION_DAYS = 7;
+function getClient() {
+  if (!_adapterClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") {
+    return _adapterClient;
+  }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && (_daemonClient._isDaemonActive() || process.env.EXE_MCP_MODE === "1")) {
+    return _daemonClient;
+  }
+  if (!_resilientClient) {
+    return _adapterClient;
+  }
+  if (process.env.EXE_DB_READONLY === "1" || process.env.EXE_DB_DIRECT === "1") {
+    return _resilientClient;
+  }
+  if (!process.env.EXE_MCP_MODE) {
+    let daemonAlive = false;
+    try {
+      daemonAlive = _checkDaemonAliveSync();
+    } catch {
+    }
+    if (daemonAlive) {
+      process.stderr.write(
+        "[database] INFO: daemon running \u2014 CLI taking direct SQLite access (single-writer CLI mode).\n"
+      );
+    } else {
+      process.stderr.write(
+        "[database] WARN: daemon unavailable \u2014 using direct SQLite (single-writer CLI mode).\n"
+      );
+    }
+    return _resilientClient;
+  }
+  process.stderr.write(
+    "[database] ERROR: Daemon is not running \u2014 refusing direct SQLite write access.\n[database] Direct writes from MCP processes bypass the single-writer gate and corrupt FTS5.\n[database] Restart the daemon: kill $(cat ~/.exe-os/exed.pid) && exe-os update\n"
+  );
+  throw new Error(
+    "Daemon not running. Direct SQLite writes from MCP processes are blocked to prevent FTS5 corruption. Restart daemon to restore service."
+  );
+}
+async function initDaemonClient() {
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
+  if (process.env.EXE_IS_DAEMON === "1") return;
+  if (process.env.EXE_DB_READONLY === "1" || process.env.EXE_DB_DIRECT === "1" || process.env.EXE_SKIP_DAEMON === "1") return;
+  if (process.env.VITEST) return;
+  if (!_resilientClient) return;
+  if (_daemonClient) return;
+  try {
+    const { initDaemonDbClient } = await import("./lib/db-daemon-client.js");
+    _daemonClient = await initDaemonDbClient(_resilientClient);
+  } catch (err) {
+    process.stderr.write(
+      `[database] Daemon client init failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function getRawClient() {
+  if (!_client) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _client;
+}
+async function ensureSchema() {
+  const client = getRawClient();
+  await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 30000");
+  await client.execute("PRAGMA synchronous = NORMAL");
+  await client.execute("PRAGMA cache_size = -65536");
+  await client.execute("PRAGMA mmap_size = 536870912");
+  await client.execute("PRAGMA temp_store = MEMORY");
+  if (process.env.EXE_IS_DAEMON === "1") {
+    await client.execute("PRAGMA wal_autocheckpoint = 0");
+  }
+  try {
+    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      timestamp     TEXT NOT NULL,
+      tool_name     TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      raw_text      TEXT NOT NULL,
+      vector        F32_BLOB(1024),
+      version       INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent
+      ON memories(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_timestamp
+      ON memories(timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_session
+      ON memories(session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_project
+      ON memories(project_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_tool
+      ON memories(tool_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_version
+      ON memories(version);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent_project
+      ON memories(agent_id, project_name);
+  `);
+  try {
+    await client.execute("ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''");
+  } catch (e) {
+    rethrowUnlessAlreadyExists("migration add memories.keywords", e);
+  }
+  try {
+    await client.execute("ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0");
+  } catch (e) {
+    rethrowUnlessAlreadyExists("migration add memories.graph_extracted", e);
+  }
+  await executeAddColumn(client, "ALTER TABLE memories ADD COLUMN embedding_model TEXT", "migration add memories.embedding_model");
+  await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_embedding_model ON memories(embedding_model)");
+  let needsFtsMigration = false;
+  try {
+    const ftsCheck = await client.execute(
+      "SELECT sql FROM sqlite_master WHERE type='table' AND name='memories_fts'"
+    );
+    const ftsSql = ftsCheck.rows[0]?.sql ?? "";
+    needsFtsMigration = ftsSql.length > 0 && !ftsSql.includes("keywords");
+    if (ftsCheck.rows.length === 0) {
+      needsFtsMigration = true;
+    }
+  } catch {
+    needsFtsMigration = true;
+  }
+  if (needsFtsMigration) {
+    try {
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_ai");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_ad");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_au");
+      await client.execute("DROP TRIGGER IF EXISTS memories_fts_soft_delete");
+      await client.execute("DROP TABLE IF EXISTS memories_fts");
+    } catch (e) {
+      logCatchDebug("fts-migration-drop", e);
+    }
+  }
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      keywords,
+      content='memories',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories
+    WHEN old.status IS NULL OR old.status != 'deleted' BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE OF raw_text, keywords ON memories
+    WHEN new.status IS NULL OR new.status != 'deleted' BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+      INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+    END;
+
+    -- Soft-delete trigger: remove from FTS when status changes to 'deleted'
+    CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE ON memories
+    WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+    END;
+  `);
+  if (needsFtsMigration) {
+    try {
+      await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+    } catch (e) {
+      logCatchDebug("fts-rebuild", e);
+    }
+  }
+  try {
+    await client.execute("SELECT COUNT(*) FROM memories_fts LIMIT 1");
+  } catch (ftsErr) {
+    process.stderr.write(
+      `[database] WARN: memories_fts corrupted (${ftsErr instanceof Error ? ftsErr.message : String(ftsErr)}) \u2014 rebuilding FTS index.
+`
+    );
+    try {
+      await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+      process.stderr.write("[database] FTS index rebuilt successfully.\n");
+    } catch (rebuildErr) {
+      process.stderr.write(
+        `[database] ERROR: FTS rebuild failed: ${rebuildErr instanceof Error ? rebuildErr.message : String(rebuildErr)}
+`
+      );
+    }
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS sync_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id            TEXT PRIMARY KEY,
+      title         TEXT NOT NULL,
+      assigned_to   TEXT NOT NULL,
+      assigned_by   TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      priority      TEXT NOT NULL DEFAULT 'p1',
+      status        TEXT NOT NULL DEFAULT 'open',
+      task_file     TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status
+      ON tasks(assigned_to, status);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS orchestration_events (
+      id             TEXT PRIMARY KEY,
+      ts             TEXT NOT NULL,
+      event_type     TEXT NOT NULL,
+      source         TEXT NOT NULL,
+      severity       TEXT NOT NULL DEFAULT 'info',
+      task_id        TEXT,
+      agent_id       TEXT,
+      reviewer       TEXT,
+      session_scope  TEXT,
+      project_name   TEXT,
+      instance_id    TEXT,
+      tmux_session   TEXT,
+      runtime        TEXT,
+      correlation_id TEXT,
+      attempt        INTEGER,
+      duration_ms    INTEGER,
+      result         TEXT,
+      error_code     TEXT,
+      payload_json   TEXT,
+      created_at     TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_orch_events_ts
+      ON orchestration_events(ts);
+
+    CREATE INDEX IF NOT EXISTS idx_orch_events_task
+      ON orchestration_events(task_id, ts);
+
+    CREATE INDEX IF NOT EXISTS idx_orch_events_agent
+      ON orchestration_events(agent_id, session_scope, ts);
+
+    CREATE INDEX IF NOT EXISTS idx_orch_events_type
+      ON orchestration_events(event_type, ts);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS behaviors (
+      id           TEXT PRIMARY KEY,
+      agent_id     TEXT NOT NULL,
+      project_name TEXT,
+      domain       TEXT,
+      content      TEXT NOT NULL,
+      active       INTEGER NOT NULL DEFAULT 1,
+      created_at   TEXT NOT NULL,
+      updated_at   TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
+      ON behaviors(agent_id, active);
+  `);
+  try {
+    const coordinatorName = getCoordinatorName();
+    const existing = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
+      args: [coordinatorName]
+    });
+    if (Number(existing.rows[0]?.cnt) === 0) {
+      const seededAt = "2026-03-25T00:00:00Z";
+      for (const [domain, content] of [
+        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
+        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
+        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
+      ]) {
+        await client.execute({
+          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
+          args: [coordinatorName, domain, content, seededAt, seededAt]
+        });
+      }
+    }
+  } catch (seedErr) {
+    logCatchDebug("behavior seed", seedErr);
+  }
+  await executeAddColumn(client, `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`);
+  await executeAddColumn(client, `ALTER TABLE behaviors ADD COLUMN vector F32_BLOB(${EMBEDDING_DIM})`);
+  for (const col of ["created_by_agent TEXT", "created_by_device TEXT", "source_session_id TEXT"]) {
+    await executeAddColumn(client, `ALTER TABLE behaviors ADD COLUMN ${col}`);
+  }
+  try {
+    await client.execute(
+      `CREATE TRIGGER IF NOT EXISTS behaviors_reject_ghost_insert
+         BEFORE INSERT ON behaviors
+         WHEN new.id IS NULL
+           OR trim(new.id) = ''
+           OR trim(coalesce(new.content, '')) = ''
+           OR (new.content = '(empty)' AND coalesce(new.agent_id, '') = 'unknown')
+         BEGIN
+           SELECT RAISE(ABORT, 'ghost behavior rejected: null/blank id or empty content (bug 26688a14)');
+         END`
+    );
+  } catch (e) {
+    logCatchDebug("behaviors ghost-guard migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`);
+  try {
+    await client.execute({
+      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+              ON tasks(parent_task_id)
+              WHERE parent_task_id IS NOT NULL`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'closed' WHERE status IN ('completed', 'done') AND result IS NOT NULL`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'needs_review' WHERE status IN ('completed', 'done') AND result IS NULL`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN reviewer TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN context TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN result TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN session_scope TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN instance_id TEXT`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN task_id TEXT`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN author_device_id TEXT`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
+      ON consolidations(consolidated_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS reminders (
+      id            TEXT PRIMARY KEY,
+      text          TEXT NOT NULL,
+      created_at    TEXT NOT NULL,
+      due_date      TEXT,
+      completed_at  TEXT
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS notifications (
+      id          TEXT PRIMARY KEY,
+      agent_id    TEXT NOT NULL,
+      agent_role  TEXT NOT NULL,
+      event       TEXT NOT NULL,
+      project     TEXT NOT NULL,
+      summary     TEXT NOT NULL,
+      task_file   TEXT,
+      session_scope TEXT,
+      read        INTEGER NOT NULL DEFAULT 0,
+      created_at  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_read
+      ON notifications(read);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent
+      ON notifications(agent_id, session_scope);
+
+    CREATE INDEX IF NOT EXISTS idx_notifications_task_file
+      ON notifications(task_file);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS schedules (
+      id            TEXT PRIMARY KEY,
+      cron          TEXT NOT NULL,
+      description   TEXT NOT NULL,
+      job_type      TEXT NOT NULL DEFAULT 'report',
+      prompt        TEXT,
+      assigned_to   TEXT,
+      project_name  TEXT,
+      active        INTEGER NOT NULL DEFAULT 1,
+      use_crontab   INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS device_registry (
+      device_id     TEXT PRIMARY KEY,
+      friendly_name TEXT NOT NULL,
+      hostname      TEXT NOT NULL,
+      projects      TEXT NOT NULL DEFAULT '[]',
+      agents        TEXT NOT NULL DEFAULT '[]',
+      connected     INTEGER DEFAULT 0,
+      last_seen     TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id              TEXT PRIMARY KEY,
+      from_agent      TEXT NOT NULL,
+      from_device     TEXT NOT NULL DEFAULT 'local',
+      target_agent    TEXT NOT NULL,
+      target_project  TEXT,
+      target_device   TEXT NOT NULL DEFAULT 'local',
+      session_scope   TEXT,
+      content         TEXT NOT NULL,
+      priority        TEXT DEFAULT 'normal',
+      status          TEXT DEFAULT 'pending',
+      server_seq      INTEGER,
+      retry_count     INTEGER DEFAULT 0,
+      created_at      TEXT NOT NULL,
+      delivered_at    TEXT,
+      processed_at    TEXT,
+      failed_at       TEXT,
+      failure_reason  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target
+      ON messages(target_agent, session_scope, status);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation_order
+      ON messages(target_agent, session_scope, from_agent, server_seq);
+  `);
+  await executeAddColumn(client, `ALTER TABLE notifications ADD COLUMN session_scope TEXT`);
+  await executeAddColumn(client, `ALTER TABLE messages ADD COLUMN session_scope TEXT`);
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent_scope_read
+      ON notifications(agent_id, session_scope, read, created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target_scope_status
+      ON messages(target_agent, session_scope, status, created_at);
+  `);
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-create' WHERE project_name = 'web'`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE tasks SET project_name = 'exe-os' WHERE project_name = 'worker'`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS trajectories (
+      id              TEXT PRIMARY KEY,
+      task_id         TEXT NOT NULL,
+      agent_id        TEXT NOT NULL,
+      project_name    TEXT NOT NULL,
+      task_title      TEXT NOT NULL,
+      signature       TEXT NOT NULL,
+      signature_hash  TEXT NOT NULL,
+      tool_count      INTEGER NOT NULL,
+      skill_id        TEXT,
+      created_at      TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_hash
+      ON trajectories(signature_hash);
+
+    CREATE INDEX IF NOT EXISTS idx_trajectories_agent
+      ON trajectories(agent_id);
+  `);
+  await executeAddColumn(client, "ALTER TABLE trajectories ADD COLUMN skill_id TEXT");
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS audit_trail (
+      id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp           TEXT NOT NULL,
+      session_id          TEXT NOT NULL,
+      agent_id            TEXT NOT NULL,
+      tool                TEXT NOT NULL,
+      input               TEXT,
+      decision            TEXT NOT NULL,
+      reason              TEXT,
+      is_customer_facing  INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_agent
+      ON audit_trail(agent_id, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_audit_trail_session
+      ON audit_trail(session_id);
+  `);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN deleted_at TEXT`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN confidence REAL DEFAULT 0.7`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN last_accessed TEXT`);
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET last_accessed = timestamp WHERE last_accessed IS NULL`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN graph_extracted INTEGER DEFAULT 0`);
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN content_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN graph_extracted_hash TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_scoped_content_hash
+         ON memories(content_hash, agent_id, project_name, memory_type)
+         WHERE content_hash IS NOT NULL`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash
+         ON memories(content_hash, agent_id, project_name, memory_type)
+         WHERE content_hash IS NOT NULL
+           AND COALESCE(status, 'active') != 'deleted'`
+    );
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("UNIQUE constraint")) {
+      process.stderr.write("[migration] Cleaning up existing duplicate memories before creating unique index...\n");
+      try {
+        await client.execute(`
+          UPDATE memories SET status = 'deleted', outcome = 'dedup-migration'
+          WHERE id IN (
+            SELECT m.id FROM memories m
+            JOIN (
+              SELECT content_hash, agent_id, project_name, memory_type, MAX(timestamp) as max_ts
+              FROM memories
+              WHERE content_hash IS NOT NULL AND COALESCE(status, 'active') != 'deleted'
+              GROUP BY content_hash, agent_id, project_name, memory_type
+              HAVING COUNT(*) > 1
+            ) d ON m.content_hash = d.content_hash
+              AND m.agent_id = d.agent_id
+              AND m.project_name = d.project_name
+              AND COALESCE(m.memory_type, 'raw') = COALESCE(d.memory_type, 'raw')
+              AND m.timestamp < d.max_ts
+              AND COALESCE(m.status, 'active') != 'deleted'
+          )
+        `);
+        await client.execute(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_scoped_hash
+             ON memories(content_hash, agent_id, project_name, memory_type)
+             WHERE content_hash IS NOT NULL
+               AND COALESCE(status, 'active') != 'deleted'`
+        );
+        process.stderr.write("[migration] Duplicate cleanup + unique index created successfully\n");
+      } catch (retryErr) {
+        logCatchDebug("migration-dedup-retry", retryErr);
+      }
+    } else {
+      logCatchDebug("migration", e);
+    }
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      first_seen TEXT NOT NULL,
+      last_seen TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(name, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationships (
+      id TEXT PRIMARY KEY,
+      source_entity_id TEXT NOT NULL,
+      target_entity_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      weight REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL,
+      properties TEXT DEFAULT '{}',
+      UNIQUE(source_entity_id, target_entity_id, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS entity_memories (
+      entity_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (entity_id, memory_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS relationship_memories (
+      relationship_id TEXT NOT NULL,
+      memory_id TEXT NOT NULL,
+      PRIMARY KEY (relationship_id, memory_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+    CREATE INDEX IF NOT EXISTS idx_entities_name_nocase ON entities(name COLLATE NOCASE);
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_relationships_source ON relationships(source_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_relationships_target ON relationships(target_entity_id);
+    CREATE INDEX IF NOT EXISTS idx_entity_memories_memory ON entity_memories(memory_id);
+    CREATE INDEX IF NOT EXISTS idx_relationship_memories_memory ON relationship_memories(memory_id);
+
+    CREATE TABLE IF NOT EXISTS hyperedges (
+      id TEXT PRIMARY KEY,
+      label TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      confidence REAL DEFAULT 1.0,
+      timestamp TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS hyperedge_nodes (
+      hyperedge_id TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      PRIMARY KEY (hyperedge_id, entity_id)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+  `);
+  try {
+    await client.execute(
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_entities_type_name_nocase_unique ON entities(type, name COLLATE NOCASE)"
+    );
+  } catch (e) {
+    process.stderr.write(
+      `[database] WARN: could not create NOCASE entity uniqueness index; existing case-only duplicates may need dedupe: ${e instanceof Error ? e.message : String(e)}
+`
+    );
+  }
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS entity_aliases (
+      alias TEXT NOT NULL PRIMARY KEY,
+      canonical_entity_id TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_entity_aliases_canonical ON entity_aliases(canonical_entity_id);
+  `);
+  for (const col of [
+    "ALTER TABLE relationships ADD COLUMN confidence REAL DEFAULT 1.0",
+    "ALTER TABLE relationships ADD COLUMN confidence_label TEXT DEFAULT 'extracted'"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS ontology_schema (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL,
+      relationship_type TEXT NOT NULL,
+      target_type TEXT NOT NULL,
+      description TEXT,
+      bidirectional INTEGER DEFAULT 0,
+      UNIQUE(source_type, relationship_type, target_type)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_ontology_source ON ontology_schema(source_type);
+    CREATE INDEX IF NOT EXISTS idx_ontology_target ON ontology_schema(target_type);
+    CREATE INDEX IF NOT EXISTS idx_entities_type_name ON entities(type, name);
+  `);
+  try {
+    const triples = [
+      ["person", "worked_on", "project", 0],
+      ["person", "worked_on", "file", 0],
+      ["person", "uses", "tool", 0],
+      ["person", "decided", "decision", 0],
+      ["person", "created", "file", 0],
+      ["person", "fixed", "file", 0],
+      ["person", "reviewed", "file", 0],
+      ["person", "reports_to", "person", 0],
+      ["person", "manages", "person", 0],
+      ["person", "communicates_with", "person", 1],
+      ["person", "ordered_from", "supplier", 0],
+      ["file", "depends_on", "file", 0],
+      ["file", "part_of", "project", 0],
+      ["file", "implements", "concept", 0],
+      ["project", "depends_on", "project", 0],
+      ["project", "uses", "tool", 0],
+      ["decision", "rationale_for", "decision", 0],
+      ["decision", "superseded_by", "decision", 0],
+      ["decision", "related_to", "project", 0],
+      ["concept", "related_to", "concept", 1],
+      ["concept", "part_of", "project", 0],
+      ["rationale", "rationale_for", "decision", 0],
+      ["product", "part_of", "company", 0],
+      ["product", "categorized_as", "category", 0],
+      ["company", "located_at", "location", 0],
+      ["supplier", "supplies", "product", 0],
+      ["order", "ships_to", "location", 0],
+      ["tool", "part_of", "project", 0]
+    ];
+    for (const [src, rel, tgt, bidir] of triples) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO ontology_schema (source_type, relationship_type, target_type, bidirectional) VALUES (?, ?, ?, ?)`,
+        args: [src, rel, tgt, bidir]
+      });
+    }
+  } catch (e) {
+    logCatchDebug("ontology seed", e);
+  }
+  let relationshipsValidFromColumnAdded = false;
+  relationshipsValidFromColumnAdded = await executeAddColumn(client, "ALTER TABLE relationships ADD COLUMN valid_from TEXT");
+  await executeAddColumn(client, "ALTER TABLE relationships ADD COLUMN valid_until TEXT");
+  try {
+    if (relationshipsValidFromColumnAdded) {
+      await client.execute("UPDATE relationships SET valid_from = timestamp WHERE valid_from IS NULL AND timestamp IS NOT NULL");
+    }
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_relationships_valid_from ON relationships(valid_from)");
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_relationships_valid_until ON relationships(valid_until)");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, "ALTER TABLE entities ADD COLUMN parent_type TEXT");
+  try {
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_entities_parent_type ON entities(parent_type)");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_trust_level TEXT DEFAULT 'unknown'",
+    "ALTER TABLE memories ADD COLUMN quarantined INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN quarantine_reason TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  try {
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_quarantined ON memories(quarantined) WHERE quarantined = 1");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS sync_conflicts (
+      id TEXT PRIMARY KEY,
+      memory_id TEXT NOT NULL,
+      local_version INTEGER,
+      remote_version INTEGER,
+      local_timestamp TEXT,
+      remote_timestamp TEXT,
+      local_device_id TEXT,
+      resolution TEXT NOT NULL DEFAULT 'remote_wins',
+      created_at TEXT NOT NULL
+    );
+  `);
+  await executeAddColumn(client, "ALTER TABLE memories ADD COLUMN visibility TEXT DEFAULT 'project'", "migration add memories.visibility");
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN media_url TEXT",
+    "ALTER TABLE memories ADD COLUMN media_type TEXT",
+    "ALTER TABLE memories ADD COLUMN media_meta TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS agent_centroids (
+      agent_id TEXT NOT NULL,
+      project_name TEXT NOT NULL,
+      centroid_vector BLOB,
+      sample_count INTEGER DEFAULT 0,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (agent_id, project_name)
+    );
+  `);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS identity (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id    TEXT NOT NULL UNIQUE,
+      content_hash TEXT NOT NULL,
+      updated_at  TEXT NOT NULL,
+      updated_by  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_identity_agent ON identity(agent_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS chat_history (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id  TEXT NOT NULL,
+      role        TEXT NOT NULL,
+      content     TEXT NOT NULL,
+      tool_name   TEXT,
+      tool_id     TEXT,
+      is_error    INTEGER NOT NULL DEFAULT 0,
+      timestamp   INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chat_history_session
+      ON chat_history(session_id, id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id              TEXT PRIMARY KEY,
+      slug            TEXT NOT NULL UNIQUE,
+      name            TEXT NOT NULL,
+      owner_agent_id  TEXT,
+      created_at      TEXT NOT NULL,
+      metadata        TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workspaces_slug
+      ON workspaces(slug);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS documents (
+      id            TEXT PRIMARY KEY,
+      workspace_id  TEXT NOT NULL,
+      filename      TEXT NOT NULL,
+      mime          TEXT,
+      source_type   TEXT,
+      user_id       TEXT,
+      uploaded_at   TEXT NOT NULL,
+      metadata      TEXT,
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_documents_workspace
+      ON documents(workspace_id);
+
+    CREATE INDEX IF NOT EXISTS idx_documents_user
+      ON documents(user_id);
+  `);
+  for (const column of [
+    "workspace_id TEXT",
+    "document_id TEXT",
+    "user_id TEXT",
+    "char_offset INTEGER",
+    "page_number INTEGER"
+  ]) {
+    await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN ${column}`);
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_memories_workspace
+      ON memories(workspace_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_document
+      ON memories(document_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_user
+      ON memories(user_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_kills (
+      id                      TEXT PRIMARY KEY,
+      session_name            TEXT NOT NULL,
+      agent_id                TEXT NOT NULL,
+      killed_at               TIMESTAMP NOT NULL,
+      reason                  TEXT NOT NULL,
+      ticks_idle              INTEGER,
+      estimated_tokens_saved  INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_kills_killed_at
+      ON session_kills(killed_at);
+
+    CREATE INDEX IF NOT EXISTS idx_session_kills_agent
+      ON session_kills(agent_id);
+  `);
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS company_procedures (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'p0',
+      domain TEXT,
+      kind TEXT NOT NULL DEFAULT 'procedure',
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+  await executeAddColumn(client, "ALTER TABLE company_procedures ADD COLUMN kind TEXT NOT NULL DEFAULT 'procedure'");
+  const legacyProcedureObject = await client.execute({
+    sql: "SELECT type FROM sqlite_master WHERE name = 'global_procedures'",
+    args: []
+  });
+  const legacyProcedureType = legacyProcedureObject.rows[0]?.type == null ? null : String(legacyProcedureObject.rows[0].type);
+  if (legacyProcedureType === "table") {
+    await client.execute(`
+      INSERT OR IGNORE INTO company_procedures
+        (id, title, content, priority, domain, active, created_at, updated_at)
+      SELECT id, title, content, priority, domain, active, created_at, updated_at
+      FROM global_procedures
+    `);
+    await client.executeMultiple(`
+      CREATE TRIGGER IF NOT EXISTS global_procedures_mirror_insert
+        AFTER INSERT ON global_procedures
+      BEGIN
+        INSERT OR IGNORE INTO company_procedures
+          (id, title, content, priority, domain, active, created_at, updated_at)
+        VALUES
+          (NEW.id, NEW.title, NEW.content, NEW.priority, NEW.domain, NEW.active, NEW.created_at, NEW.updated_at);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS global_procedures_mirror_update
+        AFTER UPDATE ON global_procedures
+      BEGIN
+        UPDATE company_procedures
+        SET title = NEW.title,
+            content = NEW.content,
+            priority = NEW.priority,
+            domain = NEW.domain,
+            active = NEW.active,
+            created_at = NEW.created_at,
+            updated_at = NEW.updated_at
+        WHERE id = OLD.id;
+      END;
+    `);
+  } else {
+    await client.execute(`
+      CREATE VIEW IF NOT EXISTS global_procedures AS
+      SELECT id, title, content, priority, domain, active, created_at, updated_at
+      FROM company_procedures
+    `);
+    await client.executeMultiple(`
+      CREATE TRIGGER IF NOT EXISTS global_procedures_insert
+        INSTEAD OF INSERT ON global_procedures
+      BEGIN
+        INSERT INTO company_procedures
+          (id, title, content, priority, domain, active, created_at, updated_at)
+        VALUES
+          (NEW.id, NEW.title, NEW.content, NEW.priority, NEW.domain, NEW.active, NEW.created_at, NEW.updated_at);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS global_procedures_update
+        INSTEAD OF UPDATE ON global_procedures
+      BEGIN
+        UPDATE company_procedures
+        SET title = NEW.title,
+            content = NEW.content,
+            priority = NEW.priority,
+            domain = NEW.domain,
+            active = NEW.active,
+            created_at = NEW.created_at,
+            updated_at = NEW.updated_at
+        WHERE id = OLD.id;
+      END;
+    `);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id              TEXT PRIMARY KEY,
+      platform        TEXT NOT NULL,
+      external_id     TEXT,
+      sender_id       TEXT NOT NULL,
+      sender_name     TEXT,
+      sender_phone    TEXT,
+      sender_email    TEXT,
+      recipient_id    TEXT,
+      channel_id      TEXT NOT NULL,
+      thread_id       TEXT,
+      reply_to_id     TEXT,
+      content_text    TEXT,
+      content_media   TEXT,
+      content_metadata TEXT,
+      agent_response  TEXT,
+      agent_name      TEXT,
+      timestamp       TEXT NOT NULL,
+      ingested_at     TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_platform
+      ON conversations(platform);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_sender
+      ON conversations(sender_id);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_timestamp
+      ON conversations(timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_thread
+      ON conversations(thread_id);
+
+    CREATE INDEX IF NOT EXISTS idx_conversations_channel
+      ON conversations(channel_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL,
+      cache_cold_count INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS agent_file_reads (
+      session_uuid TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      read_at TEXT NOT NULL,
+      commit_hash TEXT,
+      PRIMARY KEY (session_uuid, file_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_file_reads_agent_read_at
+      ON agent_file_reads(agent_id, read_at);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch (e) {
+    logCatchDebug("session_agent_map backfill", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE session_agent_map ADD COLUMN cache_cold_count INTEGER NOT NULL DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN spawn_runtime TEXT`);
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN spawn_model TEXT`);
+  let tasksDeviceIdColumnAdded = false;
+  tasksDeviceIdColumnAdded = await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN device_id TEXT`);
+  try {
+    if (tasksDeviceIdColumnAdded) {
+      const { loadDeviceId } = await import("./lib/license.js");
+      const deviceId = loadDeviceId();
+      if (deviceId) {
+        await client.execute({
+          sql: "UPDATE tasks SET device_id = ? WHERE device_id IS NULL",
+          args: [deviceId]
+        });
+      }
+    }
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN claimed_by TEXT",
+    "ALTER TABLE tasks ADD COLUMN claimed_at TEXT",
+    "ALTER TABLE tasks ADD COLUMN last_heartbeat_at TEXT",
+    "ALTER TABLE tasks ADD COLUMN lease_expires_at TEXT",
+    "ALTER TABLE tasks ADD COLUMN claim_count INTEGER NOT NULL DEFAULT 0"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await executeAddColumn(client, "ALTER TABLE tasks ADD COLUMN assertions TEXT");
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_tasks_heartbeat_stale ON tasks(status, last_heartbeat_at) WHERE status = 'in_progress'",
+    "CREATE INDEX IF NOT EXISTS idx_tasks_lease_expiry ON tasks(status, lease_expires_at) WHERE status = 'in_progress'",
+    "CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by ON tasks(claimed_by) WHERE claimed_by IS NOT NULL"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch (e) {
+      logCatchDebug("migration", e);
+    }
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS core_memory (
+      agent_id    TEXT NOT NULL,
+      key         TEXT NOT NULL,
+      value       TEXT NOT NULL,
+      updated_at  TEXT NOT NULL,
+      PRIMARY KEY (agent_id, key)
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS oauth_tokens (
+      id            TEXT PRIMARY KEY,
+      provider      TEXT NOT NULL,
+      access_token  TEXT NOT NULL,
+      refresh_token TEXT,
+      token_type    TEXT NOT NULL DEFAULT 'Bearer',
+      scope         TEXT,
+      expires_at    TEXT,
+      user_id       TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_oauth_tokens_provider
+      ON oauth_tokens(provider, user_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS wiki_acl (
+      user_id       TEXT NOT NULL,
+      workspace     TEXT NOT NULL,
+      access_level  TEXT NOT NULL DEFAULT 'read',
+      granted_by    TEXT,
+      created_at    TEXT NOT NULL,
+      PRIMARY KEY (user_id, workspace)
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS workflow_definitions (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL,
+      description   TEXT,
+      steps         TEXT NOT NULL,
+      trigger_event TEXT,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS workflow_instances (
+      id              TEXT PRIMARY KEY,
+      definition_id   TEXT NOT NULL,
+      status          TEXT NOT NULL DEFAULT 'pending',
+      current_step    INTEGER NOT NULL DEFAULT 1,
+      step_results    TEXT NOT NULL DEFAULT '[]',
+      context         TEXT NOT NULL DEFAULT '{}',
+      approval_task_id TEXT,
+      created_at      TEXT NOT NULL,
+      updated_at      TEXT NOT NULL,
+      FOREIGN KEY (definition_id) REFERENCES workflow_definitions(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_instances_status
+      ON workflow_instances(status);
+  `);
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
+      content_text,
+      sender_name,
+      agent_response,
+      content='conversations',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ai AFTER INSERT ON conversations BEGIN
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_ad AFTER DELETE ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS conversations_fts_au AFTER UPDATE OF content_text, sender_name, agent_response ON conversations BEGIN
+      INSERT INTO conversations_fts(conversations_fts, rowid, content_text, sender_name, agent_response)
+      VALUES('delete', old.rowid, old.content_text, old.sender_name, old.agent_response);
+      INSERT INTO conversations_fts(rowid, content_text, sender_name, agent_response)
+      VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
+    END;
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memory_cards (
+      id            TEXT PRIMARY KEY,
+      memory_id     TEXT NOT NULL,
+      agent_id      TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      project_name  TEXT,
+      timestamp     TEXT NOT NULL,
+      card_type     TEXT NOT NULL,
+      subject       TEXT,
+      predicate     TEXT,
+      object        TEXT,
+      content       TEXT NOT NULL,
+      source_ref    TEXT,
+      confidence    REAL DEFAULT 0.6,
+      active        INTEGER DEFAULT 1,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_agent
+      ON memory_cards(agent_id, active, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_memory
+      ON memory_cards(memory_id);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_cards_fts
+      USING fts5(content, subject, predicate, object, content='memory_cards', content_rowid='rowid');
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ai AFTER INSERT ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ad AFTER DELETE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_au AFTER UPDATE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memory_reflections (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      project_name TEXT,
+      insight_type TEXT NOT NULL CHECK (insight_type IN ('pattern', 'contradiction', 'evolution', 'summary')),
+      subject TEXT NOT NULL,
+      content TEXT NOT NULL,
+      source_card_ids TEXT NOT NULL DEFAULT '[]',
+      confidence REAL NOT NULL DEFAULT 0.7,
+      active INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      expires_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_reflections_agent
+      ON memory_reflections(agent_id, insight_type, created_at DESC);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_reflections_fts USING fts5(
+      content, subject,
+      content=memory_reflections, content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memory_reflections_fts_ai AFTER INSERT ON memory_reflections BEGIN
+      INSERT INTO memory_reflections_fts(rowid, content, subject)
+      VALUES (new.rowid, new.content, new.subject);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_reflections_fts_ad AFTER DELETE ON memory_reflections BEGIN
+      INSERT INTO memory_reflections_fts(memory_reflections_fts, rowid, content, subject)
+      VALUES ('delete', old.rowid, old.content, old.subject);
+    END;
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      id              TEXT PRIMARY KEY,
+      agent_id        TEXT NOT NULL,
+      project_name    TEXT,
+      started_at      TEXT NOT NULL,
+      last_event_at   TEXT NOT NULL,
+      event_count     INTEGER NOT NULL DEFAULT 0,
+      properties      TEXT DEFAULT '{}'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_agent_time
+      ON agent_sessions(agent_id, started_at);
+
+    CREATE TABLE IF NOT EXISTS agent_goals (
+      id                TEXT PRIMARY KEY,
+      statement         TEXT NOT NULL,
+      owner_agent_id    TEXT,
+      project_name      TEXT,
+      status            TEXT NOT NULL DEFAULT 'open',
+      priority          INTEGER NOT NULL DEFAULT 5,
+      success_criteria  TEXT,
+      parent_goal_id    TEXT,
+      due_at            TEXT,
+      achieved_at       TEXT,
+      supersedes_id     TEXT,
+      created_at        TEXT NOT NULL,
+      updated_at        TEXT NOT NULL,
+      source_memory_id  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_goals_project_status
+      ON agent_goals(project_name, status, priority);
+
+    CREATE TABLE IF NOT EXISTS agent_events (
+      id                  TEXT PRIMARY KEY,
+      event_type          TEXT NOT NULL,
+      occurred_at         TEXT NOT NULL,
+      sequence_index      INTEGER NOT NULL,
+      actor_agent_id      TEXT,
+      agent_role          TEXT,
+      project_name        TEXT,
+      session_id          TEXT,
+      task_id             TEXT,
+      goal_id             TEXT,
+      parent_event_id     TEXT,
+      intention           TEXT,
+      outcome             TEXT,
+      evidence_memory_id  TEXT,
+      impact              TEXT,
+      payload             TEXT DEFAULT '{}',
+      created_at          TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_time
+      ON agent_events(occurred_at, sequence_index);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_session_seq
+      ON agent_events(session_id, sequence_index);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_goal_time
+      ON agent_events(goal_id, occurred_at);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_memory
+      ON agent_events(evidence_memory_id);
+
+    CREATE TABLE IF NOT EXISTS agent_goal_links (
+      id           TEXT PRIMARY KEY,
+      goal_id      TEXT NOT NULL,
+      link_type    TEXT NOT NULL,
+      target_id    TEXT NOT NULL,
+      target_type  TEXT NOT NULL,
+      created_at   TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_goal_links_goal
+      ON agent_goal_links(goal_id, target_type);
+
+    CREATE TABLE IF NOT EXISTS agent_semantic_labels (
+      id                TEXT PRIMARY KEY,
+      source_memory_id  TEXT NOT NULL,
+      event_id          TEXT,
+      labeler           TEXT NOT NULL,
+      schema_version    INTEGER NOT NULL DEFAULT 1,
+      confidence        REAL NOT NULL DEFAULT 0,
+      labels            TEXT NOT NULL,
+      created_at        TEXT NOT NULL,
+      updated_at        TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_semantic_labels_memory
+      ON agent_semantic_labels(source_memory_id, labeler);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_semantic_labels_event
+      ON agent_semantic_labels(event_id);
+
+    CREATE TABLE IF NOT EXISTS agent_reflection_checkpoints (
+      id                  TEXT PRIMARY KEY,
+      project_name        TEXT,
+      session_id          TEXT,
+      window_start_at     TEXT NOT NULL,
+      window_end_at       TEXT NOT NULL,
+      event_count         INTEGER NOT NULL DEFAULT 0,
+      goal_count          INTEGER NOT NULL DEFAULT 0,
+      success_count       INTEGER NOT NULL DEFAULT 0,
+      failure_count       INTEGER NOT NULL DEFAULT 0,
+      risk_count          INTEGER NOT NULL DEFAULT 0,
+      summary             TEXT NOT NULL,
+      learnings           TEXT NOT NULL DEFAULT '[]',
+      next_actions        TEXT NOT NULL DEFAULT '[]',
+      evidence_event_ids  TEXT NOT NULL DEFAULT '[]',
+      confidence          REAL NOT NULL DEFAULT 0,
+      created_at          TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_reflection_project_time
+      ON agent_reflection_checkpoints(project_name, window_end_at);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_reflection_session_time
+      ON agent_reflection_checkpoints(session_id, window_end_at);
+  `);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN valid_from TEXT",
+    "ALTER TABLE memories ADD COLUMN invalid_at TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET valid_from = timestamp WHERE valid_from IS NULL`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN trajectory TEXT`);
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN procedure_for TEXT`);
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'closed' WHERE status = 'done' AND result IS NOT NULL`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN visibility TEXT DEFAULT 'private'`);
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN strength REAL DEFAULT 1.0`);
+  await executeAddColumn(client, `ALTER TABLE behaviors ADD COLUMN device_id TEXT`);
+  for (const col of [
+    "use_count INTEGER DEFAULT 0",
+    "success_count INTEGER DEFAULT 0",
+    "last_used_at TEXT",
+    "last_refined_at TEXT"
+  ]) {
+    await executeAddColumn(client, `ALTER TABLE behaviors ADD COLUMN ${col}`);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN session_scope TEXT`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_agent_scope_project ON memories(agent_id, session_scope, project_name)`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute({
+      sql: `CREATE TABLE IF NOT EXISTS task_groups (
+        id                 TEXT PRIMARY KEY,
+        title              TEXT NOT NULL,
+        coordinator        TEXT NOT NULL,
+        session_scope      TEXT,
+        project_name       TEXT,
+        timeout_minutes    INTEGER NOT NULL DEFAULT 120,
+        on_partial_failure TEXT NOT NULL DEFAULT 'notify',
+        barrier_fired      INTEGER NOT NULL DEFAULT 0,
+        barrier_fired_at   TEXT,
+        aggregated_result  TEXT,
+        created_at         TEXT NOT NULL,
+        updated_at         TEXT NOT NULL
+      )`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await executeAddColumn(client, `ALTER TABLE tasks ADD COLUMN group_id TEXT`);
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_tasks_group_id ON tasks(group_id) WHERE group_id IS NOT NULL`
+    );
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN estimated_minutes INTEGER",
+    "ALTER TABLE tasks ADD COLUMN estimate_confidence REAL",
+    "ALTER TABLE tasks ADD COLUMN actual_minutes INTEGER",
+    "ALTER TABLE tasks ADD COLUMN started_at TEXT"
+  ]) {
+    await executeAddColumn(client, col);
+  }
+  await executeAddColumn(client, `ALTER TABLE memories ADD COLUMN keywords TEXT DEFAULT ''`);
+  try {
+    await client.execute("SELECT keywords FROM memories_fts LIMIT 0");
+  } catch {
+    process.stderr.write("[database] Upgrading FTS5 to dual-column (raw_text + keywords)...\n");
+    try {
+      await client.executeMultiple(`
+        DROP TRIGGER IF EXISTS memories_fts_ai;
+        DROP TRIGGER IF EXISTS memories_fts_ad;
+        DROP TRIGGER IF EXISTS memories_fts_au;
+        DROP TRIGGER IF EXISTS memories_fts_soft_delete;
+        DROP TABLE IF EXISTS memories_fts;
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          raw_text,
+          keywords,
+          content='memories',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories
+        WHEN old.status IS NULL OR old.status != 'deleted' BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE OF raw_text, keywords ON memories
+        WHEN new.status IS NULL OR new.status != 'deleted' BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+          INSERT INTO memories_fts(rowid, raw_text, keywords) VALUES (new.rowid, new.raw_text, COALESCE(new.keywords, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_fts_soft_delete AFTER UPDATE ON memories
+        WHEN new.status = 'deleted' AND (old.status IS NULL OR old.status != 'deleted') BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, raw_text, keywords) VALUES('delete', old.rowid, old.raw_text, COALESCE(old.keywords, ''));
+        END;
+      `);
+      await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+      process.stderr.write("[database] FTS5 dual-column upgrade complete.\n");
+    } catch (ftsUpgradeErr) {
+      process.stderr.write(
+        `[database] FTS5 upgrade failed: ${ftsUpgradeErr instanceof Error ? ftsUpgradeErr.message : String(ftsUpgradeErr)}
+`
+      );
+    }
+  }
+  const founderIdTables = ["memories", "tasks", "behaviors", "messages"];
+  for (const table of founderIdTables) {
+    await executeAddColumn(client, `ALTER TABLE ${table} ADD COLUMN founder_id TEXT DEFAULT NULL`);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS investigation_attempts (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      task_id TEXT,
+      agent_id TEXT NOT NULL,
+      project_name TEXT,
+      attempt_number INTEGER NOT NULL,
+      investigation_key TEXT,
+      hypothesis TEXT,
+      confidence REAL,
+      action_type TEXT,
+      action_summary TEXT,
+      verification_type TEXT,
+      result TEXT NOT NULL,
+      error_output TEXT,
+      failure_category TEXT,
+      lesson TEXT,
+      timestamp TEXT NOT NULL,
+      duration_ms INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_investigation_session ON investigation_attempts(session_id);
+    CREATE INDEX IF NOT EXISTS idx_investigation_agent ON investigation_attempts(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_investigation_key ON investigation_attempts(investigation_key);
+    CREATE INDEX IF NOT EXISTS idx_investigation_result ON investigation_attempts(result);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS behavior_attributions (
+      id TEXT PRIMARY KEY,
+      behavior_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      investigation_key TEXT,
+      attributed_at TEXT NOT NULL,
+      FOREIGN KEY (behavior_id) REFERENCES behaviors(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_attr_behavior ON behavior_attributions(behavior_id);
+  `);
+  try {
+    await client.execute({
+      sql: `CREATE TABLE IF NOT EXISTS co_activations (
+        entity_a_id TEXT NOT NULL,
+        entity_b_id TEXT NOT NULL,
+        count INTEGER DEFAULT 1,
+        last_activated_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY (entity_a_id, entity_b_id)
+      )`,
+      args: []
+    });
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS prospective_memories (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      content       TEXT NOT NULL,
+      due_date      TEXT,
+      recurrence    TEXT NOT NULL DEFAULT 'once'
+                      CHECK (recurrence IN ('daily', 'weekly', 'monthly', 'once')),
+      priority      INTEGER NOT NULL DEFAULT 5,
+      status        TEXT NOT NULL DEFAULT 'pending'
+                      CHECK (status IN ('pending', 'completed', 'deferred')),
+      last_surfaced TEXT,
+      project_name  TEXT,
+      session_scope TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_prospective_agent
+      ON prospective_memories(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_prospective_status
+      ON prospective_memories(status);
+
+    CREATE INDEX IF NOT EXISTS idx_prospective_due
+      ON prospective_memories(due_date);
+
+    CREATE INDEX IF NOT EXISTS idx_prospective_agent_status
+      ON prospective_memories(agent_id, status);
+  `);
+}
+var disposeTurso = disposeDatabase;
+async function disposeDatabase() {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
+  if (_client) {
+    try {
+      await _client.execute("PRAGMA wal_checkpoint(PASSIVE)");
+    } catch (e) {
+      logCatchDebug("WAL checkpoint", e);
+    }
+  }
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+  releaseDbLock();
+}
+
+export {
+  WAL_ESCALATION_THRESHOLD_BYTES,
+  checkpointWalIfLarge,
+  initTurso,
+  initDatabase,
+  isInitialized,
+  setExternalClient,
+  SOFT_DELETE_RETENTION_DAYS,
+  getClient,
+  initDaemonClient,
+  getRawClient,
+  ensureSchema,
+  disposeTurso,
+  disposeDatabase,
+  identityPath,
+  getIdentity,
+  updateIdentity,
+  listIdentities,
+  getIdentityInjection,
+  EMPLOYEES_PATH,
+  DEFAULT_BOOT_TIMEOUT_MS,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  COORDINATOR_ROLE,
+  normalizeRole,
+  isCoordinatorRole,
+  getCoordinatorEmployee,
+  getCoordinatorName,
+  getCoordinatorDisplayTitle,
+  isCoordinatorName,
+  canCoordinate,
+  canManage,
+  VALID_AGENT_NAME,
+  VALID_AGENT_NAME_DESCRIPTION,
+  validateEmployeeName,
+  loadEmployees,
+  saveEmployees,
+  loadEmployeesSync,
+  getEmployee,
+  getEmployeeByRole,
+  getEmployeeNamesByRole,
+  hasRole,
+  baseAgentName,
+  isMultiInstance,
+  shouldAutoInstance,
+  addEmployee,
+  hireEmployee,
+  normalizeRosterCase,
+  registerBinSymlinks
+};