engrm 0.4.0 → 0.4.3

package/dist/hooks/session-start.js

@@ -3,2158 +3,2486 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, hostname, networkInterfaces } from "node:os";
-import { join } from "node:path";
-import { createHash } from "node:crypto";
-var CONFIG_DIR = join(homedir(), ".engrm");
-var SETTINGS_PATH = join(CONFIG_DIR, "settings.json");
-var DB_PATH = join(CONFIG_DIR, "engrm.db");
-function getDbPath() {
-  return DB_PATH;
-}
-function generateDeviceId() {
-  const host = hostname().toLowerCase().replace(/[^a-z0-9-]/g, "");
-  let mac = "";
-  const ifaces = networkInterfaces();
-  for (const entries of Object.values(ifaces)) {
-    if (!entries)
-      continue;
-    for (const entry of entries) {
-      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
-        mac = entry.mac;
-        break;
-      }
-    }
-    if (mac)
-      break;
+// hooks/session-start.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/storage/projects.ts
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+function normaliseGitRemoteUrl(remoteUrl) {
+  let url = remoteUrl.trim();
+  url = url.replace(/^(?:https?|ssh|git):\/\//, "");
+  url = url.replace(/^[^@]+@/, "");
+  url = url.replace(/^([^/:]+):(?!\d)/, "$1/");
+  url = url.replace(/\.git$/, "");
+  url = url.replace(/\/+$/, "");
+  const slashIndex = url.indexOf("/");
+  if (slashIndex !== -1) {
+    const host = url.substring(0, slashIndex).toLowerCase();
+    const path = url.substring(slashIndex);
+    url = host + path;
+  } else {
+    url = url.toLowerCase();
   }
-  const material = `${host}:${mac || "no-mac"}`;
-  const suffix = createHash("sha256").update(material).digest("hex").slice(0, 8);
-  return `${host}-${suffix}`;
+  return url;
 }
-function createDefaultConfig() {
-  return {
-    candengo_url: "",
-    candengo_api_key: "",
-    site_id: "",
-    namespace: "",
-    user_id: "",
-    user_email: "",
-    device_id: generateDeviceId(),
-    teams: [],
-    sync: {
-      enabled: true,
-      interval_seconds: 30,
-      batch_size: 50
-    },
-    search: {
-      default_limit: 10,
-      local_boost: 1.2,
-      scope: "all"
-    },
-    scrubbing: {
-      enabled: true,
-      custom_patterns: [],
-      default_sensitivity: "shared"
-    },
-    sentinel: {
-      enabled: false,
-      mode: "advisory",
-      provider: "openai",
-      model: "gpt-4o-mini",
-      api_key: "",
-      base_url: "",
-      skip_patterns: [],
-      daily_limit: 100,
-      tier: "free"
-    },
-    observer: {
-      enabled: true,
-      mode: "per_event",
-      model: "sonnet"
-    },
-    transcript_analysis: {
-      enabled: false
-    }
-  };
+function projectNameFromCanonicalId(canonicalId) {
+  const parts = canonicalId.split("/");
+  return parts[parts.length - 1] ?? canonicalId;
 }
-function loadConfig() {
-  if (!existsSync(SETTINGS_PATH)) {
-    throw new Error(`Config not found at ${SETTINGS_PATH}. Run 'engrm init --manual' to configure.`);
+function getGitRemoteUrl(directory) {
+  try {
+    const url = execSync("git remote get-url origin", {
+      cwd: directory,
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return url || null;
+  } catch {
+    try {
+      const remotes = execSync("git remote", {
+        cwd: directory,
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split(`
+`).filter(Boolean);
+      if (remotes.length === 0)
+        return null;
+      const url = execSync(`git remote get-url ${remotes[0]}`, {
+        cwd: directory,
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return url || null;
+    } catch {
+      return null;
+    }
   }
-  const raw = readFileSync(SETTINGS_PATH, "utf-8");
-  let parsed;
+}
+function readProjectConfigFile(directory) {
+  const configPath = join(directory, ".engrm.json");
+  if (!existsSync(configPath))
+    return null;
   try {
-    parsed = JSON.parse(raw);
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed["project_id"] !== "string" || !parsed["project_id"]) {
+      return null;
+    }
+    return {
+      project_id: parsed["project_id"],
+      name: typeof parsed["name"] === "string" ? parsed["name"] : undefined
+    };
   } catch {
-    throw new Error(`Invalid JSON in ${SETTINGS_PATH}`);
+    return null;
   }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Config at ${SETTINGS_PATH} is not a JSON object`);
+}
+function detectProject(directory) {
+  const remoteUrl = getGitRemoteUrl(directory);
+  if (remoteUrl) {
+    const canonicalId = normaliseGitRemoteUrl(remoteUrl);
+    return {
+      canonical_id: canonicalId,
+      name: projectNameFromCanonicalId(canonicalId),
+      remote_url: remoteUrl,
+      local_path: directory
+    };
   }
-  const config = parsed;
-  const defaults = createDefaultConfig();
+  const configFile = readProjectConfigFile(directory);
+  if (configFile) {
+    return {
+      canonical_id: configFile.project_id,
+      name: configFile.name ?? projectNameFromCanonicalId(configFile.project_id),
+      remote_url: null,
+      local_path: directory
+    };
+  }
+  const dirName = basename(directory);
   return {
-    candengo_url: asString(config["candengo_url"], defaults.candengo_url),
-    candengo_api_key: asString(config["candengo_api_key"], defaults.candengo_api_key),
-    site_id: asString(config["site_id"], defaults.site_id),
-    namespace: asString(config["namespace"], defaults.namespace),
-    user_id: asString(config["user_id"], defaults.user_id),
-    user_email: asString(config["user_email"], defaults.user_email),
-    device_id: asString(config["device_id"], defaults.device_id),
-    teams: asTeams(config["teams"], defaults.teams),
-    sync: {
-      enabled: asBool(config["sync"]?.["enabled"], defaults.sync.enabled),
-      interval_seconds: asNumber(config["sync"]?.["interval_seconds"], defaults.sync.interval_seconds),
-      batch_size: asNumber(config["sync"]?.["batch_size"], defaults.sync.batch_size)
-    },
-    search: {
-      default_limit: asNumber(config["search"]?.["default_limit"], defaults.search.default_limit),
-      local_boost: asNumber(config["search"]?.["local_boost"], defaults.search.local_boost),
-      scope: asScope(config["search"]?.["scope"], defaults.search.scope)
-    },
-    scrubbing: {
-      enabled: asBool(config["scrubbing"]?.["enabled"], defaults.scrubbing.enabled),
-      custom_patterns: asStringArray(config["scrubbing"]?.["custom_patterns"], defaults.scrubbing.custom_patterns),
-      default_sensitivity: asSensitivity(config["scrubbing"]?.["default_sensitivity"], defaults.scrubbing.default_sensitivity)
-    },
-    sentinel: {
-      enabled: asBool(config["sentinel"]?.["enabled"], defaults.sentinel.enabled),
-      mode: asSentinelMode(config["sentinel"]?.["mode"], defaults.sentinel.mode),
-      provider: asLlmProvider(config["sentinel"]?.["provider"], defaults.sentinel.provider),
-      model: asString(config["sentinel"]?.["model"], defaults.sentinel.model),
-      api_key: asString(config["sentinel"]?.["api_key"], defaults.sentinel.api_key),
-      base_url: asString(config["sentinel"]?.["base_url"], defaults.sentinel.base_url),
-      skip_patterns: asStringArray(config["sentinel"]?.["skip_patterns"], defaults.sentinel.skip_patterns),
-      daily_limit: asNumber(config["sentinel"]?.["daily_limit"], defaults.sentinel.daily_limit),
-      tier: asTier(config["sentinel"]?.["tier"], defaults.sentinel.tier)
-    },
-    observer: {
-      enabled: asBool(config["observer"]?.["enabled"], defaults.observer.enabled),
-      mode: asObserverMode(config["observer"]?.["mode"], defaults.observer.mode),
-      model: asString(config["observer"]?.["model"], defaults.observer.model)
-    },
-    transcript_analysis: {
-      enabled: asBool(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
-    }
+    canonical_id: `local/${dirName}`,
+    name: dirName,
+    remote_url: null,
+    local_path: directory
   };
 }
-function configExists() {
-  return existsSync(SETTINGS_PATH);
+
+// src/capture/dedup.ts
+function tokenise(text) {
+  const cleaned = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim();
+  const tokens = cleaned.split(/\s+/).filter((t) => t.length > 0);
+  return new Set(tokens);
+}
+function jaccardSimilarity(a, b) {
+  const tokensA = tokenise(a);
+  const tokensB = tokenise(b);
+  if (tokensA.size === 0 && tokensB.size === 0)
+    return 1;
+  if (tokensA.size === 0 || tokensB.size === 0)
+    return 0;
+  let intersectionSize = 0;
+  for (const token of tokensA) {
+    if (tokensB.has(token))
+      intersectionSize++;
+  }
+  const unionSize = tokensA.size + tokensB.size - intersectionSize;
+  if (unionSize === 0)
+    return 0;
+  return intersectionSize / unionSize;
+}
+var DEDUP_THRESHOLD = 0.8;
+function findDuplicate(newTitle, candidates) {
+  let bestMatch = null;
+  let bestScore = 0;
+  for (const candidate of candidates) {
+    const similarity = jaccardSimilarity(newTitle, candidate.title);
+    if (similarity > DEDUP_THRESHOLD && similarity > bestScore) {
+      bestScore = similarity;
+      bestMatch = candidate;
+    }
+  }
+  return bestMatch;
 }
-function asString(value, fallback) {
-  return typeof value === "string" ? value : fallback;
+
+// src/intelligence/followthrough.ts
+var FOLLOW_THROUGH_THRESHOLD = 0.25;
+var STALE_AFTER_DAYS = 3;
+var DECISION_WINDOW_DAYS = 30;
+var IMPLEMENTATION_TYPES = new Set([
+  "feature",
+  "bugfix",
+  "change",
+  "refactor"
+]);
+function findStaleDecisions(db, projectId, options) {
+  const staleAfterDays = options?.staleAfterDays ?? STALE_AFTER_DAYS;
+  const windowDays = options?.windowDays ?? DECISION_WINDOW_DAYS;
+  const nowEpoch = Math.floor(Date.now() / 1000);
+  const windowStart = nowEpoch - windowDays * 86400;
+  const staleThreshold = nowEpoch - staleAfterDays * 86400;
+  const decisions = db.db.query(`SELECT * FROM observations
+       WHERE project_id = ? AND type = 'decision'
+       AND lifecycle IN ('active', 'aging', 'pinned')
+       AND superseded_by IS NULL
+       AND created_at_epoch >= ?
+       ORDER BY created_at_epoch DESC`).all(projectId, windowStart);
+  if (decisions.length === 0)
+    return [];
+  const implementations = db.db.query(`SELECT * FROM observations
+       WHERE project_id = ? AND type IN ('feature', 'bugfix', 'change', 'refactor')
+       AND lifecycle IN ('active', 'aging', 'pinned')
+       AND superseded_by IS NULL
+       AND created_at_epoch >= ?
+       ORDER BY created_at_epoch DESC`).all(projectId, windowStart);
+  const crossProjectImpls = db.db.query(`SELECT * FROM observations
+       WHERE project_id != ? AND type IN ('feature', 'bugfix', 'change', 'refactor')
+       AND lifecycle IN ('active', 'aging', 'pinned')
+       AND superseded_by IS NULL
+       AND created_at_epoch >= ?
+       ORDER BY created_at_epoch DESC
+       LIMIT 200`).all(projectId, windowStart);
+  const allImpls = [...implementations, ...crossProjectImpls];
+  const stale = [];
+  for (const decision of decisions) {
+    if (decision.created_at_epoch > staleThreshold)
+      continue;
+    const daysAgo = Math.floor((nowEpoch - decision.created_at_epoch) / 86400);
+    let decisionConcepts = [];
+    try {
+      const parsed = decision.concepts ? JSON.parse(decision.concepts) : [];
+      if (Array.isArray(parsed))
+        decisionConcepts = parsed;
+    } catch {}
+    let bestTitle = "";
+    let bestScore = 0;
+    for (const impl of allImpls) {
+      if (impl.created_at_epoch <= decision.created_at_epoch)
+        continue;
+      const titleScore = jaccardSimilarity(decision.title, impl.title);
+      let conceptBoost = 0;
+      if (decisionConcepts.length > 0) {
+        try {
+          const implConcepts = impl.concepts ? JSON.parse(impl.concepts) : [];
+          if (Array.isArray(implConcepts) && implConcepts.length > 0) {
+            const decSet = new Set(decisionConcepts.map((c) => c.toLowerCase()));
+            const overlap = implConcepts.filter((c) => decSet.has(c.toLowerCase())).length;
+            conceptBoost = overlap / Math.max(decisionConcepts.length, 1) * 0.15;
+          }
+        } catch {}
+      }
+      let narrativeBoost = 0;
+      if (impl.narrative) {
+        const decWords = new Set(decision.title.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3));
+        if (decWords.size > 0) {
+          const implNarrativeLower = impl.narrative.toLowerCase();
+          const hits = [...decWords].filter((w) => implNarrativeLower.includes(w)).length;
+          narrativeBoost = hits / decWords.size * 0.1;
+        }
+      }
+      const totalScore = titleScore + conceptBoost + narrativeBoost;
+      if (totalScore > bestScore) {
+        bestScore = totalScore;
+        bestTitle = impl.title;
+      }
+    }
+    if (bestScore < FOLLOW_THROUGH_THRESHOLD) {
+      stale.push({
+        id: decision.id,
+        title: decision.title,
+        narrative: decision.narrative,
+        concepts: decisionConcepts,
+        created_at: decision.created_at,
+        days_ago: daysAgo,
+        ...bestScore > 0.1 ? {
+          best_match_title: bestTitle,
+          best_match_similarity: Math.round(bestScore * 100) / 100
+        } : {}
+      });
+    }
+  }
+  stale.sort((a, b) => b.days_ago - a.days_ago);
+  return stale.slice(0, 5);
 }
-function asNumber(value, fallback) {
-  return typeof value === "number" && !Number.isNaN(value) ? value : fallback;
+function findStaleDecisionsGlobal(db, options) {
+  const staleAfterDays = options?.staleAfterDays ?? STALE_AFTER_DAYS;
+  const windowDays = options?.windowDays ?? DECISION_WINDOW_DAYS;
+  const nowEpoch = Math.floor(Date.now() / 1000);
+  const windowStart = nowEpoch - windowDays * 86400;
+  const staleThreshold = nowEpoch - staleAfterDays * 86400;
+  const decisions = db.db.query(`SELECT * FROM observations
+       WHERE type = 'decision'
+       AND lifecycle IN ('active', 'aging', 'pinned')
+       AND superseded_by IS NULL
+       AND created_at_epoch >= ?
+       ORDER BY created_at_epoch DESC`).all(windowStart);
+  if (decisions.length === 0)
+    return [];
+  const implementations = db.db.query(`SELECT * FROM observations
+       WHERE type IN ('feature', 'bugfix', 'change', 'refactor')
+       AND lifecycle IN ('active', 'aging', 'pinned')
+       AND superseded_by IS NULL
+       AND created_at_epoch >= ?
+       ORDER BY created_at_epoch DESC
+       LIMIT 500`).all(windowStart);
+  const stale = [];
+  for (const decision of decisions) {
+    if (decision.created_at_epoch > staleThreshold)
+      continue;
+    const daysAgo = Math.floor((nowEpoch - decision.created_at_epoch) / 86400);
+    let decisionConcepts = [];
+    try {
+      const parsed = decision.concepts ? JSON.parse(decision.concepts) : [];
+      if (Array.isArray(parsed))
+        decisionConcepts = parsed;
+    } catch {}
+    let bestScore = 0;
+    let bestTitle = "";
+    for (const impl of implementations) {
+      if (impl.created_at_epoch <= decision.created_at_epoch)
+        continue;
+      const titleScore = jaccardSimilarity(decision.title, impl.title);
+      let conceptBoost = 0;
+      if (decisionConcepts.length > 0) {
+        try {
+          const implConcepts = impl.concepts ? JSON.parse(impl.concepts) : [];
+          if (Array.isArray(implConcepts) && implConcepts.length > 0) {
+            const decSet = new Set(decisionConcepts.map((c) => c.toLowerCase()));
+            const overlap = implConcepts.filter((c) => decSet.has(c.toLowerCase())).length;
+            conceptBoost = overlap / Math.max(decisionConcepts.length, 1) * 0.15;
+          }
+        } catch {}
+      }
+      const totalScore = titleScore + conceptBoost;
+      if (totalScore > bestScore) {
+        bestScore = totalScore;
+        bestTitle = impl.title;
+      }
+    }
+    if (bestScore < FOLLOW_THROUGH_THRESHOLD) {
+      stale.push({
+        id: decision.id,
+        title: decision.title,
+        narrative: decision.narrative,
+        concepts: decisionConcepts,
+        created_at: decision.created_at,
+        days_ago: daysAgo,
+        ...bestScore > 0.1 ? {
+          best_match_title: bestTitle,
+          best_match_similarity: Math.round(bestScore * 100) / 100
+        } : {}
+      });
+    }
+  }
+  stale.sort((a, b) => b.days_ago - a.days_ago);
+  return stale.slice(0, 5);
 }
-function asBool(value, fallback) {
-  return typeof value === "boolean" ? value : fallback;
+
+// src/context/inject.ts
+var RECENCY_WINDOW_SECONDS = 30 * 86400;
+function computeBlendedScore(quality, createdAtEpoch, nowEpoch) {
+  const age = nowEpoch - createdAtEpoch;
+  const recencyNorm = Math.max(0, Math.min(1, 1 - age / RECENCY_WINDOW_SECONDS));
+  return quality * 0.6 + recencyNorm * 0.4;
 }
-function asStringArray(value, fallback) {
-  return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : fallback;
+function estimateTokens(text) {
+  if (!text)
+    return 0;
+  return Math.ceil(text.length / 4);
 }
-function asScope(value, fallback) {
-  if (value === "personal" || value === "team" || value === "all")
-    return value;
-  return fallback;
+function buildSessionContext(db, cwd, options = {}) {
+  const opts = typeof options === "number" ? { maxCount: options } : options;
+  const tokenBudget = opts.tokenBudget ?? 3000;
+  const maxCount = opts.maxCount;
+  const visibilityClause = opts.userId ? " AND (sensitivity != 'personal' OR user_id = ?)" : "";
+  const visibilityParams = opts.userId ? [opts.userId] : [];
+  const detected = detectProject(cwd);
+  const project = db.getProjectByCanonicalId(detected.canonical_id);
+  const projectId = project?.id ?? -1;
+  const isNewProject = !project;
+  const totalActive = isNewProject ? (db.db.query(`SELECT COUNT(*) as c FROM observations
+             WHERE lifecycle IN ('active', 'aging', 'pinned')
+             ${visibilityClause}
+             AND superseded_by IS NULL`).get(...visibilityParams) ?? { c: 0 }).c : (db.db.query(`SELECT COUNT(*) as c FROM observations
+             WHERE project_id = ? AND lifecycle IN ('active', 'aging', 'pinned')
+             ${visibilityClause}
+             AND superseded_by IS NULL`).get(projectId, ...visibilityParams) ?? { c: 0 }).c;
+  const candidateLimit = maxCount ?? 50;
+  let pinned = [];
+  let recent = [];
+  let candidates = [];
+  if (!isNewProject) {
+    const MAX_PINNED = 5;
+    pinned = db.db.query(`SELECT * FROM observations
+         WHERE project_id = ? AND lifecycle = 'pinned'
+         AND superseded_by IS NULL
+         ${visibilityClause}
+         ORDER BY quality DESC, created_at_epoch DESC
+         LIMIT ?`).all(projectId, ...visibilityParams, MAX_PINNED);
+    const MAX_RECENT = 5;
+    recent = db.db.query(`SELECT * FROM observations
+         WHERE project_id = ? AND lifecycle IN ('active', 'aging')
+         AND superseded_by IS NULL
+         ${visibilityClause}
+         ORDER BY created_at_epoch DESC
+         LIMIT ?`).all(projectId, ...visibilityParams, MAX_RECENT);
+    candidates = db.db.query(`SELECT * FROM observations
+         WHERE project_id = ? AND lifecycle IN ('active', 'aging')
+         AND quality >= 0.3
+         AND superseded_by IS NULL
+         ${visibilityClause}
+         ORDER BY quality DESC, created_at_epoch DESC
+         LIMIT ?`).all(projectId, ...visibilityParams, candidateLimit);
+  }
+  let crossProjectCandidates = [];
+  if (opts.scope === "all" || isNewProject) {
+    const crossLimit = isNewProject ? Math.max(30, candidateLimit) : Math.max(10, Math.floor(candidateLimit / 3));
+    const qualityThreshold = isNewProject ? 0.3 : 0.5;
+    const rawCross = isNewProject ? db.db.query(`SELECT * FROM observations
+             WHERE lifecycle IN ('active', 'aging', 'pinned')
+             AND quality >= ?
+             AND superseded_by IS NULL
+             ${visibilityClause}
+             ORDER BY quality DESC, created_at_epoch DESC
+             LIMIT ?`).all(qualityThreshold, ...visibilityParams, crossLimit) : db.db.query(`SELECT * FROM observations
+             WHERE project_id != ? AND lifecycle IN ('active', 'aging')
+             AND quality >= ?
+             AND superseded_by IS NULL
+             ${visibilityClause}
+             ORDER BY quality DESC, created_at_epoch DESC
+             LIMIT ?`).all(projectId, qualityThreshold, ...visibilityParams, crossLimit);
+    const projectNameCache = new Map;
+    crossProjectCandidates = rawCross.map((obs) => {
+      if (!projectNameCache.has(obs.project_id)) {
+        const proj = db.getProjectById(obs.project_id);
+        if (proj)
+          projectNameCache.set(obs.project_id, proj.name);
+      }
+      return { ...obs, _source_project: projectNameCache.get(obs.project_id) };
+    });
+  }
+  const seenIds = new Set(pinned.map((o) => o.id));
+  const dedupedRecent = recent.filter((o) => {
+    if (seenIds.has(o.id))
+      return false;
+    seenIds.add(o.id);
+    return true;
+  });
+  const deduped = candidates.filter((o) => !seenIds.has(o.id));
+  for (const obs of crossProjectCandidates) {
+    if (!seenIds.has(obs.id)) {
+      seenIds.add(obs.id);
+      deduped.push(obs);
+    }
+  }
+  const nowEpoch = Math.floor(Date.now() / 1000);
+  const sorted = [...deduped].sort((a, b) => {
+    const boostA = a.type === "digest" ? 0.15 : 0;
+    const boostB = b.type === "digest" ? 0.15 : 0;
+    const scoreA = computeBlendedScore(a.quality, a.created_at_epoch, nowEpoch) + boostA;
+    const scoreB = computeBlendedScore(b.quality, b.created_at_epoch, nowEpoch) + boostB;
+    return scoreB - scoreA;
+  });
+  const projectName = project?.name ?? detected.name;
+  const canonicalId = project?.canonical_id ?? detected.canonical_id;
+  if (maxCount !== undefined) {
+    const remaining = Math.max(0, maxCount - pinned.length - dedupedRecent.length);
+    const all = [...pinned, ...dedupedRecent, ...sorted.slice(0, remaining)];
+    return {
+      project_name: projectName,
+      canonical_id: canonicalId,
+      observations: all.map(toContextObservation),
+      session_count: all.length,
+      total_active: totalActive
+    };
+  }
+  let remainingBudget = tokenBudget - 30;
+  const selected = [];
+  for (const obs of pinned) {
+    const cost = estimateObservationTokens(obs, selected.length);
+    remainingBudget -= cost;
+    selected.push(obs);
+  }
+  for (const obs of dedupedRecent) {
+    const cost = estimateObservationTokens(obs, selected.length);
+    remainingBudget -= cost;
+    selected.push(obs);
+  }
+  for (const obs of sorted) {
+    const cost = estimateObservationTokens(obs, selected.length);
+    if (remainingBudget - cost < 0 && selected.length > 0)
+      break;
+    remainingBudget -= cost;
+    selected.push(obs);
+  }
+  const summaries = isNewProject ? [] : db.getRecentSummaries(projectId, 5);
+  let securityFindings = [];
+  if (!isNewProject) {
+    try {
+      const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86400;
+      securityFindings = db.db.query(`SELECT * FROM security_findings
+           WHERE project_id = ? AND created_at_epoch > ?
+           ORDER BY severity DESC, created_at_epoch DESC
+           LIMIT ?`).all(projectId, weekAgo, 10);
+    } catch {}
+  }
+  let recentProjects;
+  if (isNewProject) {
+    try {
+      const nowEpochSec = Math.floor(Date.now() / 1000);
+      const projectRows = db.db.query(`SELECT p.name, p.canonical_id, p.last_active_epoch,
+                  (SELECT COUNT(*) FROM observations o
+                   WHERE o.project_id = p.id
+                   AND o.lifecycle IN ('active', 'aging', 'pinned')
+                   ${opts.userId ? "AND (o.sensitivity != 'personal' OR o.user_id = ?)" : ""}
+                   AND o.superseded_by IS NULL) as obs_count
+           FROM projects p
+           ORDER BY p.last_active_epoch DESC
+           LIMIT 10`).all(...visibilityParams);
+      if (projectRows.length > 0) {
+        recentProjects = projectRows.map((r) => {
+          const daysAgo = Math.max(0, Math.floor((nowEpochSec - r.last_active_epoch) / 86400));
+          const lastActive = new Date(r.last_active_epoch * 1000).toISOString().split("T")[0];
+          return {
+            name: r.name,
+            canonical_id: r.canonical_id,
+            observation_count: r.obs_count,
+            last_active: lastActive,
+            days_ago: daysAgo
+          };
+        });
+      }
+    } catch {}
+  }
+  let staleDecisions;
+  try {
+    const stale = isNewProject ? findStaleDecisionsGlobal(db) : findStaleDecisions(db, projectId);
+    if (stale.length > 0)
+      staleDecisions = stale;
+  } catch {}
+  return {
+    project_name: projectName,
+    canonical_id: canonicalId,
+    observations: selected.map(toContextObservation),
+    session_count: selected.length,
+    total_active: totalActive,
+    summaries: summaries.length > 0 ? summaries : undefined,
+    securityFindings: securityFindings.length > 0 ? securityFindings : undefined,
+    recentProjects,
+    staleDecisions
+  };
 }
-function asSensitivity(value, fallback) {
-  if (value === "shared" || value === "personal" || value === "secret")
-    return value;
-  return fallback;
+function estimateObservationTokens(obs, index) {
+  const DETAILED_THRESHOLD = 5;
+  const titleCost = estimateTokens(`- **[${obs.type}]** ${obs.title} (2026-01-01, q=0.5)`);
+  if (index >= DETAILED_THRESHOLD) {
+    return titleCost;
+  }
+  const detailText = formatObservationDetail(obs);
+  return titleCost + estimateTokens(detailText);
 }
-function asSentinelMode(value, fallback) {
-  if (value === "advisory" || value === "blocking")
-    return value;
-  return fallback;
+function formatContextForInjection(context) {
+  if (context.observations.length === 0) {
+    return `Project: ${context.project_name} (no prior observations)`;
+  }
+  const DETAILED_COUNT = 5;
+  const isCrossProject = context.recentProjects && context.recentProjects.length > 0;
+  const lines = [];
+  if (isCrossProject) {
+    lines.push(`## Engrm Memory — Workspace Overview`);
+    lines.push(`This is a new project folder. Here is context from your recent work:`);
+    lines.push("");
+    lines.push("**Active projects in memory:**");
+    for (const rp of context.recentProjects) {
+      const activity = rp.days_ago === 0 ? "today" : rp.days_ago === 1 ? "yesterday" : `${rp.days_ago}d ago`;
+      lines.push(`- **${rp.name}** — ${rp.observation_count} observations, last active ${activity}`);
+    }
+    lines.push("");
+    lines.push(`${context.session_count} relevant observation(s) from across projects:`);
+    lines.push("");
+  } else {
+    lines.push(`## Project Memory: ${context.project_name}`);
+    lines.push(`${context.session_count} relevant observation(s) from prior sessions:`);
+    lines.push("");
+  }
+  for (let i = 0;i < context.observations.length; i++) {
+    const obs = context.observations[i];
+    const date = obs.created_at.split("T")[0];
+    const fromLabel = obs.source_project ? ` [from: ${obs.source_project}]` : "";
+    lines.push(`- **[${obs.type}]** ${obs.title} (${date}, q=${obs.quality.toFixed(1)})${fromLabel}`);
+    if (i < DETAILED_COUNT) {
+      const detail = formatObservationDetailFromContext(obs);
+      if (detail) {
+        lines.push(detail);
+      }
+    }
+  }
+  if (context.summaries && context.summaries.length > 0) {
+    lines.push("");
+    lines.push("## Recent Project Briefs");
+    for (const summary of context.summaries.slice(0, 3)) {
+      lines.push(...formatSessionBrief(summary));
+      lines.push("");
+    }
+  }
+  if (context.securityFindings && context.securityFindings.length > 0) {
+    lines.push("");
+    lines.push("Security findings (recent):");
+    for (const finding of context.securityFindings) {
+      const date = new Date(finding.created_at_epoch * 1000).toISOString().split("T")[0];
+      const file = finding.file_path ? ` in ${finding.file_path}` : finding.tool_name ? ` via ${finding.tool_name}` : "";
+      lines.push(`- [${finding.severity.toUpperCase()}] ${finding.pattern_name}${file} (${date})`);
+    }
+  }
+  if (context.staleDecisions && context.staleDecisions.length > 0) {
+    lines.push("");
+    lines.push("Stale commitments (decided but no implementation observed):");
+    for (const sd of context.staleDecisions) {
+      const date = sd.created_at.split("T")[0];
+      lines.push(`- [DECISION] ${sd.title} (${date}, ${sd.days_ago}d ago)`);
+      if (sd.best_match_title) {
+        lines.push(`  Closest match: "${sd.best_match_title}" (${Math.round((sd.best_match_similarity ?? 0) * 100)}% similar — not enough to count as done)`);
+      }
+    }
+  }
+  const remaining = context.total_active - context.session_count;
+  if (remaining > 0) {
+    lines.push("");
+    lines.push(`${remaining} more observation(s) available via search tool.`);
+  }
+  return lines.join(`
+`);
 }
-function asLlmProvider(value, fallback) {
-  if (value === "openai" || value === "anthropic" || value === "ollama" || value === "custom")
-    return value;
-  return fallback;
+function formatSessionBrief(summary) {
+  const lines = [];
+  const heading = summary.request ? `### ${truncateText(summary.request, 120)}` : `### Session ${summary.session_id.slice(0, 8)}`;
+  lines.push(heading);
+  const sections = [
+    ["Investigated", summary.investigated, 180],
+    ["Learned", summary.learned, 180],
+    ["Completed", summary.completed, 180],
+    ["Next Steps", summary.next_steps, 140]
+  ];
+  for (const [label, value, maxLen] of sections) {
+    const formatted = formatSummarySection(value, maxLen);
+    if (formatted) {
+      lines.push(`${label}:`);
+      lines.push(formatted);
+    }
+  }
+  return lines;
 }
-function asTier(value, fallback) {
-  if (value === "free" || value === "vibe" || value === "solo" || value === "pro" || value === "team" || value === "enterprise")
-    return value;
-  return fallback;
+function formatSummarySection(value, maxLen) {
+  if (!value)
+    return null;
+  const cleaned = value.split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => line.startsWith("-") ? line : `- ${line}`).join(`
+`);
+  if (!cleaned)
+    return null;
+  return truncateMultilineText(cleaned, maxLen);
 }
-function asObserverMode(value, fallback) {
-  if (value === "per_event" || value === "per_session")
-    return value;
-  return fallback;
+function truncateMultilineText(text, maxLen) {
+  if (text.length <= maxLen)
+    return text;
+  const truncated = text.slice(0, maxLen).trimEnd();
+  const lastBreak = Math.max(truncated.lastIndexOf(`
+`), truncated.lastIndexOf(" "));
+  const safe = lastBreak > maxLen * 0.5 ? truncated.slice(0, lastBreak) : truncated;
+  return `${safe.trimEnd()}…`;
 }
-function asTeams(value, fallback) {
-  if (!Array.isArray(value))
-    return fallback;
-  return value.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string" && typeof t.name === "string" && typeof t.namespace === "string");
+function truncateText(text, maxLen) {
+  if (text.length <= maxLen)
+    return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+function formatObservationDetailFromContext(obs) {
+  if (obs.facts) {
+    const bullets = parseFacts(obs.facts);
+    if (bullets.length > 0) {
+      return bullets.slice(0, 4).map((f) => `  - ${f}`).join(`
+`);
+    }
+  }
+  if (obs.narrative) {
+    const snippet = obs.narrative.length > 120 ? obs.narrative.slice(0, 117) + "..." : obs.narrative;
+    return `  ${snippet}`;
+  }
+  return null;
+}
+function formatObservationDetail(obs) {
+  if (obs.facts) {
+    const bullets = parseFacts(obs.facts);
+    if (bullets.length > 0) {
+      return bullets.slice(0, 4).map((f) => `  - ${f}`).join(`
+`);
+    }
+  }
+  if (obs.narrative) {
+    const snippet = obs.narrative.length > 120 ? obs.narrative.slice(0, 117) + "..." : obs.narrative;
+    return `  ${snippet}`;
+  }
+  return "";
+}
+function parseFacts(facts) {
+  if (!facts)
+    return [];
+  try {
+    const parsed = JSON.parse(facts);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((f) => typeof f === "string" && f.length > 0);
+    }
+  } catch {
+    if (facts.trim().length > 0) {
+      return [facts.trim()];
+    }
+  }
+  return [];
+}
+function toContextObservation(obs) {
+  return {
+    id: obs.id,
+    type: obs.type,
+    title: obs.title,
+    narrative: obs.narrative,
+    facts: obs.facts,
+    quality: obs.quality,
+    created_at: obs.created_at,
+    ...obs._source_project ? { source_project: obs._source_project } : {}
+  };
 }
 
-// src/storage/migrations.ts
-var MIGRATIONS = [
-  {
-    version: 1,
-    description: "Initial schema: projects, observations, sessions, sync, FTS5",
-    sql: `
-      -- Projects (canonical identity across machines)
-      CREATE TABLE projects (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          canonical_id    TEXT UNIQUE NOT NULL,
-          name            TEXT NOT NULL,
-          local_path      TEXT,
-          remote_url      TEXT,
-          first_seen_epoch INTEGER NOT NULL,
-          last_active_epoch INTEGER NOT NULL
-      );
-
-      -- Core observations table
-      CREATE TABLE observations (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT,
-          project_id      INTEGER NOT NULL REFERENCES projects(id),
-          type            TEXT NOT NULL CHECK (type IN (
-              'bugfix', 'discovery', 'decision', 'pattern',
-              'change', 'feature', 'refactor', 'digest'
-          )),
-          title           TEXT NOT NULL,
-          narrative       TEXT,
-          facts           TEXT,
-          concepts        TEXT,
-          files_read      TEXT,
-          files_modified  TEXT,
-          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
-          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
-              'active', 'aging', 'archived', 'purged', 'pinned'
-          )),
-          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
-              'shared', 'personal', 'secret'
-          )),
-          user_id         TEXT NOT NULL,
-          device_id       TEXT NOT NULL,
-          agent           TEXT DEFAULT 'claude-code',
-          created_at      TEXT NOT NULL,
-          created_at_epoch INTEGER NOT NULL,
-          archived_at_epoch INTEGER,
-          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL
-      );
-
-      -- Session tracking
-      CREATE TABLE sessions (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT UNIQUE NOT NULL,
-          project_id      INTEGER REFERENCES projects(id),
-          user_id         TEXT NOT NULL,
-          device_id       TEXT NOT NULL,
-          agent           TEXT DEFAULT 'claude-code',
-          status          TEXT DEFAULT 'active' CHECK (status IN ('active', 'completed')),
-          observation_count INTEGER DEFAULT 0,
-          started_at_epoch INTEGER,
-          completed_at_epoch INTEGER
-      );
-
-      -- Session summaries (generated on Stop hook)
-      CREATE TABLE session_summaries (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT UNIQUE NOT NULL,
-          project_id      INTEGER REFERENCES projects(id),
-          user_id         TEXT NOT NULL,
-          request         TEXT,
-          investigated    TEXT,
-          learned         TEXT,
-          completed       TEXT,
-          next_steps      TEXT,
-          created_at_epoch INTEGER
-      );
-
-      -- Sync outbox (offline-first queue)
-      CREATE TABLE sync_outbox (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary')),
-          record_id       INTEGER NOT NULL,
-          status          TEXT DEFAULT 'pending' CHECK (status IN (
-              'pending', 'syncing', 'synced', 'failed'
-          )),
-          retry_count     INTEGER DEFAULT 0,
-          max_retries     INTEGER DEFAULT 10,
-          last_error      TEXT,
-          created_at_epoch INTEGER NOT NULL,
-          synced_at_epoch  INTEGER,
-          next_retry_epoch INTEGER
-      );
-
-      -- Sync high-water mark and lifecycle job tracking
-      CREATE TABLE sync_state (
-          key   TEXT PRIMARY KEY,
-          value TEXT NOT NULL
-      );
-
-      -- FTS5 for local offline search (external content mode)
-      CREATE VIRTUAL TABLE observations_fts USING fts5(
-          title, narrative, facts, concepts,
-          content=observations,
-          content_rowid=id
-      );
-
-      -- Indexes: observations
-      CREATE INDEX idx_observations_project ON observations(project_id);
-      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
-      CREATE INDEX idx_observations_type ON observations(type);
-      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
-      CREATE INDEX idx_observations_session ON observations(session_id);
-      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
-      CREATE INDEX idx_observations_quality ON observations(quality);
-      CREATE INDEX idx_observations_user ON observations(user_id);
+// src/telemetry/stack-detect.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2, extname } from "node:path";
+var EXTENSION_MAP = {
+  ".tsx": "react",
+  ".jsx": "react",
+  ".ts": "typescript",
+  ".js": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".zig": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hs": "haskell",
+  ".lua": "lua",
+  ".dart": "dart",
+  ".scala": "scala",
+  ".clj": "clojure",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro"
+};
+var CONFIG_FILE_STACKS = [
+  ["next.config.js", "nextjs"],
+  ["next.config.mjs", "nextjs"],
+  ["next.config.ts", "nextjs"],
+  ["nuxt.config.ts", "nuxt"],
+  ["nuxt.config.js", "nuxt"],
+  ["vite.config.ts", "vite"],
+  ["vite.config.js", "vite"],
+  ["vite.config.mjs", "vite"],
+  ["svelte.config.js", "svelte"],
+  ["astro.config.mjs", "astro"],
+  ["remix.config.js", "remix"],
+  ["angular.json", "angular"],
+  ["tailwind.config.js", "tailwind"],
+  ["tailwind.config.ts", "tailwind"],
+  ["postcss.config.js", "postcss"],
+  ["webpack.config.js", "webpack"],
+  ["tsconfig.json", "typescript"],
+  ["Cargo.toml", "rust"],
+  ["go.mod", "go"],
+  ["pyproject.toml", "python"],
+  ["setup.py", "python"],
+  ["requirements.txt", "python"],
+  ["Pipfile", "python"],
+  ["manage.py", "django"],
+  ["Gemfile", "ruby"],
+  ["composer.json", "php"],
+  ["pom.xml", "java"],
+  ["build.gradle", "gradle"],
+  ["build.gradle.kts", "gradle"],
+  ["Package.swift", "swift"],
+  ["pubspec.yaml", "flutter"],
+  ["mix.exs", "elixir"],
+  ["deno.json", "deno"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["docker-compose.yml", "docker"],
+  ["docker-compose.yaml", "docker"],
+  ["Dockerfile", "docker"],
+  [".prisma/schema.prisma", "prisma"],
+  ["prisma/schema.prisma", "prisma"],
+  ["drizzle.config.ts", "drizzle"]
+];
+var PATH_PATTERN_STACKS = [
+  ["/__tests__/", "jest"],
+  ["/.storybook/", "storybook"],
+  ["/cypress/", "cypress"],
+  ["/playwright/", "playwright"],
+  ["/terraform/", "terraform"],
+  ["/k8s/", "kubernetes"],
+  ["/helm/", "helm"]
+];
+function detectStacks(filePaths) {
+  const stacks = new Set;
+  for (const fp of filePaths) {
+    const ext = extname(fp).toLowerCase();
+    if (ext && EXTENSION_MAP[ext]) {
+      stacks.add(EXTENSION_MAP[ext]);
+    }
+    for (const [pattern, stack] of PATH_PATTERN_STACKS) {
+      if (fp.includes(pattern)) {
+        stacks.add(stack);
+      }
+    }
+  }
+  return Array.from(stacks).sort();
+}
+function detectStacksFromProject(projectRoot, filePaths = []) {
+  const stacks = new Set(detectStacks(filePaths));
+  for (const [configFile, stack] of CONFIG_FILE_STACKS) {
+    try {
+      if (existsSync2(join2(projectRoot, configFile))) {
+        stacks.add(stack);
+      }
+    } catch {}
+  }
+  const sorted = Array.from(stacks).sort();
+  const frameworks = ["nextjs", "nuxt", "remix", "angular", "django", "flutter", "svelte", "astro"];
+  const primary = sorted.find((s) => frameworks.includes(s)) ?? sorted[0] ?? "unknown";
+  return { stacks: sorted, primary };
+}
 
-      -- Indexes: sessions
-      CREATE INDEX idx_sessions_project ON sessions(project_id);
+// src/telemetry/config-fingerprint.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, readdirSync, mkdirSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { homedir } from "node:os";
+var STATE_PATH = join3(homedir(), ".engrm", "config-fingerprint.json");
+var CLIENT_VERSION = "0.4.0";
+function hashFile(filePath) {
+  try {
+    if (!existsSync3(filePath))
+      return null;
+    const content = readFileSync2(filePath, "utf-8");
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function countMemoryFiles(memoryDir) {
+  try {
+    if (!existsSync3(memoryDir))
+      return 0;
+    return readdirSync(memoryDir).filter((f) => f.endsWith(".md")).length;
+  } catch {
+    return 0;
+  }
+}
+function readPreviousFingerprint() {
+  try {
+    if (!existsSync3(STATE_PATH))
+      return null;
+    return JSON.parse(readFileSync2(STATE_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveFingerprint(fp) {
+  try {
+    const dir = join3(homedir(), ".engrm");
+    if (!existsSync3(dir))
+      mkdirSync(dir, { recursive: true });
+    writeFileSync(STATE_PATH, JSON.stringify(fp, null, 2) + `
+`, "utf-8");
+  } catch {}
+}
+function computeAndSaveFingerprint(cwd) {
+  const claudeMdHash = hashFile(join3(cwd, "CLAUDE.md"));
+  const engrmJsonHash = hashFile(join3(cwd, ".engrm.json"));
+  const slug = cwd.replace(/\//g, "-");
+  const memoryDir = join3(homedir(), ".claude", "projects", slug, "memory");
+  const memoryMdHash = hashFile(join3(memoryDir, "MEMORY.md"));
+  const memoryFileCount = countMemoryFiles(memoryDir);
+  const material = [
+    claudeMdHash ?? "null",
+    memoryMdHash ?? "null",
+    engrmJsonHash ?? "null",
+    String(memoryFileCount),
+    CLIENT_VERSION
+  ].join("+");
+  const configHash = createHash("sha256").update(material).digest("hex");
+  const previous = readPreviousFingerprint();
+  const configChanged = previous !== null && previous.config_hash !== configHash;
+  const fingerprint = {
+    config_hash: configHash,
+    config_changed: configChanged,
+    claude_md_hash: claudeMdHash,
+    memory_md_hash: memoryMdHash,
+    engrm_json_hash: engrmJsonHash,
+    memory_file_count: memoryFileCount,
+    client_version: CLIENT_VERSION
+  };
+  saveFingerprint(fingerprint);
+  return fingerprint;
+}
 
-      -- Indexes: sync outbox
-      CREATE INDEX idx_outbox_status ON sync_outbox(status, next_retry_epoch);
-      CREATE INDEX idx_outbox_record ON sync_outbox(record_type, record_id);
-    `
-  },
-  {
-    version: 2,
-    description: "Add superseded_by for knowledge supersession",
-    sql: `
-      ALTER TABLE observations ADD COLUMN superseded_by INTEGER REFERENCES observations(id) ON DELETE SET NULL;
-      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
-    `
-  },
-  {
-    version: 3,
-    description: "Add remote_source_id for pull deduplication",
-    sql: `
-      ALTER TABLE observations ADD COLUMN remote_source_id TEXT;
-      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
-    `
-  },
-  {
-    version: 4,
-    description: "Add sqlite-vec for local semantic search",
-    sql: `
-      CREATE VIRTUAL TABLE vec_observations USING vec0(
-        observation_id INTEGER PRIMARY KEY,
-        embedding float[384]
-      );
-    `,
-    condition: (db) => isVecExtensionLoaded(db)
-  },
-  {
-    version: 5,
-    description: "Session metrics and security findings",
-    sql: `
-      ALTER TABLE sessions ADD COLUMN files_touched_count INTEGER DEFAULT 0;
-      ALTER TABLE sessions ADD COLUMN searches_performed INTEGER DEFAULT 0;
-      ALTER TABLE sessions ADD COLUMN tool_calls_count INTEGER DEFAULT 0;
-
-      CREATE TABLE security_findings (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT,
-          project_id      INTEGER NOT NULL REFERENCES projects(id),
-          finding_type    TEXT NOT NULL,
-          severity        TEXT NOT NULL DEFAULT 'medium' CHECK (severity IN ('critical', 'high', 'medium', 'low')),
-          pattern_name    TEXT NOT NULL,
-          file_path       TEXT,
-          snippet         TEXT,
-          tool_name       TEXT,
-          user_id         TEXT NOT NULL,
-          device_id       TEXT NOT NULL,
-          created_at_epoch INTEGER NOT NULL
-      );
-
-      CREATE INDEX idx_security_findings_session ON security_findings(session_id);
-      CREATE INDEX idx_security_findings_project ON security_findings(project_id, created_at_epoch);
-      CREATE INDEX idx_security_findings_severity ON security_findings(severity);
-    `
-  },
-  {
-    version: 6,
-    description: "Add risk_score, expand observation types to include standard",
-    sql: `
-      ALTER TABLE sessions ADD COLUMN risk_score INTEGER;
-
-      -- Recreate observations table with expanded type CHECK to include 'standard'
-      -- SQLite doesn't support ALTER CHECK, so we recreate the table
-      CREATE TABLE observations_new (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT,
-          project_id      INTEGER NOT NULL REFERENCES projects(id),
-          type            TEXT NOT NULL CHECK (type IN (
-              'bugfix', 'discovery', 'decision', 'pattern',
-              'change', 'feature', 'refactor', 'digest', 'standard'
-          )),
-          title           TEXT NOT NULL,
-          narrative       TEXT,
-          facts           TEXT,
-          concepts        TEXT,
-          files_read      TEXT,
-          files_modified  TEXT,
-          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
-          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
-              'active', 'aging', 'archived', 'purged', 'pinned'
-          )),
-          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
-              'shared', 'personal', 'secret'
-          )),
-          user_id         TEXT NOT NULL,
-          device_id       TEXT NOT NULL,
-          agent           TEXT DEFAULT 'claude-code',
-          created_at      TEXT NOT NULL,
-          created_at_epoch INTEGER NOT NULL,
-          archived_at_epoch INTEGER,
-          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          superseded_by   INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          remote_source_id TEXT
-      );
-
-      INSERT INTO observations_new SELECT * FROM observations;
-
-      DROP TABLE observations;
-      ALTER TABLE observations_new RENAME TO observations;
-
-      -- Recreate indexes
-      CREATE INDEX idx_observations_project ON observations(project_id);
-      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
-      CREATE INDEX idx_observations_type ON observations(type);
-      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
-      CREATE INDEX idx_observations_session ON observations(session_id);
-      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
-      CREATE INDEX idx_observations_quality ON observations(quality);
-      CREATE INDEX idx_observations_user ON observations(user_id);
-      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
-      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
-
-      -- Recreate FTS5 (external content mode — must rebuild after table recreation)
-      DROP TABLE IF EXISTS observations_fts;
-      CREATE VIRTUAL TABLE observations_fts USING fts5(
-          title, narrative, facts, concepts,
-          content=observations,
-          content_rowid=id
-      );
-      -- Rebuild FTS index
-      INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
-    `
-  },
-  {
-    version: 7,
-    description: "Add packs_installed table for help pack tracking",
-    sql: `
-      CREATE TABLE IF NOT EXISTS packs_installed (
-          name            TEXT PRIMARY KEY,
-          installed_at    INTEGER NOT NULL,
-          observation_count INTEGER DEFAULT 0
-      );
-    `
-  },
-  {
-    version: 8,
-    description: "Add message type to observations CHECK constraint",
-    sql: `
-      CREATE TABLE IF NOT EXISTS observations_v8 (
-          id              INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id      TEXT,
-          project_id      INTEGER NOT NULL REFERENCES projects(id),
-          type            TEXT NOT NULL CHECK (type IN (
-              'bugfix', 'discovery', 'decision', 'pattern',
-              'change', 'feature', 'refactor', 'digest', 'standard', 'message'
-          )),
-          title           TEXT NOT NULL,
-          narrative       TEXT,
-          facts           TEXT,
-          concepts        TEXT,
-          files_read      TEXT,
-          files_modified  TEXT,
-          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
-          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
-              'active', 'aging', 'archived', 'purged', 'pinned'
-          )),
-          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
-              'shared', 'personal', 'secret'
-          )),
-          user_id         TEXT NOT NULL,
-          device_id       TEXT NOT NULL,
-          agent           TEXT DEFAULT 'claude-code',
-          created_at      TEXT NOT NULL,
-          created_at_epoch INTEGER NOT NULL,
-          archived_at_epoch INTEGER,
-          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          superseded_by   INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          remote_source_id TEXT
-      );
-      INSERT INTO observations_v8 SELECT * FROM observations;
-      DROP TABLE observations;
-      ALTER TABLE observations_v8 RENAME TO observations;
-      CREATE INDEX idx_observations_project ON observations(project_id);
-      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
-      CREATE INDEX idx_observations_type ON observations(type);
-      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
-      CREATE INDEX idx_observations_session ON observations(session_id);
-      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
-      CREATE INDEX idx_observations_quality ON observations(quality);
-      CREATE INDEX idx_observations_user ON observations(user_id);
-      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
-      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
-      DROP TABLE IF EXISTS observations_fts;
-      CREATE VIRTUAL TABLE observations_fts USING fts5(
-          title, narrative, facts, concepts,
-          content=observations,
-          content_rowid=id
-      );
-      INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
-    `
-  }
-];
-function isVecExtensionLoaded(db) {
-  try {
-    db.exec("SELECT vec_version()");
-    return true;
-  } catch {
-    return false;
-  }
+// src/packs/recommender.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4, basename as basename3, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var STACK_PACK_MAP = {
+  typescript: ["typescript-patterns"],
+  react: ["react-gotchas"],
+  nextjs: ["nextjs-patterns"],
+  python: ["python-django"],
+  django: ["python-django"],
+  javascript: ["node-security"],
+  bun: ["node-security"]
+};
+function getPacksDir() {
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  return join4(thisDir, "../../packs");
 }
-function runMigrations(db) {
-  const currentVersion = db.query("PRAGMA user_version").get();
-  let version = currentVersion.user_version;
-  for (const migration of MIGRATIONS) {
-    if (migration.version <= version)
-      continue;
-    if (migration.condition && !migration.condition(db)) {
-      continue;
-    }
-    db.exec("BEGIN TRANSACTION");
-    try {
-      db.exec(migration.sql);
-      db.exec(`PRAGMA user_version = ${migration.version}`);
-      db.exec("COMMIT");
-      version = migration.version;
-    } catch (error) {
-      db.exec("ROLLBACK");
-      throw new Error(`Migration ${migration.version} (${migration.description}) failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
+function listAvailablePacks() {
+  const dir = getPacksDir();
+  if (!existsSync4(dir))
+    return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => basename3(f, ".json"));
 }
-function ensureObservationTypes(db) {
+function loadPack(name) {
+  const packPath = join4(getPacksDir(), `${name}.json`);
+  if (!existsSync4(packPath))
+    return null;
   try {
-    db.exec("INSERT INTO observations (session_id, project_id, type, title, user_id, device_id, agent, created_at, created_at_epoch) " + "VALUES ('_typecheck', 1, 'message', '_test', '_test', '_test', '_test', '2000-01-01', 0)");
-    db.exec("DELETE FROM observations WHERE session_id = '_typecheck'");
+    const raw = readFileSync3(packPath, "utf-8");
+    return JSON.parse(raw);
   } catch {
-    db.exec("BEGIN TRANSACTION");
-    try {
-      db.exec(`
-        CREATE TABLE observations_repair (
-          id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT,
-          project_id INTEGER NOT NULL REFERENCES projects(id),
-          type TEXT NOT NULL CHECK (type IN (
-            'bugfix','discovery','decision','pattern','change','feature',
-            'refactor','digest','standard','message')),
-          title TEXT NOT NULL, narrative TEXT, facts TEXT, concepts TEXT,
-          files_read TEXT, files_modified TEXT,
-          quality REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
-          lifecycle TEXT DEFAULT 'active' CHECK (lifecycle IN ('active','aging','archived','purged','pinned')),
-          sensitivity TEXT DEFAULT 'shared' CHECK (sensitivity IN ('shared','personal','secret')),
-          user_id TEXT NOT NULL, device_id TEXT NOT NULL, agent TEXT DEFAULT 'claude-code',
-          created_at TEXT NOT NULL, created_at_epoch INTEGER NOT NULL,
-          archived_at_epoch INTEGER,
-          compacted_into INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          superseded_by INTEGER REFERENCES observations(id) ON DELETE SET NULL,
-          remote_source_id TEXT
-        );
-        INSERT INTO observations_repair SELECT * FROM observations;
-        DROP TABLE observations;
-        ALTER TABLE observations_repair RENAME TO observations;
-        CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project_id);
-        CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
-        CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch);
-        CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
-        CREATE INDEX IF NOT EXISTS idx_observations_lifecycle ON observations(lifecycle);
-        CREATE INDEX IF NOT EXISTS idx_observations_quality ON observations(quality);
-        CREATE INDEX IF NOT EXISTS idx_observations_user ON observations(user_id);
-        CREATE INDEX IF NOT EXISTS idx_observations_superseded ON observations(superseded_by);
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
-        DROP TABLE IF EXISTS observations_fts;
-        CREATE VIRTUAL TABLE observations_fts USING fts5(
-          title, narrative, facts, concepts, content=observations, content_rowid=id
-        );
-        INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
-      `);
-      db.exec("COMMIT");
-    } catch (err) {
-      db.exec("ROLLBACK");
+    return null;
+  }
+}
+function recommendPacks(stacks, installedPacks) {
+  const installed = new Set(installedPacks);
+  const available = listAvailablePacks();
+  const availableSet = new Set(available);
+  const seen = new Set;
+  const recommendations = [];
+  for (const stack of stacks) {
+    const packNames = STACK_PACK_MAP[stack] ?? [];
+    for (const packName of packNames) {
+      if (seen.has(packName) || installed.has(packName) || !availableSet.has(packName)) {
+        continue;
+      }
+      seen.add(packName);
+      const pack = loadPack(packName);
+      if (!pack)
+        continue;
+      const matchedStacks = stacks.filter((s) => STACK_PACK_MAP[s]?.includes(packName));
+      recommendations.push({
+        name: packName,
+        description: pack.description,
+        observationCount: pack.observations.length,
+        matchedStacks
+      });
     }
   }
+  return recommendations;
 }
-var LATEST_SCHEMA_VERSION = MIGRATIONS.filter((m) => !m.condition).reduce((max, m) => Math.max(max, m.version), 0);
 
-// src/storage/sqlite.ts
-var IS_BUN = typeof globalThis.Bun !== "undefined";
-function openDatabase(dbPath) {
-  if (IS_BUN) {
-    return openBunDatabase(dbPath);
-  }
-  return openNodeDatabase(dbPath);
+// src/config.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, hostname, networkInterfaces } from "node:os";
+import { join as join5 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+var CONFIG_DIR = join5(homedir2(), ".engrm");
+var SETTINGS_PATH = join5(CONFIG_DIR, "settings.json");
+var DB_PATH = join5(CONFIG_DIR, "engrm.db");
+function getDbPath() {
+  return DB_PATH;
 }
-function openBunDatabase(dbPath) {
-  const { Database } = __require("bun:sqlite");
-  if (process.platform === "darwin") {
-    const { existsSync: existsSync2 } = __require("node:fs");
-    const paths = [
-      "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib",
-      "/usr/local/opt/sqlite3/lib/libsqlite3.dylib"
-    ];
-    for (const p of paths) {
-      if (existsSync2(p)) {
-        try {
-          Database.setCustomSQLite(p);
-        } catch {}
+function generateDeviceId() {
+  const host = hostname().toLowerCase().replace(/[^a-z0-9-]/g, "");
+  let mac = "";
+  const ifaces = networkInterfaces();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
         break;
       }
     }
+    if (mac)
+      break;
   }
-  const db = new Database(dbPath);
-  return db;
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash2("sha256").update(material).digest("hex").slice(0, 8);
+  return `${host}-${suffix}`;
 }
-function openNodeDatabase(dbPath) {
-  const BetterSqlite3 = __require("better-sqlite3");
-  const raw = new BetterSqlite3(dbPath);
+function createDefaultConfig() {
   return {
-    query(sql) {
-      const stmt = raw.prepare(sql);
-      return {
-        get(...params) {
-          return stmt.get(...params);
-        },
-        all(...params) {
-          return stmt.all(...params);
-        },
-        run(...params) {
-          return stmt.run(...params);
-        }
-      };
+    candengo_url: "",
+    candengo_api_key: "",
+    site_id: "",
+    namespace: "",
+    user_id: "",
+    user_email: "",
+    device_id: generateDeviceId(),
+    teams: [],
+    sync: {
+      enabled: true,
+      interval_seconds: 30,
+      batch_size: 50
     },
-    exec(sql) {
-      raw.exec(sql);
+    search: {
+      default_limit: 10,
+      local_boost: 1.2,
+      scope: "all"
     },
-    close() {
-      raw.close();
+    scrubbing: {
+      enabled: true,
+      custom_patterns: [],
+      default_sensitivity: "shared"
+    },
+    sentinel: {
+      enabled: false,
+      mode: "advisory",
+      provider: "openai",
+      model: "gpt-4o-mini",
+      api_key: "",
+      base_url: "",
+      skip_patterns: [],
+      daily_limit: 100,
+      tier: "free"
+    },
+    observer: {
+      enabled: true,
+      mode: "per_event",
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
     }
   };
 }
-
-class MemDatabase {
-  db;
-  vecAvailable;
-  constructor(dbPath) {
-    this.db = openDatabase(dbPath);
-    this.db.exec("PRAGMA journal_mode = WAL");
-    this.db.exec("PRAGMA foreign_keys = ON");
-    this.vecAvailable = this.loadVecExtension();
-    runMigrations(this.db);
-    ensureObservationTypes(this.db);
+function loadConfig() {
+  if (!existsSync5(SETTINGS_PATH)) {
+    throw new Error(`Config not found at ${SETTINGS_PATH}. Run 'engrm init --manual' to configure.`);
   }
-  loadVecExtension() {
-    try {
-      const sqliteVec = __require("sqlite-vec");
-      sqliteVec.load(this.db);
-      return true;
-    } catch {
-      return false;
-    }
+  const raw = readFileSync4(SETTINGS_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${SETTINGS_PATH}`);
   }
-  close() {
-    this.db.close();
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Config at ${SETTINGS_PATH} is not a JSON object`);
   }
-  upsertProject(project) {
-    const now = Math.floor(Date.now() / 1000);
-    const existing = this.db.query("SELECT * FROM projects WHERE canonical_id = ?").get(project.canonical_id);
-    if (existing) {
-      this.db.query(`UPDATE projects SET
-            local_path = COALESCE(?, local_path),
-            remote_url = COALESCE(?, remote_url),
-            last_active_epoch = ?
-          WHERE id = ?`).run(project.local_path ?? null, project.remote_url ?? null, now, existing.id);
-      return {
-        ...existing,
-        local_path: project.local_path ?? existing.local_path,
-        remote_url: project.remote_url ?? existing.remote_url,
-        last_active_epoch: now
-      };
+  const config = parsed;
+  const defaults = createDefaultConfig();
+  return {
+    candengo_url: asString(config["candengo_url"], defaults.candengo_url),
+    candengo_api_key: asString(config["candengo_api_key"], defaults.candengo_api_key),
+    site_id: asString(config["site_id"], defaults.site_id),
+    namespace: asString(config["namespace"], defaults.namespace),
+    user_id: asString(config["user_id"], defaults.user_id),
+    user_email: asString(config["user_email"], defaults.user_email),
+    device_id: asString(config["device_id"], defaults.device_id),
+    teams: asTeams(config["teams"], defaults.teams),
+    sync: {
+      enabled: asBool(config["sync"]?.["enabled"], defaults.sync.enabled),
+      interval_seconds: asNumber(config["sync"]?.["interval_seconds"], defaults.sync.interval_seconds),
+      batch_size: asNumber(config["sync"]?.["batch_size"], defaults.sync.batch_size)
+    },
+    search: {
+      default_limit: asNumber(config["search"]?.["default_limit"], defaults.search.default_limit),
+      local_boost: asNumber(config["search"]?.["local_boost"], defaults.search.local_boost),
+      scope: asScope(config["search"]?.["scope"], defaults.search.scope)
+    },
+    scrubbing: {
+      enabled: asBool(config["scrubbing"]?.["enabled"], defaults.scrubbing.enabled),
+      custom_patterns: asStringArray(config["scrubbing"]?.["custom_patterns"], defaults.scrubbing.custom_patterns),
+      default_sensitivity: asSensitivity(config["scrubbing"]?.["default_sensitivity"], defaults.scrubbing.default_sensitivity)
+    },
+    sentinel: {
+      enabled: asBool(config["sentinel"]?.["enabled"], defaults.sentinel.enabled),
+      mode: asSentinelMode(config["sentinel"]?.["mode"], defaults.sentinel.mode),
+      provider: asLlmProvider(config["sentinel"]?.["provider"], defaults.sentinel.provider),
+      model: asString(config["sentinel"]?.["model"], defaults.sentinel.model),
+      api_key: asString(config["sentinel"]?.["api_key"], defaults.sentinel.api_key),
+      base_url: asString(config["sentinel"]?.["base_url"], defaults.sentinel.base_url),
+      skip_patterns: asStringArray(config["sentinel"]?.["skip_patterns"], defaults.sentinel.skip_patterns),
+      daily_limit: asNumber(config["sentinel"]?.["daily_limit"], defaults.sentinel.daily_limit),
+      tier: asTier(config["sentinel"]?.["tier"], defaults.sentinel.tier)
+    },
+    observer: {
+      enabled: asBool(config["observer"]?.["enabled"], defaults.observer.enabled),
+      mode: asObserverMode(config["observer"]?.["mode"], defaults.observer.mode),
+      model: asString(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
     }
-    const result = this.db.query(`INSERT INTO projects (canonical_id, name, local_path, remote_url, first_seen_epoch, last_active_epoch)
-        VALUES (?, ?, ?, ?, ?, ?)`).run(project.canonical_id, project.name, project.local_path ?? null, project.remote_url ?? null, now, now);
-    return this.db.query("SELECT * FROM projects WHERE id = ?").get(Number(result.lastInsertRowid));
-  }
-  getProjectByCanonicalId(canonicalId) {
-    return this.db.query("SELECT * FROM projects WHERE canonical_id = ?").get(canonicalId) ?? null;
-  }
-  getProjectById(id) {
-    return this.db.query("SELECT * FROM projects WHERE id = ?").get(id) ?? null;
-  }
-  insertObservation(obs) {
-    const now = Math.floor(Date.now() / 1000);
-    const createdAt = new Date().toISOString();
-    const result = this.db.query(`INSERT INTO observations (
-          session_id, project_id, type, title, narrative, facts, concepts,
-          files_read, files_modified, quality, lifecycle, sensitivity,
-          user_id, device_id, agent, created_at, created_at_epoch
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(obs.session_id ?? null, obs.project_id, obs.type, obs.title, obs.narrative ?? null, obs.facts ?? null, obs.concepts ?? null, obs.files_read ?? null, obs.files_modified ?? null, obs.quality, obs.lifecycle ?? "active", obs.sensitivity ?? "shared", obs.user_id, obs.device_id, obs.agent ?? "claude-code", createdAt, now);
-    const id = Number(result.lastInsertRowid);
-    const row = this.getObservationById(id);
-    this.ftsInsert(row);
-    if (obs.session_id) {
-      this.db.query("UPDATE sessions SET observation_count = observation_count + 1 WHERE session_id = ?").run(obs.session_id);
-    }
-    return row;
+  };
+}
+function saveConfig(config) {
+  if (!existsSync5(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, { recursive: true });
   }
-  getObservationById(id) {
-    return this.db.query("SELECT * FROM observations WHERE id = ?").get(id) ?? null;
+  writeFileSync2(SETTINGS_PATH, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function configExists() {
+  return existsSync5(SETTINGS_PATH);
+}
+function asString(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback) {
+  return typeof value === "number" && !Number.isNaN(value) ? value : fallback;
+}
+function asBool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asStringArray(value, fallback) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : fallback;
+}
+function asScope(value, fallback) {
+  if (value === "personal" || value === "team" || value === "all")
+    return value;
+  return fallback;
+}
+function asSensitivity(value, fallback) {
+  if (value === "shared" || value === "personal" || value === "secret")
+    return value;
+  return fallback;
+}
+function asSentinelMode(value, fallback) {
+  if (value === "advisory" || value === "blocking")
+    return value;
+  return fallback;
+}
+function asLlmProvider(value, fallback) {
+  if (value === "openai" || value === "anthropic" || value === "ollama" || value === "custom")
+    return value;
+  return fallback;
+}
+function asTier(value, fallback) {
+  if (value === "free" || value === "vibe" || value === "solo" || value === "pro" || value === "team" || value === "enterprise")
+    return value;
+  return fallback;
+}
+function asObserverMode(value, fallback) {
+  if (value === "per_event" || value === "per_session")
+    return value;
+  return fallback;
+}
+function asTeams(value, fallback) {
+  if (!Array.isArray(value))
+    return fallback;
+  return value.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string" && typeof t.name === "string" && typeof t.namespace === "string");
+}
+
+// src/sync/auth.ts
+function getApiKey(config) {
+  const envKey = process.env.ENGRM_TOKEN;
+  if (envKey && envKey.startsWith("cvk_"))
+    return envKey;
+  if (config.candengo_api_key && config.candengo_api_key.length > 0) {
+    return config.candengo_api_key;
   }
-  getObservationsByIds(ids) {
-    if (ids.length === 0)
-      return [];
-    const placeholders = ids.map(() => "?").join(",");
-    return this.db.query(`SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`).all(...ids);
+  return null;
+}
+function getBaseUrl(config) {
+  if (config.candengo_url && config.candengo_url.length > 0) {
+    return config.candengo_url;
   }
-  getRecentObservations(projectId, sincEpoch, limit = 50) {
-    return this.db.query(`SELECT * FROM observations
-        WHERE project_id = ? AND created_at_epoch > ?
-        ORDER BY created_at_epoch DESC
-        LIMIT ?`).all(projectId, sincEpoch, limit);
+  return null;
+}
+function buildSourceId(config, localId, type = "obs") {
+  return `${config.user_id}-${config.device_id}-${type}-${localId}`;
+}
+function parseSourceId(sourceId) {
+  const obsIndex = sourceId.lastIndexOf("-obs-");
+  if (obsIndex === -1)
+    return null;
+  const prefix = sourceId.slice(0, obsIndex);
+  const localIdStr = sourceId.slice(obsIndex + 5);
+  const localId = parseInt(localIdStr, 10);
+  if (isNaN(localId))
+    return null;
+  const firstDash = prefix.indexOf("-");
+  if (firstDash === -1)
+    return null;
+  return {
+    userId: prefix.slice(0, firstDash),
+    deviceId: prefix.slice(firstDash + 1),
+    localId
+  };
+}
+
+// src/embeddings/embedder.ts
+var _available = null;
+var _pipeline = null;
+var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
+async function embedText(text) {
+  const pipe = await getPipeline();
+  if (!pipe)
+    return null;
+  try {
+    const output = await pipe(text, { pooling: "mean", normalize: true });
+    return new Float32Array(output.data);
+  } catch {
+    return null;
   }
-  searchFts(query, projectId, lifecycles = ["active", "aging", "pinned"], limit = 20) {
-    const lifecyclePlaceholders = lifecycles.map(() => "?").join(",");
-    if (projectId !== null) {
-      return this.db.query(`SELECT o.id, observations_fts.rank
-          FROM observations_fts
-          JOIN observations o ON o.id = observations_fts.rowid
-          WHERE observations_fts MATCH ?
-            AND o.project_id = ?
-            AND o.lifecycle IN (${lifecyclePlaceholders})
-          ORDER BY observations_fts.rank
-          LIMIT ?`).all(query, projectId, ...lifecycles, limit);
+}
+function composeEmbeddingText(obs) {
+  const parts = [obs.title];
+  if (obs.narrative)
+    parts.push(obs.narrative);
+  if (obs.facts) {
+    try {
+      const facts = JSON.parse(obs.facts);
+      if (Array.isArray(facts) && facts.length > 0) {
+        parts.push(facts.map((f) => `- ${f}`).join(`
+`));
+      }
+    } catch {
+      parts.push(obs.facts);
     }
-    return this.db.query(`SELECT o.id, observations_fts.rank
-        FROM observations_fts
-        JOIN observations o ON o.id = observations_fts.rowid
-        WHERE observations_fts MATCH ?
-          AND o.lifecycle IN (${lifecyclePlaceholders})
-        ORDER BY observations_fts.rank
-        LIMIT ?`).all(query, ...lifecycles, limit);
   }
-  getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3) {
-    const anchor = this.getObservationById(anchorId);
-    if (!anchor)
-      return [];
-    const projectFilter = projectId !== null ? "AND project_id = ?" : "";
-    const projectParams = projectId !== null ? [projectId] : [];
-    const before = this.db.query(`SELECT * FROM observations
-        WHERE created_at_epoch < ? ${projectFilter}
-          AND lifecycle IN ('active', 'aging', 'pinned')
-        ORDER BY created_at_epoch DESC
-        LIMIT ?`).all(anchor.created_at_epoch, ...projectParams, depthBefore);
-    const after = this.db.query(`SELECT * FROM observations
-        WHERE created_at_epoch > ? ${projectFilter}
-          AND lifecycle IN ('active', 'aging', 'pinned')
-        ORDER BY created_at_epoch ASC
-        LIMIT ?`).all(anchor.created_at_epoch, ...projectParams, depthAfter);
-    return [...before.reverse(), anchor, ...after];
+  if (obs.concepts) {
+    try {
+      const concepts = JSON.parse(obs.concepts);
+      if (Array.isArray(concepts) && concepts.length > 0) {
+        parts.push(concepts.join(", "));
+      }
+    } catch {}
   }
-  pinObservation(id, pinned) {
-    const obs = this.getObservationById(id);
-    if (!obs)
-      return false;
-    if (pinned) {
-      if (obs.lifecycle !== "active" && obs.lifecycle !== "aging")
-        return false;
-      this.db.query("UPDATE observations SET lifecycle = 'pinned' WHERE id = ?").run(id);
-    } else {
-      if (obs.lifecycle !== "pinned")
-        return false;
-      this.db.query("UPDATE observations SET lifecycle = 'active' WHERE id = ?").run(id);
-    }
-    return true;
+  return parts.join(`
+
+`);
+}
+async function getPipeline() {
+  if (_pipeline)
+    return _pipeline;
+  if (_available === false)
+    return null;
+  try {
+    const { pipeline } = await import("@xenova/transformers");
+    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
+    _available = true;
+    return _pipeline;
+  } catch (err) {
+    _available = false;
+    console.error(`[engrm] Local embedding model unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
   }
-  getActiveObservationCount(userId) {
-    if (userId) {
-      const result2 = this.db.query(`SELECT COUNT(*) as count FROM observations
-          WHERE lifecycle IN ('active', 'aging')
-            AND sensitivity != 'secret'
-            AND user_id = ?`).get(userId);
-      return result2?.count ?? 0;
+}
+
+// src/sync/pull.ts
+var PULL_CURSOR_KEY = "pull_cursor";
+var MAX_PAGES = 20;
+async function pullFromVector(db, client, config, limit = 50) {
+  let cursor = db.getSyncState(PULL_CURSOR_KEY) ?? undefined;
+  let totalReceived = 0;
+  let totalMerged = 0;
+  let totalSkipped = 0;
+  for (let page = 0;page < MAX_PAGES; page++) {
+    const response = await client.pullChanges(cursor, limit);
+    const { merged, skipped } = mergeChanges(db, config, response.changes);
+    totalReceived += response.changes.length;
+    totalMerged += merged;
+    totalSkipped += skipped;
+    if (response.cursor) {
+      db.setSyncState(PULL_CURSOR_KEY, response.cursor);
+      cursor = response.cursor;
     }
-    const result = this.db.query(`SELECT COUNT(*) as count FROM observations
-        WHERE lifecycle IN ('active', 'aging')
-          AND sensitivity != 'secret'`).get();
-    return result?.count ?? 0;
+    if (!response.has_more || response.changes.length === 0)
+      break;
   }
-  supersedeObservation(oldId, newId) {
-    if (oldId === newId)
-      return false;
-    const replacement = this.getObservationById(newId);
-    if (!replacement)
-      return false;
-    let targetId = oldId;
-    const visited = new Set;
-    for (let depth = 0;depth < 10; depth++) {
-      const target2 = this.getObservationById(targetId);
-      if (!target2)
-        return false;
-      if (target2.superseded_by === null)
-        break;
-      if (target2.superseded_by === newId)
-        return true;
-      visited.add(targetId);
-      targetId = target2.superseded_by;
-      if (visited.has(targetId))
-        return false;
+  return { received: totalReceived, merged: totalMerged, skipped: totalSkipped };
+}
+function mergeChanges(db, config, changes) {
+  let merged = 0;
+  let skipped = 0;
+  for (const change of changes) {
+    const parsed = parseSourceId(change.source_id);
+    if (parsed && parsed.deviceId === config.device_id) {
+      skipped++;
+      continue;
     }
-    const target = this.getObservationById(targetId);
-    if (!target)
-      return false;
-    if (target.superseded_by !== null)
-      return false;
-    if (targetId === newId)
-      return false;
-    const now = Math.floor(Date.now() / 1000);
-    this.db.query(`UPDATE observations
-         SET superseded_by = ?, lifecycle = 'archived', archived_at_epoch = ?
-         WHERE id = ?`).run(newId, now, targetId);
-    this.ftsDelete(target);
-    this.vecDelete(targetId);
-    return true;
-  }
-  isSuperseded(id) {
-    const obs = this.getObservationById(id);
-    return obs !== null && obs.superseded_by !== null;
-  }
-  upsertSession(sessionId, projectId, userId, deviceId, agent = "claude-code") {
-    const existing = this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
-    if (existing)
-      return existing;
-    const now = Math.floor(Date.now() / 1000);
-    this.db.query(`INSERT INTO sessions (session_id, project_id, user_id, device_id, agent, started_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?)`).run(sessionId, projectId, userId, deviceId, agent, now);
-    return this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+    const existing = db.db.query("SELECT id FROM observations WHERE remote_source_id = ?").get(change.source_id);
+    if (existing) {
+      skipped++;
+      continue;
+    }
+    const projectCanonical = change.metadata?.project_canonical ?? null;
+    if (!projectCanonical) {
+      skipped++;
+      continue;
+    }
+    let project = db.getProjectByCanonicalId(projectCanonical);
+    if (!project) {
+      project = db.upsertProject({
+        canonical_id: projectCanonical,
+        name: change.metadata?.project_name ?? projectCanonical.split("/").pop() ?? "unknown"
+      });
+    }
+    const obs = db.insertObservation({
+      session_id: change.metadata?.session_id ?? null,
+      project_id: project.id,
+      type: change.metadata?.type ?? "discovery",
+      title: change.metadata?.title ?? change.content.split(`
+`)[0] ?? "Untitled",
+      narrative: extractNarrative(change.content),
+      facts: change.metadata?.facts ? JSON.stringify(change.metadata.facts) : null,
+      concepts: change.metadata?.concepts ? JSON.stringify(change.metadata.concepts) : null,
+      quality: change.metadata?.quality ?? 0.5,
+      lifecycle: "active",
+      sensitivity: change.metadata?.sensitivity ?? "shared",
+      user_id: change.metadata?.user_id ?? "unknown",
+      device_id: change.metadata?.device_id ?? "unknown",
+      agent: change.metadata?.agent ?? "unknown",
+      created_at: change.metadata?.created_at ?? undefined,
+      created_at_epoch: change.metadata?.created_at_epoch ?? undefined
+    });
+    db.db.query("UPDATE observations SET remote_source_id = ? WHERE id = ?").run(change.source_id, obs.id);
+    if (db.vecAvailable) {
+      embedAndInsert(db, obs).catch(() => {});
+    }
+    merged++;
   }
-  completeSession(sessionId) {
-    const now = Math.floor(Date.now() / 1000);
-    this.db.query("UPDATE sessions SET status = 'completed', completed_at_epoch = ? WHERE session_id = ?").run(now, sessionId);
+  return { merged, skipped };
+}
+async function embedAndInsert(db, obs) {
+  const text = composeEmbeddingText(obs);
+  const embedding = await embedText(text);
+  if (embedding)
+    db.vecInsert(obs.id, embedding);
+}
+function extractNarrative(content) {
+  const lines = content.split(`
+`);
+  if (lines.length <= 1)
+    return null;
+  const narrative = lines.slice(1).join(`
+`).trim();
+  return narrative.length > 0 ? narrative : null;
+}
+async function pullSettings(client, config) {
+  try {
+    const settings = await client.fetchSettings();
+    if (!settings)
+      return false;
+    let changed = false;
+    if (settings.transcript_analysis !== undefined) {
+      const ta = settings.transcript_analysis;
+      if (typeof ta === "object" && ta !== null) {
+        const taObj = ta;
+        if (taObj.enabled !== undefined && taObj.enabled !== config.transcript_analysis.enabled) {
+          config.transcript_analysis.enabled = !!taObj.enabled;
+          changed = true;
+        }
+      }
+    }
+    if (settings.observer !== undefined) {
+      const obs = settings.observer;
+      if (typeof obs === "object" && obs !== null) {
+        const obsObj = obs;
+        if (obsObj.enabled !== undefined && obsObj.enabled !== config.observer.enabled) {
+          config.observer.enabled = !!obsObj.enabled;
+          changed = true;
+        }
+        if (obsObj.model !== undefined && typeof obsObj.model === "string" && obsObj.model !== config.observer.model) {
+          config.observer.model = obsObj.model;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      saveConfig(config);
+    }
+    return changed;
+  } catch {
+    return false;
   }
-  addToOutbox(recordType, recordId) {
-    const now = Math.floor(Date.now() / 1000);
-    this.db.query(`INSERT INTO sync_outbox (record_type, record_id, created_at_epoch)
-        VALUES (?, ?, ?)`).run(recordType, recordId, now);
+}
+
+// src/sync/client.ts
+class VectorClient {
+  baseUrl;
+  apiKey;
+  siteId;
+  namespace;
+  constructor(config) {
+    const baseUrl = getBaseUrl(config);
+    const apiKey = getApiKey(config);
+    if (!baseUrl || !apiKey) {
+      throw new Error("VectorClient requires candengo_url and candengo_api_key");
+    }
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.siteId = config.site_id;
+    this.namespace = config.namespace;
   }
-  getSyncState(key) {
-    const row = this.db.query("SELECT value FROM sync_state WHERE key = ?").get(key);
-    return row?.value ?? null;
+  static isConfigured(config) {
+    return getApiKey(config) !== null && getBaseUrl(config) !== null;
   }
-  setSyncState(key, value) {
-    this.db.query("INSERT INTO sync_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?").run(key, value, value);
+  async ingest(doc) {
+    await this.request("POST", "/v1/ingest", doc);
   }
-  ftsInsert(obs) {
-    this.db.query(`INSERT INTO observations_fts (rowid, title, narrative, facts, concepts)
-        VALUES (?, ?, ?, ?, ?)`).run(obs.id, obs.title, obs.narrative, obs.facts, obs.concepts);
+  async batchIngest(docs) {
+    if (docs.length === 0)
+      return;
+    await this.request("POST", "/v1/ingest/batch", { documents: docs });
   }
-  ftsDelete(obs) {
-    this.db.query(`INSERT INTO observations_fts (observations_fts, rowid, title, narrative, facts, concepts)
-        VALUES ('delete', ?, ?, ?, ?, ?)`).run(obs.id, obs.title, obs.narrative, obs.facts, obs.concepts);
+  async search(query, metadataFilter, limit = 10) {
+    const body = { query, limit };
+    if (metadataFilter) {
+      body.metadata_filter = metadataFilter;
+    }
+    return this.request("POST", "/v1/search", body);
   }
-  vecInsert(observationId, embedding) {
-    if (!this.vecAvailable)
+  async deleteBySourceIds(sourceIds) {
+    if (sourceIds.length === 0)
       return;
-    this.db.query("INSERT OR REPLACE INTO vec_observations (observation_id, embedding) VALUES (?, ?)").run(observationId, new Uint8Array(embedding.buffer));
+    await this.request("POST", "/v1/documents/delete", {
+      source_ids: sourceIds
+    });
   }
-  vecDelete(observationId) {
-    if (!this.vecAvailable)
-      return;
-    this.db.query("DELETE FROM vec_observations WHERE observation_id = ?").run(observationId);
+  async pullChanges(cursor, limit = 50) {
+    const params = new URLSearchParams;
+    if (cursor)
+      params.set("cursor", cursor);
+    params.set("namespace", this.namespace);
+    params.set("limit", String(limit));
+    return this.request("GET", `/v1/sync/changes?${params.toString()}`);
   }
-  searchVec(queryEmbedding, projectId, lifecycles = ["active", "aging", "pinned"], limit = 20) {
-    if (!this.vecAvailable)
-      return [];
-    const lifecyclePlaceholders = lifecycles.map(() => "?").join(",");
-    const embeddingBlob = new Uint8Array(queryEmbedding.buffer);
-    if (projectId !== null) {
-      return this.db.query(`SELECT v.observation_id, v.distance
-           FROM vec_observations v
-           JOIN observations o ON o.id = v.observation_id
-           WHERE v.embedding MATCH ?
-             AND k = ?
-             AND o.project_id = ?
-             AND o.lifecycle IN (${lifecyclePlaceholders})
-             AND o.superseded_by IS NULL`).all(embeddingBlob, limit, projectId, ...lifecycles);
+  async sendTelemetry(beacon) {
+    await this.request("POST", "/v1/mem/telemetry", beacon);
+  }
+  async fetchSettings() {
+    try {
+      return await this.request("GET", "/v1/mem/user-settings");
+    } catch {
+      return null;
     }
-    return this.db.query(`SELECT v.observation_id, v.distance
-         FROM vec_observations v
-         JOIN observations o ON o.id = v.observation_id
-         WHERE v.embedding MATCH ?
-           AND k = ?
-           AND o.lifecycle IN (${lifecyclePlaceholders})
-           AND o.superseded_by IS NULL`).all(embeddingBlob, limit, ...lifecycles);
   }
-  getUnembeddedCount() {
-    if (!this.vecAvailable)
-      return 0;
-    const result = this.db.query(`SELECT COUNT(*) as count FROM observations o
-         WHERE o.lifecycle IN ('active', 'aging', 'pinned')
-         AND o.superseded_by IS NULL
-         AND NOT EXISTS (
-           SELECT 1 FROM vec_observations v WHERE v.observation_id = o.id
-         )`).get();
-    return result?.count ?? 0;
+  async health() {
+    try {
+      await this.request("GET", "/health");
+      return true;
+    } catch {
+      return false;
+    }
   }
-  getUnembeddedObservations(limit = 100) {
-    if (!this.vecAvailable)
-      return [];
-    return this.db.query(`SELECT o.* FROM observations o
-         WHERE o.lifecycle IN ('active', 'aging', 'pinned')
-         AND o.superseded_by IS NULL
-         AND NOT EXISTS (
-           SELECT 1 FROM vec_observations v WHERE v.observation_id = o.id
-         )
-         ORDER BY o.created_at_epoch DESC
-         LIMIT ?`).all(limit);
-  }
-  insertSessionSummary(summary) {
-    const now = Math.floor(Date.now() / 1000);
-    const result = this.db.query(`INSERT INTO session_summaries (session_id, project_id, user_id, request, investigated, learned, completed, next_steps, created_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(summary.session_id, summary.project_id, summary.user_id, summary.request, summary.investigated, summary.learned, summary.completed, summary.next_steps, now);
-    const id = Number(result.lastInsertRowid);
-    return this.db.query("SELECT * FROM session_summaries WHERE id = ?").get(id);
-  }
-  getSessionSummary(sessionId) {
-    return this.db.query("SELECT * FROM session_summaries WHERE session_id = ?").get(sessionId) ?? null;
-  }
-  getRecentSummaries(projectId, limit = 5) {
-    return this.db.query(`SELECT * FROM session_summaries
-         WHERE project_id = ?
-         ORDER BY created_at_epoch DESC, id DESC
-         LIMIT ?`).all(projectId, limit);
-  }
-  incrementSessionMetrics(sessionId, increments) {
-    const sets = [];
-    const params = [];
-    if (increments.files) {
-      sets.push("files_touched_count = files_touched_count + ?");
-      params.push(increments.files);
-    }
-    if (increments.searches) {
-      sets.push("searches_performed = searches_performed + ?");
-      params.push(increments.searches);
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body && method !== "GET") {
+      init.body = JSON.stringify(body);
     }
-    if (increments.toolCalls) {
-      sets.push("tool_calls_count = tool_calls_count + ?");
-      params.push(increments.toolCalls);
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new VectorApiError(response.status, text, path);
     }
-    if (sets.length === 0)
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
       return;
-    params.push(sessionId);
-    this.db.query(`UPDATE sessions SET ${sets.join(", ")} WHERE session_id = ?`).run(...params);
-  }
-  getSessionMetrics(sessionId) {
-    return this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId) ?? null;
-  }
-  insertSecurityFinding(finding) {
-    const now = Math.floor(Date.now() / 1000);
-    const result = this.db.query(`INSERT INTO security_findings (session_id, project_id, finding_type, severity, pattern_name, file_path, snippet, tool_name, user_id, device_id, created_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(finding.session_id ?? null, finding.project_id, finding.finding_type, finding.severity, finding.pattern_name, finding.file_path ?? null, finding.snippet ?? null, finding.tool_name ?? null, finding.user_id, finding.device_id, now);
-    const id = Number(result.lastInsertRowid);
-    return this.db.query("SELECT * FROM security_findings WHERE id = ?").get(id);
-  }
-  getSecurityFindings(projectId, options = {}) {
-    const limit = options.limit ?? 50;
-    if (options.severity) {
-      return this.db.query(`SELECT * FROM security_findings
-           WHERE project_id = ? AND severity = ?
-           ORDER BY created_at_epoch DESC
-           LIMIT ?`).all(projectId, options.severity, limit);
-    }
-    return this.db.query(`SELECT * FROM security_findings
-         WHERE project_id = ?
-         ORDER BY created_at_epoch DESC
-         LIMIT ?`).all(projectId, limit);
-  }
-  getSecurityFindingsCount(projectId) {
-    const rows = this.db.query(`SELECT severity, COUNT(*) as count FROM security_findings
-         WHERE project_id = ?
-         GROUP BY severity`).all(projectId);
-    const counts = {
-      critical: 0,
-      high: 0,
-      medium: 0,
-      low: 0
-    };
-    for (const row of rows) {
-      counts[row.severity] = row.count;
-    }
-    return counts;
-  }
-  setSessionRiskScore(sessionId, score) {
-    this.db.query("UPDATE sessions SET risk_score = ? WHERE session_id = ?").run(score, sessionId);
-  }
-  getObservationsBySession(sessionId) {
-    return this.db.query(`SELECT * FROM observations WHERE session_id = ? ORDER BY created_at_epoch ASC`).all(sessionId);
-  }
-  getInstalledPacks() {
-    try {
-      const rows = this.db.query("SELECT name FROM packs_installed").all();
-      return rows.map((r) => r.name);
-    } catch {
-      return [];
     }
-  }
-  markPackInstalled(name, observationCount) {
-    const now = Math.floor(Date.now() / 1000);
-    this.db.query("INSERT OR REPLACE INTO packs_installed (name, installed_at, observation_count) VALUES (?, ?, ?)").run(name, now, observationCount);
+    return response.json();
   }
 }
 
-// src/storage/projects.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { basename, join as join2 } from "node:path";
-function normaliseGitRemoteUrl(remoteUrl) {
-  let url = remoteUrl.trim();
-  url = url.replace(/^(?:https?|ssh|git):\/\//, "");
-  url = url.replace(/^[^@]+@/, "");
-  url = url.replace(/^([^/:]+):(?!\d)/, "$1/");
-  url = url.replace(/\.git$/, "");
-  url = url.replace(/\/+$/, "");
-  const slashIndex = url.indexOf("/");
-  if (slashIndex !== -1) {
-    const host = url.substring(0, slashIndex).toLowerCase();
-    const path = url.substring(slashIndex);
-    url = host + path;
-  } else {
-    url = url.toLowerCase();
-  }
-  return url;
-}
-function projectNameFromCanonicalId(canonicalId) {
-  const parts = canonicalId.split("/");
-  return parts[parts.length - 1] ?? canonicalId;
-}
-function getGitRemoteUrl(directory) {
-  try {
-    const url = execSync("git remote get-url origin", {
-      cwd: directory,
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return url || null;
-  } catch {
-    try {
-      const remotes = execSync("git remote", {
-        cwd: directory,
-        encoding: "utf-8",
-        timeout: 5000,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim().split(`
-`).filter(Boolean);
-      if (remotes.length === 0)
-        return null;
-      const url = execSync(`git remote get-url ${remotes[0]}`, {
-        cwd: directory,
-        encoding: "utf-8",
-        timeout: 5000,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      return url || null;
-    } catch {
-      return null;
-    }
-  }
-}
-function readProjectConfigFile(directory) {
-  const configPath = join2(directory, ".engrm.json");
-  if (!existsSync2(configPath))
-    return null;
-  try {
-    const raw = readFileSync2(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed["project_id"] !== "string" || !parsed["project_id"]) {
-      return null;
-    }
-    return {
-      project_id: parsed["project_id"],
-      name: typeof parsed["name"] === "string" ? parsed["name"] : undefined
-    };
-  } catch {
-    return null;
-  }
-}
-function detectProject(directory) {
-  const remoteUrl = getGitRemoteUrl(directory);
-  if (remoteUrl) {
-    const canonicalId = normaliseGitRemoteUrl(remoteUrl);
-    return {
-      canonical_id: canonicalId,
-      name: projectNameFromCanonicalId(canonicalId),
-      remote_url: remoteUrl,
-      local_path: directory
-    };
-  }
-  const configFile = readProjectConfigFile(directory);
-  if (configFile) {
-    return {
-      canonical_id: configFile.project_id,
-      name: configFile.name ?? projectNameFromCanonicalId(configFile.project_id),
-      remote_url: null,
-      local_path: directory
-    };
+class VectorApiError extends Error {
+  status;
+  body;
+  path;
+  constructor(status, body, path) {
+    super(`Vector API error ${status} on ${path}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.path = path;
+    this.name = "VectorApiError";
   }
-  const dirName = basename(directory);
-  return {
-    canonical_id: `local/${dirName}`,
-    name: dirName,
-    remote_url: null,
-    local_path: directory
-  };
 }
 
-// src/context/inject.ts
-var RECENCY_WINDOW_SECONDS = 30 * 86400;
-function computeBlendedScore(quality, createdAtEpoch, nowEpoch) {
-  const age = nowEpoch - createdAtEpoch;
-  const recencyNorm = Math.max(0, Math.min(1, 1 - age / RECENCY_WINDOW_SECONDS));
-  return quality * 0.6 + recencyNorm * 0.4;
-}
-function estimateTokens(text) {
-  if (!text)
-    return 0;
-  return Math.ceil(text.length / 4);
-}
-function buildSessionContext(db, cwd, options = {}) {
-  const opts = typeof options === "number" ? { maxCount: options } : options;
-  const tokenBudget = opts.tokenBudget ?? 3000;
-  const maxCount = opts.maxCount;
-  const detected = detectProject(cwd);
-  const project = db.getProjectByCanonicalId(detected.canonical_id);
-  if (!project) {
-    return {
-      project_name: detected.name,
-      canonical_id: detected.canonical_id,
-      observations: [],
-      session_count: 0,
-      total_active: 0
-    };
-  }
-  const totalActive = (db.db.query(`SELECT COUNT(*) as c FROM observations
-         WHERE project_id = ? AND lifecycle IN ('active', 'aging', 'pinned')
-         AND superseded_by IS NULL`).get(project.id) ?? { c: 0 }).c;
-  const MAX_PINNED = 5;
-  const pinned = db.db.query(`SELECT * FROM observations
-       WHERE project_id = ? AND lifecycle = 'pinned'
-       AND superseded_by IS NULL
-       ORDER BY quality DESC, created_at_epoch DESC
-       LIMIT ?`).all(project.id, MAX_PINNED);
-  const MAX_RECENT = 5;
-  const recent = db.db.query(`SELECT * FROM observations
-       WHERE project_id = ? AND lifecycle IN ('active', 'aging')
-       AND superseded_by IS NULL
-       ORDER BY created_at_epoch DESC
-       LIMIT ?`).all(project.id, MAX_RECENT);
-  const candidateLimit = maxCount ?? 50;
-  const candidates = db.db.query(`SELECT * FROM observations
-       WHERE project_id = ? AND lifecycle IN ('active', 'aging')
-       AND quality >= 0.3
-       AND superseded_by IS NULL
-       ORDER BY quality DESC, created_at_epoch DESC
-       LIMIT ?`).all(project.id, candidateLimit);
-  let crossProjectCandidates = [];
-  if (opts.scope === "all") {
-    const crossLimit = Math.max(10, Math.floor(candidateLimit / 3));
-    const rawCross = db.db.query(`SELECT * FROM observations
-         WHERE project_id != ? AND lifecycle IN ('active', 'aging')
-         AND quality >= 0.5
-         AND superseded_by IS NULL
-         ORDER BY quality DESC, created_at_epoch DESC
-         LIMIT ?`).all(project.id, crossLimit);
-    const projectNameCache = new Map;
-    crossProjectCandidates = rawCross.map((obs) => {
-      if (!projectNameCache.has(obs.project_id)) {
-        const proj = db.getProjectById(obs.project_id);
-        if (proj)
-          projectNameCache.set(obs.project_id, proj.name);
-      }
-      return { ...obs, _source_project: projectNameCache.get(obs.project_id) };
-    });
-  }
-  const seenIds = new Set(pinned.map((o) => o.id));
-  const dedupedRecent = recent.filter((o) => {
-    if (seenIds.has(o.id))
-      return false;
-    seenIds.add(o.id);
-    return true;
-  });
-  const deduped = candidates.filter((o) => !seenIds.has(o.id));
-  for (const obs of crossProjectCandidates) {
-    if (!seenIds.has(obs.id)) {
-      seenIds.add(obs.id);
-      deduped.push(obs);
-    }
-  }
-  const nowEpoch = Math.floor(Date.now() / 1000);
-  const sorted = [...deduped].sort((a, b) => {
-    const boostA = a.type === "digest" ? 0.15 : 0;
-    const boostB = b.type === "digest" ? 0.15 : 0;
-    const scoreA = computeBlendedScore(a.quality, a.created_at_epoch, nowEpoch) + boostA;
-    const scoreB = computeBlendedScore(b.quality, b.created_at_epoch, nowEpoch) + boostB;
-    return scoreB - scoreA;
-  });
-  if (maxCount !== undefined) {
-    const remaining = Math.max(0, maxCount - pinned.length - dedupedRecent.length);
-    const all = [...pinned, ...dedupedRecent, ...sorted.slice(0, remaining)];
-    return {
-      project_name: project.name,
-      canonical_id: project.canonical_id,
-      observations: all.map(toContextObservation),
-      session_count: all.length,
-      total_active: totalActive
-    };
-  }
-  let remainingBudget = tokenBudget - 30;
-  const selected = [];
-  for (const obs of pinned) {
-    const cost = estimateObservationTokens(obs, selected.length);
-    remainingBudget -= cost;
-    selected.push(obs);
-  }
-  for (const obs of dedupedRecent) {
-    const cost = estimateObservationTokens(obs, selected.length);
-    remainingBudget -= cost;
-    selected.push(obs);
-  }
-  for (const obs of sorted) {
-    const cost = estimateObservationTokens(obs, selected.length);
-    if (remainingBudget - cost < 0 && selected.length > 0)
-      break;
-    remainingBudget -= cost;
-    selected.push(obs);
-  }
-  const summaries = db.getRecentSummaries(project.id, 5);
-  let securityFindings = [];
-  try {
-    const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86400;
-    securityFindings = db.db.query(`SELECT * FROM security_findings
-         WHERE project_id = ? AND created_at_epoch > ?
-         ORDER BY severity DESC, created_at_epoch DESC
-         LIMIT ?`).all(project.id, weekAgo, 10);
-  } catch {}
-  return {
-    project_name: project.name,
-    canonical_id: project.canonical_id,
-    observations: selected.map(toContextObservation),
-    session_count: selected.length,
-    total_active: totalActive,
-    summaries: summaries.length > 0 ? summaries : undefined,
-    securityFindings: securityFindings.length > 0 ? securityFindings : undefined
-  };
-}
-function estimateObservationTokens(obs, index) {
-  const DETAILED_THRESHOLD = 5;
-  const titleCost = estimateTokens(`- **[${obs.type}]** ${obs.title} (2026-01-01, q=0.5)`);
-  if (index >= DETAILED_THRESHOLD) {
-    return titleCost;
-  }
-  const detailText = formatObservationDetail(obs);
-  return titleCost + estimateTokens(detailText);
-}
-function formatContextForInjection(context) {
-  if (context.observations.length === 0) {
-    return `Project: ${context.project_name} (no prior observations)`;
-  }
-  const DETAILED_COUNT = 5;
-  const lines = [
-    `## Project Memory: ${context.project_name}`,
-    `${context.session_count} relevant observation(s) from prior sessions:`,
-    ""
-  ];
-  for (let i = 0;i < context.observations.length; i++) {
-    const obs = context.observations[i];
-    const date = obs.created_at.split("T")[0];
-    const fromLabel = obs.source_project ? ` [from: ${obs.source_project}]` : "";
-    lines.push(`- **[${obs.type}]** ${obs.title} (${date}, q=${obs.quality.toFixed(1)})${fromLabel}`);
-    if (i < DETAILED_COUNT) {
-      const detail = formatObservationDetailFromContext(obs);
-      if (detail) {
-        lines.push(detail);
-      }
-    }
-  }
-  if (context.summaries && context.summaries.length > 0) {
-    lines.push("");
-    lines.push("Lessons from recent sessions:");
-    for (const summary of context.summaries) {
-      if (summary.request) {
-        lines.push(`- Request: ${summary.request}`);
-      }
-      if (summary.learned) {
-        lines.push(`  Learned: ${truncateText(summary.learned, 100)}`);
-      }
-      if (summary.next_steps) {
-        lines.push(`  Next: ${truncateText(summary.next_steps, 80)}`);
-      }
-    }
-  }
-  if (context.securityFindings && context.securityFindings.length > 0) {
-    lines.push("");
-    lines.push("Security findings (recent):");
-    for (const finding of context.securityFindings) {
-      const date = new Date(finding.created_at_epoch * 1000).toISOString().split("T")[0];
-      const file = finding.file_path ? ` in ${finding.file_path}` : finding.tool_name ? ` via ${finding.tool_name}` : "";
-      lines.push(`- [${finding.severity.toUpperCase()}] ${finding.pattern_name}${file} (${date})`);
-    }
-  }
-  const remaining = context.total_active - context.session_count;
-  if (remaining > 0) {
-    lines.push("");
-    lines.push(`${remaining} more observation(s) available via search tool.`);
-  }
-  return lines.join(`
-`);
-}
-function truncateText(text, maxLen) {
-  if (text.length <= maxLen)
-    return text;
-  return text.slice(0, maxLen - 3) + "...";
-}
-function formatObservationDetailFromContext(obs) {
-  if (obs.facts) {
-    const bullets = parseFacts(obs.facts);
-    if (bullets.length > 0) {
-      return bullets.slice(0, 4).map((f) => `  - ${f}`).join(`
-`);
-    }
-  }
-  if (obs.narrative) {
-    const snippet = obs.narrative.length > 120 ? obs.narrative.slice(0, 117) + "..." : obs.narrative;
-    return `  ${snippet}`;
-  }
-  return null;
-}
-function formatObservationDetail(obs) {
-  if (obs.facts) {
-    const bullets = parseFacts(obs.facts);
-    if (bullets.length > 0) {
-      return bullets.slice(0, 4).map((f) => `  - ${f}`).join(`
-`);
-    }
-  }
-  if (obs.narrative) {
-    const snippet = obs.narrative.length > 120 ? obs.narrative.slice(0, 117) + "..." : obs.narrative;
-    return `  ${snippet}`;
-  }
-  return "";
-}
-function parseFacts(facts) {
-  if (!facts)
-    return [];
-  try {
-    const parsed = JSON.parse(facts);
-    if (Array.isArray(parsed)) {
-      return parsed.filter((f) => typeof f === "string" && f.length > 0);
-    }
-  } catch {
-    if (facts.trim().length > 0) {
-      return [facts.trim()];
-    }
-  }
-  return [];
-}
-function toContextObservation(obs) {
-  return {
-    id: obs.id,
-    type: obs.type,
-    title: obs.title,
-    narrative: obs.narrative,
-    facts: obs.facts,
-    quality: obs.quality,
-    created_at: obs.created_at,
-    ...obs._source_project ? { source_project: obs._source_project } : {}
-  };
-}
+// src/storage/migrations.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    description: "Initial schema: projects, observations, sessions, sync, FTS5",
+    sql: `
+      -- Projects (canonical identity across machines)
+      CREATE TABLE projects (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          canonical_id    TEXT UNIQUE NOT NULL,
+          name            TEXT NOT NULL,
+          local_path      TEXT,
+          remote_url      TEXT,
+          first_seen_epoch INTEGER NOT NULL,
+          last_active_epoch INTEGER NOT NULL
+      );
+
+      -- Core observations table
+      CREATE TABLE observations (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT,
+          project_id      INTEGER NOT NULL REFERENCES projects(id),
+          type            TEXT NOT NULL CHECK (type IN (
+              'bugfix', 'discovery', 'decision', 'pattern',
+              'change', 'feature', 'refactor', 'digest'
+          )),
+          title           TEXT NOT NULL,
+          narrative       TEXT,
+          facts           TEXT,
+          concepts        TEXT,
+          files_read      TEXT,
+          files_modified  TEXT,
+          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
+          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
+              'active', 'aging', 'archived', 'purged', 'pinned'
+          )),
+          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
+              'shared', 'personal', 'secret'
+          )),
+          user_id         TEXT NOT NULL,
+          device_id       TEXT NOT NULL,
+          agent           TEXT DEFAULT 'claude-code',
+          created_at      TEXT NOT NULL,
+          created_at_epoch INTEGER NOT NULL,
+          archived_at_epoch INTEGER,
+          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL
+      );
+
+      -- Session tracking
+      CREATE TABLE sessions (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT UNIQUE NOT NULL,
+          project_id      INTEGER REFERENCES projects(id),
+          user_id         TEXT NOT NULL,
+          device_id       TEXT NOT NULL,
+          agent           TEXT DEFAULT 'claude-code',
+          status          TEXT DEFAULT 'active' CHECK (status IN ('active', 'completed')),
+          observation_count INTEGER DEFAULT 0,
+          started_at_epoch INTEGER,
+          completed_at_epoch INTEGER
+      );
+
+      -- Session summaries (generated on Stop hook)
+      CREATE TABLE session_summaries (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT UNIQUE NOT NULL,
+          project_id      INTEGER REFERENCES projects(id),
+          user_id         TEXT NOT NULL,
+          request         TEXT,
+          investigated    TEXT,
+          learned         TEXT,
+          completed       TEXT,
+          next_steps      TEXT,
+          created_at_epoch INTEGER
+      );
+
+      -- Sync outbox (offline-first queue)
+      CREATE TABLE sync_outbox (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          record_type     TEXT NOT NULL CHECK (record_type IN ('observation', 'summary')),
+          record_id       INTEGER NOT NULL,
+          status          TEXT DEFAULT 'pending' CHECK (status IN (
+              'pending', 'syncing', 'synced', 'failed'
+          )),
+          retry_count     INTEGER DEFAULT 0,
+          max_retries     INTEGER DEFAULT 10,
+          last_error      TEXT,
+          created_at_epoch INTEGER NOT NULL,
+          synced_at_epoch  INTEGER,
+          next_retry_epoch INTEGER
+      );
+
+      -- Sync high-water mark and lifecycle job tracking
+      CREATE TABLE sync_state (
+          key   TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+      );
+
+      -- FTS5 for local offline search (external content mode)
+      CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, narrative, facts, concepts,
+          content=observations,
+          content_rowid=id
+      );
 
-// src/telemetry/stack-detect.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join3, extname } from "node:path";
-var EXTENSION_MAP = {
-  ".tsx": "react",
-  ".jsx": "react",
-  ".ts": "typescript",
-  ".js": "javascript",
-  ".py": "python",
-  ".rs": "rust",
-  ".go": "go",
-  ".java": "java",
-  ".kt": "kotlin",
-  ".swift": "swift",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".zig": "zig",
-  ".ex": "elixir",
-  ".exs": "elixir",
-  ".erl": "erlang",
-  ".hs": "haskell",
-  ".lua": "lua",
-  ".dart": "dart",
-  ".scala": "scala",
-  ".clj": "clojure",
-  ".vue": "vue",
-  ".svelte": "svelte",
-  ".astro": "astro"
-};
-var CONFIG_FILE_STACKS = [
-  ["next.config.js", "nextjs"],
-  ["next.config.mjs", "nextjs"],
-  ["next.config.ts", "nextjs"],
-  ["nuxt.config.ts", "nuxt"],
-  ["nuxt.config.js", "nuxt"],
-  ["vite.config.ts", "vite"],
-  ["vite.config.js", "vite"],
-  ["vite.config.mjs", "vite"],
-  ["svelte.config.js", "svelte"],
-  ["astro.config.mjs", "astro"],
-  ["remix.config.js", "remix"],
-  ["angular.json", "angular"],
-  ["tailwind.config.js", "tailwind"],
-  ["tailwind.config.ts", "tailwind"],
-  ["postcss.config.js", "postcss"],
-  ["webpack.config.js", "webpack"],
-  ["tsconfig.json", "typescript"],
-  ["Cargo.toml", "rust"],
-  ["go.mod", "go"],
-  ["pyproject.toml", "python"],
-  ["setup.py", "python"],
-  ["requirements.txt", "python"],
-  ["Pipfile", "python"],
-  ["manage.py", "django"],
-  ["Gemfile", "ruby"],
-  ["composer.json", "php"],
-  ["pom.xml", "java"],
-  ["build.gradle", "gradle"],
-  ["build.gradle.kts", "gradle"],
-  ["Package.swift", "swift"],
-  ["pubspec.yaml", "flutter"],
-  ["mix.exs", "elixir"],
-  ["deno.json", "deno"],
-  ["bun.lock", "bun"],
-  ["bun.lockb", "bun"],
-  ["docker-compose.yml", "docker"],
-  ["docker-compose.yaml", "docker"],
-  ["Dockerfile", "docker"],
-  [".prisma/schema.prisma", "prisma"],
-  ["prisma/schema.prisma", "prisma"],
-  ["drizzle.config.ts", "drizzle"]
-];
-var PATH_PATTERN_STACKS = [
-  ["/__tests__/", "jest"],
-  ["/.storybook/", "storybook"],
-  ["/cypress/", "cypress"],
-  ["/playwright/", "playwright"],
-  ["/terraform/", "terraform"],
-  ["/k8s/", "kubernetes"],
-  ["/helm/", "helm"]
-];
-function detectStacks(filePaths) {
-  const stacks = new Set;
-  for (const fp of filePaths) {
-    const ext = extname(fp).toLowerCase();
-    if (ext && EXTENSION_MAP[ext]) {
-      stacks.add(EXTENSION_MAP[ext]);
-    }
-    for (const [pattern, stack] of PATH_PATTERN_STACKS) {
-      if (fp.includes(pattern)) {
-        stacks.add(stack);
-      }
-    }
-  }
-  return Array.from(stacks).sort();
-}
-function detectStacksFromProject(projectRoot, filePaths = []) {
-  const stacks = new Set(detectStacks(filePaths));
-  for (const [configFile, stack] of CONFIG_FILE_STACKS) {
-    try {
-      if (existsSync3(join3(projectRoot, configFile))) {
-        stacks.add(stack);
-      }
-    } catch {}
-  }
-  const sorted = Array.from(stacks).sort();
-  const frameworks = ["nextjs", "nuxt", "remix", "angular", "django", "flutter", "svelte", "astro"];
-  const primary = sorted.find((s) => frameworks.includes(s)) ?? sorted[0] ?? "unknown";
-  return { stacks: sorted, primary };
-}
+      -- Indexes: observations
+      CREATE INDEX idx_observations_project ON observations(project_id);
+      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
+      CREATE INDEX idx_observations_type ON observations(type);
+      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
+      CREATE INDEX idx_observations_session ON observations(session_id);
+      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
+      CREATE INDEX idx_observations_quality ON observations(quality);
+      CREATE INDEX idx_observations_user ON observations(user_id);
 
-// src/packs/recommender.ts
-import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync3 } from "node:fs";
-import { join as join4, basename as basename3, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-var STACK_PACK_MAP = {
-  typescript: ["typescript-patterns"],
-  react: ["react-gotchas"],
-  nextjs: ["nextjs-patterns"],
-  python: ["python-django"],
-  django: ["python-django"],
-  javascript: ["node-security"],
-  bun: ["node-security"]
-};
-function getPacksDir() {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
-  return join4(thisDir, "../../packs");
-}
-function listAvailablePacks() {
-  const dir = getPacksDir();
-  if (!existsSync4(dir))
-    return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => basename3(f, ".json"));
-}
-function loadPack(name) {
-  const packPath = join4(getPacksDir(), `${name}.json`);
-  if (!existsSync4(packPath))
-    return null;
-  try {
-    const raw = readFileSync3(packPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function recommendPacks(stacks, installedPacks) {
-  const installed = new Set(installedPacks);
-  const available = listAvailablePacks();
-  const availableSet = new Set(available);
-  const seen = new Set;
-  const recommendations = [];
-  for (const stack of stacks) {
-    const packNames = STACK_PACK_MAP[stack] ?? [];
-    for (const packName of packNames) {
-      if (seen.has(packName) || installed.has(packName) || !availableSet.has(packName)) {
-        continue;
-      }
-      seen.add(packName);
-      const pack = loadPack(packName);
-      if (!pack)
-        continue;
-      const matchedStacks = stacks.filter((s) => STACK_PACK_MAP[s]?.includes(packName));
-      recommendations.push({
-        name: packName,
-        description: pack.description,
-        observationCount: pack.observations.length,
-        matchedStacks
-      });
-    }
-  }
-  return recommendations;
-}
+      -- Indexes: sessions
+      CREATE INDEX idx_sessions_project ON sessions(project_id);
+
+      -- Indexes: sync outbox
+      CREATE INDEX idx_outbox_status ON sync_outbox(status, next_retry_epoch);
+      CREATE INDEX idx_outbox_record ON sync_outbox(record_type, record_id);
+    `
+  },
+  {
+    version: 2,
+    description: "Add superseded_by for knowledge supersession",
+    sql: `
+      ALTER TABLE observations ADD COLUMN superseded_by INTEGER REFERENCES observations(id) ON DELETE SET NULL;
+      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
+    `
+  },
+  {
+    version: 3,
+    description: "Add remote_source_id for pull deduplication",
+    sql: `
+      ALTER TABLE observations ADD COLUMN remote_source_id TEXT;
+      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
+    `
+  },
+  {
+    version: 4,
+    description: "Add sqlite-vec for local semantic search",
+    sql: `
+      CREATE VIRTUAL TABLE vec_observations USING vec0(
+        observation_id INTEGER PRIMARY KEY,
+        embedding float[384]
+      );
+    `,
+    condition: (db) => isVecExtensionLoaded(db)
+  },
+  {
+    version: 5,
+    description: "Session metrics and security findings",
+    sql: `
+      ALTER TABLE sessions ADD COLUMN files_touched_count INTEGER DEFAULT 0;
+      ALTER TABLE sessions ADD COLUMN searches_performed INTEGER DEFAULT 0;
+      ALTER TABLE sessions ADD COLUMN tool_calls_count INTEGER DEFAULT 0;
+
+      CREATE TABLE security_findings (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT,
+          project_id      INTEGER NOT NULL REFERENCES projects(id),
+          finding_type    TEXT NOT NULL,
+          severity        TEXT NOT NULL DEFAULT 'medium' CHECK (severity IN ('critical', 'high', 'medium', 'low')),
+          pattern_name    TEXT NOT NULL,
+          file_path       TEXT,
+          snippet         TEXT,
+          tool_name       TEXT,
+          user_id         TEXT NOT NULL,
+          device_id       TEXT NOT NULL,
+          created_at_epoch INTEGER NOT NULL
+      );
+
+      CREATE INDEX idx_security_findings_session ON security_findings(session_id);
+      CREATE INDEX idx_security_findings_project ON security_findings(project_id, created_at_epoch);
+      CREATE INDEX idx_security_findings_severity ON security_findings(severity);
+    `
+  },
+  {
+    version: 6,
+    description: "Add risk_score, expand observation types to include standard",
+    sql: `
+      ALTER TABLE sessions ADD COLUMN risk_score INTEGER;
+
+      -- Recreate observations table with expanded type CHECK to include 'standard'
+      -- SQLite doesn't support ALTER CHECK, so we recreate the table
+      CREATE TABLE observations_new (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT,
+          project_id      INTEGER NOT NULL REFERENCES projects(id),
+          type            TEXT NOT NULL CHECK (type IN (
+              'bugfix', 'discovery', 'decision', 'pattern',
+              'change', 'feature', 'refactor', 'digest', 'standard'
+          )),
+          title           TEXT NOT NULL,
+          narrative       TEXT,
+          facts           TEXT,
+          concepts        TEXT,
+          files_read      TEXT,
+          files_modified  TEXT,
+          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
+          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
+              'active', 'aging', 'archived', 'purged', 'pinned'
+          )),
+          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
+              'shared', 'personal', 'secret'
+          )),
+          user_id         TEXT NOT NULL,
+          device_id       TEXT NOT NULL,
+          agent           TEXT DEFAULT 'claude-code',
+          created_at      TEXT NOT NULL,
+          created_at_epoch INTEGER NOT NULL,
+          archived_at_epoch INTEGER,
+          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          superseded_by   INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          remote_source_id TEXT
+      );
 
-// src/config.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2, hostname as hostname2, networkInterfaces as networkInterfaces2 } from "node:os";
-import { join as join5 } from "node:path";
-import { createHash as createHash2 } from "node:crypto";
-var CONFIG_DIR2 = join5(homedir2(), ".engrm");
-var SETTINGS_PATH2 = join5(CONFIG_DIR2, "settings.json");
-var DB_PATH2 = join5(CONFIG_DIR2, "engrm.db");
-function getDbPath2() {
-  return DB_PATH2;
-}
-function generateDeviceId2() {
-  const host = hostname2().toLowerCase().replace(/[^a-z0-9-]/g, "");
-  let mac = "";
-  const ifaces = networkInterfaces2();
-  for (const entries of Object.values(ifaces)) {
-    if (!entries)
-      continue;
-    for (const entry of entries) {
-      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
-        mac = entry.mac;
-        break;
-      }
-    }
-    if (mac)
-      break;
-  }
-  const material = `${host}:${mac || "no-mac"}`;
-  const suffix = createHash2("sha256").update(material).digest("hex").slice(0, 8);
-  return `${host}-${suffix}`;
-}
-function createDefaultConfig2() {
-  return {
-    candengo_url: "",
-    candengo_api_key: "",
-    site_id: "",
-    namespace: "",
-    user_id: "",
-    user_email: "",
-    device_id: generateDeviceId2(),
-    teams: [],
-    sync: {
-      enabled: true,
-      interval_seconds: 30,
-      batch_size: 50
-    },
-    search: {
-      default_limit: 10,
-      local_boost: 1.2,
-      scope: "all"
-    },
-    scrubbing: {
-      enabled: true,
-      custom_patterns: [],
-      default_sensitivity: "shared"
-    },
-    sentinel: {
-      enabled: false,
-      mode: "advisory",
-      provider: "openai",
-      model: "gpt-4o-mini",
-      api_key: "",
-      base_url: "",
-      skip_patterns: [],
-      daily_limit: 100,
-      tier: "free"
-    },
-    observer: {
-      enabled: true,
-      mode: "per_event",
-      model: "sonnet"
-    },
-    transcript_analysis: {
-      enabled: false
-    }
-  };
-}
-function loadConfig2() {
-  if (!existsSync5(SETTINGS_PATH2)) {
-    throw new Error(`Config not found at ${SETTINGS_PATH2}. Run 'engrm init --manual' to configure.`);
-  }
-  const raw = readFileSync4(SETTINGS_PATH2, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${SETTINGS_PATH2}`);
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    throw new Error(`Config at ${SETTINGS_PATH2} is not a JSON object`);
-  }
-  const config = parsed;
-  const defaults = createDefaultConfig2();
-  return {
-    candengo_url: asString2(config["candengo_url"], defaults.candengo_url),
-    candengo_api_key: asString2(config["candengo_api_key"], defaults.candengo_api_key),
-    site_id: asString2(config["site_id"], defaults.site_id),
-    namespace: asString2(config["namespace"], defaults.namespace),
-    user_id: asString2(config["user_id"], defaults.user_id),
-    user_email: asString2(config["user_email"], defaults.user_email),
-    device_id: asString2(config["device_id"], defaults.device_id),
-    teams: asTeams2(config["teams"], defaults.teams),
-    sync: {
-      enabled: asBool2(config["sync"]?.["enabled"], defaults.sync.enabled),
-      interval_seconds: asNumber2(config["sync"]?.["interval_seconds"], defaults.sync.interval_seconds),
-      batch_size: asNumber2(config["sync"]?.["batch_size"], defaults.sync.batch_size)
-    },
-    search: {
-      default_limit: asNumber2(config["search"]?.["default_limit"], defaults.search.default_limit),
-      local_boost: asNumber2(config["search"]?.["local_boost"], defaults.search.local_boost),
-      scope: asScope2(config["search"]?.["scope"], defaults.search.scope)
-    },
-    scrubbing: {
-      enabled: asBool2(config["scrubbing"]?.["enabled"], defaults.scrubbing.enabled),
-      custom_patterns: asStringArray2(config["scrubbing"]?.["custom_patterns"], defaults.scrubbing.custom_patterns),
-      default_sensitivity: asSensitivity2(config["scrubbing"]?.["default_sensitivity"], defaults.scrubbing.default_sensitivity)
-    },
-    sentinel: {
-      enabled: asBool2(config["sentinel"]?.["enabled"], defaults.sentinel.enabled),
-      mode: asSentinelMode2(config["sentinel"]?.["mode"], defaults.sentinel.mode),
-      provider: asLlmProvider2(config["sentinel"]?.["provider"], defaults.sentinel.provider),
-      model: asString2(config["sentinel"]?.["model"], defaults.sentinel.model),
-      api_key: asString2(config["sentinel"]?.["api_key"], defaults.sentinel.api_key),
-      base_url: asString2(config["sentinel"]?.["base_url"], defaults.sentinel.base_url),
-      skip_patterns: asStringArray2(config["sentinel"]?.["skip_patterns"], defaults.sentinel.skip_patterns),
-      daily_limit: asNumber2(config["sentinel"]?.["daily_limit"], defaults.sentinel.daily_limit),
-      tier: asTier2(config["sentinel"]?.["tier"], defaults.sentinel.tier)
-    },
-    observer: {
-      enabled: asBool2(config["observer"]?.["enabled"], defaults.observer.enabled),
-      mode: asObserverMode2(config["observer"]?.["mode"], defaults.observer.mode),
-      model: asString2(config["observer"]?.["model"], defaults.observer.model)
-    },
-    transcript_analysis: {
-      enabled: asBool2(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
-    }
-  };
-}
-function saveConfig(config) {
-  if (!existsSync5(CONFIG_DIR2)) {
-    mkdirSync2(CONFIG_DIR2, { recursive: true });
-  }
-  writeFileSync2(SETTINGS_PATH2, JSON.stringify(config, null, 2) + `
-`, "utf-8");
-}
-function configExists2() {
-  return existsSync5(SETTINGS_PATH2);
-}
-function asString2(value, fallback) {
-  return typeof value === "string" ? value : fallback;
-}
-function asNumber2(value, fallback) {
-  return typeof value === "number" && !Number.isNaN(value) ? value : fallback;
-}
-function asBool2(value, fallback) {
-  return typeof value === "boolean" ? value : fallback;
-}
-function asStringArray2(value, fallback) {
-  return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : fallback;
-}
-function asScope2(value, fallback) {
-  if (value === "personal" || value === "team" || value === "all")
-    return value;
-  return fallback;
-}
-function asSensitivity2(value, fallback) {
-  if (value === "shared" || value === "personal" || value === "secret")
-    return value;
-  return fallback;
-}
-function asSentinelMode2(value, fallback) {
-  if (value === "advisory" || value === "blocking")
-    return value;
-  return fallback;
-}
-function asLlmProvider2(value, fallback) {
-  if (value === "openai" || value === "anthropic" || value === "ollama" || value === "custom")
-    return value;
-  return fallback;
-}
-function asTier2(value, fallback) {
-  if (value === "free" || value === "vibe" || value === "solo" || value === "pro" || value === "team" || value === "enterprise")
-    return value;
-  return fallback;
-}
-function asObserverMode2(value, fallback) {
-  if (value === "per_event" || value === "per_session")
-    return value;
-  return fallback;
-}
-function asTeams2(value, fallback) {
-  if (!Array.isArray(value))
-    return fallback;
-  return value.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string" && typeof t.name === "string" && typeof t.namespace === "string");
-}
+      INSERT INTO observations_new SELECT * FROM observations;
 
-// src/sync/auth.ts
-function getApiKey(config) {
-  const envKey = process.env.ENGRM_TOKEN;
-  if (envKey && envKey.startsWith("cvk_"))
-    return envKey;
-  if (config.candengo_api_key && config.candengo_api_key.length > 0) {
-    return config.candengo_api_key;
-  }
-  return null;
-}
-function getBaseUrl(config) {
-  if (config.candengo_url && config.candengo_url.length > 0) {
-    return config.candengo_url;
+      DROP TABLE observations;
+      ALTER TABLE observations_new RENAME TO observations;
+
+      -- Recreate indexes
+      CREATE INDEX idx_observations_project ON observations(project_id);
+      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
+      CREATE INDEX idx_observations_type ON observations(type);
+      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
+      CREATE INDEX idx_observations_session ON observations(session_id);
+      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
+      CREATE INDEX idx_observations_quality ON observations(quality);
+      CREATE INDEX idx_observations_user ON observations(user_id);
+      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
+      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
+
+      -- Recreate FTS5 (external content mode — must rebuild after table recreation)
+      DROP TABLE IF EXISTS observations_fts;
+      CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, narrative, facts, concepts,
+          content=observations,
+          content_rowid=id
+      );
+      -- Rebuild FTS index
+      INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
+    `
+  },
+  {
+    version: 7,
+    description: "Add packs_installed table for help pack tracking",
+    sql: `
+      CREATE TABLE IF NOT EXISTS packs_installed (
+          name            TEXT PRIMARY KEY,
+          installed_at    INTEGER NOT NULL,
+          observation_count INTEGER DEFAULT 0
+      );
+    `
+  },
+  {
+    version: 8,
+    description: "Add message type to observations CHECK constraint",
+    sql: `
+      CREATE TABLE IF NOT EXISTS observations_v8 (
+          id              INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id      TEXT,
+          project_id      INTEGER NOT NULL REFERENCES projects(id),
+          type            TEXT NOT NULL CHECK (type IN (
+              'bugfix', 'discovery', 'decision', 'pattern',
+              'change', 'feature', 'refactor', 'digest', 'standard', 'message'
+          )),
+          title           TEXT NOT NULL,
+          narrative       TEXT,
+          facts           TEXT,
+          concepts        TEXT,
+          files_read      TEXT,
+          files_modified  TEXT,
+          quality         REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
+          lifecycle       TEXT DEFAULT 'active' CHECK (lifecycle IN (
+              'active', 'aging', 'archived', 'purged', 'pinned'
+          )),
+          sensitivity     TEXT DEFAULT 'shared' CHECK (sensitivity IN (
+              'shared', 'personal', 'secret'
+          )),
+          user_id         TEXT NOT NULL,
+          device_id       TEXT NOT NULL,
+          agent           TEXT DEFAULT 'claude-code',
+          created_at      TEXT NOT NULL,
+          created_at_epoch INTEGER NOT NULL,
+          archived_at_epoch INTEGER,
+          compacted_into  INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          superseded_by   INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          remote_source_id TEXT
+      );
+      INSERT INTO observations_v8 SELECT * FROM observations;
+      DROP TABLE observations;
+      ALTER TABLE observations_v8 RENAME TO observations;
+      CREATE INDEX idx_observations_project ON observations(project_id);
+      CREATE INDEX idx_observations_project_lifecycle ON observations(project_id, lifecycle);
+      CREATE INDEX idx_observations_type ON observations(type);
+      CREATE INDEX idx_observations_created ON observations(created_at_epoch);
+      CREATE INDEX idx_observations_session ON observations(session_id);
+      CREATE INDEX idx_observations_lifecycle ON observations(lifecycle);
+      CREATE INDEX idx_observations_quality ON observations(quality);
+      CREATE INDEX idx_observations_user ON observations(user_id);
+      CREATE INDEX idx_observations_superseded ON observations(superseded_by);
+      CREATE UNIQUE INDEX idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
+      DROP TABLE IF EXISTS observations_fts;
+      CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, narrative, facts, concepts,
+          content=observations,
+          content_rowid=id
+      );
+      INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
+    `
   }
-  return null;
-}
-function buildSourceId(config, localId, type = "obs") {
-  return `${config.user_id}-${config.device_id}-${type}-${localId}`;
-}
-function parseSourceId(sourceId) {
-  const obsIndex = sourceId.lastIndexOf("-obs-");
-  if (obsIndex === -1)
-    return null;
-  const prefix = sourceId.slice(0, obsIndex);
-  const localIdStr = sourceId.slice(obsIndex + 5);
-  const localId = parseInt(localIdStr, 10);
-  if (isNaN(localId))
-    return null;
-  const firstDash = prefix.indexOf("-");
-  if (firstDash === -1)
-    return null;
-  return {
-    userId: prefix.slice(0, firstDash),
-    deviceId: prefix.slice(firstDash + 1),
-    localId
-  };
-}
-
-// src/embeddings/embedder.ts
-var _available = null;
-var _pipeline = null;
-var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
-async function embedText(text) {
-  const pipe = await getPipeline();
-  if (!pipe)
-    return null;
+];
+function isVecExtensionLoaded(db) {
   try {
-    const output = await pipe(text, { pooling: "mean", normalize: true });
-    return new Float32Array(output.data);
+    db.exec("SELECT vec_version()");
+    return true;
   } catch {
-    return null;
+    return false;
   }
 }
-function composeEmbeddingText(obs) {
-  const parts = [obs.title];
-  if (obs.narrative)
-    parts.push(obs.narrative);
-  if (obs.facts) {
-    try {
-      const facts = JSON.parse(obs.facts);
-      if (Array.isArray(facts) && facts.length > 0) {
-        parts.push(facts.map((f) => `- ${f}`).join(`
-`));
-      }
-    } catch {
-      parts.push(obs.facts);
+function runMigrations(db) {
+  const currentVersion = db.query("PRAGMA user_version").get();
+  let version = currentVersion.user_version;
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= version)
+      continue;
+    if (migration.condition && !migration.condition(db)) {
+      continue;
     }
-  }
-  if (obs.concepts) {
+    db.exec("BEGIN TRANSACTION");
     try {
-      const concepts = JSON.parse(obs.concepts);
-      if (Array.isArray(concepts) && concepts.length > 0) {
-        parts.push(concepts.join(", "));
-      }
-    } catch {}
+      db.exec(migration.sql);
+      db.exec(`PRAGMA user_version = ${migration.version}`);
+      db.exec("COMMIT");
+      version = migration.version;
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw new Error(`Migration ${migration.version} (${migration.description}) failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  return parts.join(`
-
-`);
 }
-async function getPipeline() {
-  if (_pipeline)
-    return _pipeline;
-  if (_available === false)
-    return null;
+function ensureObservationTypes(db) {
   try {
-    const { pipeline } = await import("@xenova/transformers");
-    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
-    _available = true;
-    return _pipeline;
-  } catch (err) {
-    _available = false;
-    console.error(`[engrm] Local embedding model unavailable: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
+    db.exec("INSERT INTO observations (session_id, project_id, type, title, user_id, device_id, agent, created_at, created_at_epoch) " + "VALUES ('_typecheck', 1, 'message', '_test', '_test', '_test', '_test', '2000-01-01', 0)");
+    db.exec("DELETE FROM observations WHERE session_id = '_typecheck'");
+  } catch {
+    db.exec("BEGIN TRANSACTION");
+    try {
+      db.exec(`
+        CREATE TABLE observations_repair (
+          id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT,
+          project_id INTEGER NOT NULL REFERENCES projects(id),
+          type TEXT NOT NULL CHECK (type IN (
+            'bugfix','discovery','decision','pattern','change','feature',
+            'refactor','digest','standard','message')),
+          title TEXT NOT NULL, narrative TEXT, facts TEXT, concepts TEXT,
+          files_read TEXT, files_modified TEXT,
+          quality REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
+          lifecycle TEXT DEFAULT 'active' CHECK (lifecycle IN ('active','aging','archived','purged','pinned')),
+          sensitivity TEXT DEFAULT 'shared' CHECK (sensitivity IN ('shared','personal','secret')),
+          user_id TEXT NOT NULL, device_id TEXT NOT NULL, agent TEXT DEFAULT 'claude-code',
+          created_at TEXT NOT NULL, created_at_epoch INTEGER NOT NULL,
+          archived_at_epoch INTEGER,
+          compacted_into INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          superseded_by INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          remote_source_id TEXT
+        );
+        INSERT INTO observations_repair SELECT * FROM observations;
+        DROP TABLE observations;
+        ALTER TABLE observations_repair RENAME TO observations;
+        CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+        CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch);
+        CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_lifecycle ON observations(lifecycle);
+        CREATE INDEX IF NOT EXISTS idx_observations_quality ON observations(quality);
+        CREATE INDEX IF NOT EXISTS idx_observations_user ON observations(user_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_superseded ON observations(superseded_by);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
+        DROP TABLE IF EXISTS observations_fts;
+        CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, narrative, facts, concepts, content=observations, content_rowid=id
+        );
+        INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
+      `);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+    }
   }
 }
+var LATEST_SCHEMA_VERSION = MIGRATIONS.filter((m) => !m.condition).reduce((max, m) => Math.max(max, m.version), 0);
 
-// src/sync/pull.ts
-var PULL_CURSOR_KEY = "pull_cursor";
-var MAX_PAGES = 20;
-async function pullFromVector(db, client, config, limit = 50) {
-  let cursor = db.getSyncState(PULL_CURSOR_KEY) ?? undefined;
-  let totalReceived = 0;
-  let totalMerged = 0;
-  let totalSkipped = 0;
-  for (let page = 0;page < MAX_PAGES; page++) {
-    const response = await client.pullChanges(cursor, limit);
-    const { merged, skipped } = mergeChanges(db, config, response.changes);
-    totalReceived += response.changes.length;
-    totalMerged += merged;
-    totalSkipped += skipped;
-    if (response.cursor) {
-      db.setSyncState(PULL_CURSOR_KEY, response.cursor);
-      cursor = response.cursor;
+// src/storage/sqlite.ts
+var IS_BUN = typeof globalThis.Bun !== "undefined";
+function openDatabase(dbPath) {
+  if (IS_BUN) {
+    return openBunDatabase(dbPath);
+  }
+  return openNodeDatabase(dbPath);
+}
+function openBunDatabase(dbPath) {
+  const { Database } = __require("bun:sqlite");
+  if (process.platform === "darwin") {
+    const { existsSync: existsSync6 } = __require("node:fs");
+    const paths = [
+      "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib",
+      "/usr/local/opt/sqlite3/lib/libsqlite3.dylib"
+    ];
+    for (const p of paths) {
+      if (existsSync6(p)) {
+        try {
+          Database.setCustomSQLite(p);
+        } catch {}
+        break;
+      }
     }
-    if (!response.has_more || response.changes.length === 0)
-      break;
   }
-  return { received: totalReceived, merged: totalMerged, skipped: totalSkipped };
+  const db = new Database(dbPath);
+  return db;
 }
-function mergeChanges(db, config, changes) {
-  let merged = 0;
-  let skipped = 0;
-  for (const change of changes) {
-    const parsed = parseSourceId(change.source_id);
-    if (parsed && parsed.deviceId === config.device_id) {
-      skipped++;
-      continue;
+function openNodeDatabase(dbPath) {
+  const BetterSqlite3 = __require("better-sqlite3");
+  const raw = new BetterSqlite3(dbPath);
+  return {
+    query(sql) {
+      const stmt = raw.prepare(sql);
+      return {
+        get(...params) {
+          return stmt.get(...params);
+        },
+        all(...params) {
+          return stmt.all(...params);
+        },
+        run(...params) {
+          return stmt.run(...params);
+        }
+      };
+    },
+    exec(sql) {
+      raw.exec(sql);
+    },
+    close() {
+      raw.close();
     }
-    const existing = db.db.query("SELECT id FROM observations WHERE remote_source_id = ?").get(change.source_id);
-    if (existing) {
-      skipped++;
-      continue;
+  };
+}
+
+class MemDatabase {
+  db;
+  vecAvailable;
+  constructor(dbPath) {
+    this.db = openDatabase(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.vecAvailable = this.loadVecExtension();
+    runMigrations(this.db);
+    ensureObservationTypes(this.db);
+  }
+  loadVecExtension() {
+    try {
+      const sqliteVec = __require("sqlite-vec");
+      sqliteVec.load(this.db);
+      return true;
+    } catch {
+      return false;
     }
-    const projectCanonical = change.metadata?.project_canonical ?? null;
-    if (!projectCanonical) {
-      skipped++;
-      continue;
+  }
+  close() {
+    this.db.close();
+  }
+  upsertProject(project) {
+    const now = Math.floor(Date.now() / 1000);
+    const existing = this.db.query("SELECT * FROM projects WHERE canonical_id = ?").get(project.canonical_id);
+    if (existing) {
+      this.db.query(`UPDATE projects SET
+            local_path = COALESCE(?, local_path),
+            remote_url = COALESCE(?, remote_url),
+            last_active_epoch = ?
+          WHERE id = ?`).run(project.local_path ?? null, project.remote_url ?? null, now, existing.id);
+      return {
+        ...existing,
+        local_path: project.local_path ?? existing.local_path,
+        remote_url: project.remote_url ?? existing.remote_url,
+        last_active_epoch: now
+      };
     }
-    let project = db.getProjectByCanonicalId(projectCanonical);
-    if (!project) {
-      project = db.upsertProject({
-        canonical_id: projectCanonical,
-        name: change.metadata?.project_name ?? projectCanonical.split("/").pop() ?? "unknown"
-      });
+    const result = this.db.query(`INSERT INTO projects (canonical_id, name, local_path, remote_url, first_seen_epoch, last_active_epoch)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(project.canonical_id, project.name, project.local_path ?? null, project.remote_url ?? null, now, now);
+    return this.db.query("SELECT * FROM projects WHERE id = ?").get(Number(result.lastInsertRowid));
+  }
+  getProjectByCanonicalId(canonicalId) {
+    return this.db.query("SELECT * FROM projects WHERE canonical_id = ?").get(canonicalId) ?? null;
+  }
+  getProjectById(id) {
+    return this.db.query("SELECT * FROM projects WHERE id = ?").get(id) ?? null;
+  }
+  insertObservation(obs) {
+    const now = obs.created_at_epoch ?? Math.floor(Date.now() / 1000);
+    const createdAt = obs.created_at ?? new Date(now * 1000).toISOString();
+    const result = this.db.query(`INSERT INTO observations (
+          session_id, project_id, type, title, narrative, facts, concepts,
+          files_read, files_modified, quality, lifecycle, sensitivity,
+          user_id, device_id, agent, created_at, created_at_epoch
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(obs.session_id ?? null, obs.project_id, obs.type, obs.title, obs.narrative ?? null, obs.facts ?? null, obs.concepts ?? null, obs.files_read ?? null, obs.files_modified ?? null, obs.quality, obs.lifecycle ?? "active", obs.sensitivity ?? "shared", obs.user_id, obs.device_id, obs.agent ?? "claude-code", createdAt, now);
+    const id = Number(result.lastInsertRowid);
+    const row = this.getObservationById(id);
+    this.ftsInsert(row);
+    if (obs.session_id) {
+      this.db.query("UPDATE sessions SET observation_count = observation_count + 1 WHERE session_id = ?").run(obs.session_id);
     }
-    const obs = db.insertObservation({
-      session_id: change.metadata?.session_id ?? null,
-      project_id: project.id,
-      type: change.metadata?.type ?? "discovery",
-      title: change.metadata?.title ?? change.content.split(`
-`)[0] ?? "Untitled",
-      narrative: extractNarrative(change.content),
-      facts: change.metadata?.facts ? JSON.stringify(change.metadata.facts) : null,
-      concepts: change.metadata?.concepts ? JSON.stringify(change.metadata.concepts) : null,
-      quality: change.metadata?.quality ?? 0.5,
-      lifecycle: "active",
-      sensitivity: "shared",
-      user_id: change.metadata?.user_id ?? "unknown",
-      device_id: change.metadata?.device_id ?? "unknown",
-      agent: change.metadata?.agent ?? "unknown"
-    });
-    db.db.query("UPDATE observations SET remote_source_id = ? WHERE id = ?").run(change.source_id, obs.id);
-    if (db.vecAvailable) {
-      embedAndInsert(db, obs).catch(() => {});
+    return row;
+  }
+  getObservationById(id) {
+    return this.db.query("SELECT * FROM observations WHERE id = ?").get(id) ?? null;
+  }
+  getObservationsByIds(ids, userId) {
+    if (ids.length === 0)
+      return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const visibilityClause = userId ? " AND (sensitivity != 'personal' OR user_id = ?)" : "";
+    return this.db.query(`SELECT * FROM observations
+         WHERE id IN (${placeholders})${visibilityClause}
+         ORDER BY created_at_epoch DESC`).all(...ids, ...userId ? [userId] : []);
+  }
+  getRecentObservations(projectId, sincEpoch, limit = 50) {
+    return this.db.query(`SELECT * FROM observations
+        WHERE project_id = ? AND created_at_epoch > ?
+        ORDER BY created_at_epoch DESC
+        LIMIT ?`).all(projectId, sincEpoch, limit);
+  }
+  searchFts(query, projectId, lifecycles = ["active", "aging", "pinned"], limit = 20, userId) {
+    const lifecyclePlaceholders = lifecycles.map(() => "?").join(",");
+    const visibilityClause = userId ? " AND (o.sensitivity != 'personal' OR o.user_id = ?)" : "";
+    if (projectId !== null) {
+      return this.db.query(`SELECT o.id, observations_fts.rank
+          FROM observations_fts
+          JOIN observations o ON o.id = observations_fts.rowid
+          WHERE observations_fts MATCH ?
+            AND o.project_id = ?
+            AND o.lifecycle IN (${lifecyclePlaceholders})
+            ${visibilityClause}
+          ORDER BY observations_fts.rank
+          LIMIT ?`).all(query, projectId, ...lifecycles, ...userId ? [userId] : [], limit);
     }
-    merged++;
+    return this.db.query(`SELECT o.id, observations_fts.rank
+        FROM observations_fts
+        JOIN observations o ON o.id = observations_fts.rowid
+        WHERE observations_fts MATCH ?
+          AND o.lifecycle IN (${lifecyclePlaceholders})
+          ${visibilityClause}
+        ORDER BY observations_fts.rank
+        LIMIT ?`).all(query, ...lifecycles, ...userId ? [userId] : [], limit);
   }
-  return { merged, skipped };
-}
-async function embedAndInsert(db, obs) {
-  const text = composeEmbeddingText(obs);
-  const embedding = await embedText(text);
-  if (embedding)
-    db.vecInsert(obs.id, embedding);
-}
-function extractNarrative(content) {
-  const lines = content.split(`
-`);
-  if (lines.length <= 1)
-    return null;
-  const narrative = lines.slice(1).join(`
-`).trim();
-  return narrative.length > 0 ? narrative : null;
-}
-async function pullSettings(client, config) {
-  try {
-    const settings = await client.fetchSettings();
-    if (!settings)
+  getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3, userId) {
+    const visibilityClause = userId ? " AND (sensitivity != 'personal' OR user_id = ?)" : "";
+    const anchor = this.db.query(`SELECT * FROM observations WHERE id = ?${visibilityClause}`).get(anchorId, ...userId ? [userId] : []) ?? null;
+    if (!anchor)
+      return [];
+    const projectFilter = projectId !== null ? "AND project_id = ?" : "";
+    const projectParams = projectId !== null ? [projectId] : [];
+    const visibilityParams = userId ? [userId] : [];
+    const before = this.db.query(`SELECT * FROM observations
+        WHERE created_at_epoch < ? ${projectFilter}
+          AND lifecycle IN ('active', 'aging', 'pinned')
+          ${visibilityClause}
+        ORDER BY created_at_epoch DESC
+        LIMIT ?`).all(anchor.created_at_epoch, ...projectParams, ...visibilityParams, depthBefore);
+    const after = this.db.query(`SELECT * FROM observations
+        WHERE created_at_epoch > ? ${projectFilter}
+          AND lifecycle IN ('active', 'aging', 'pinned')
+          ${visibilityClause}
+        ORDER BY created_at_epoch ASC
+        LIMIT ?`).all(anchor.created_at_epoch, ...projectParams, ...visibilityParams, depthAfter);
+    return [...before.reverse(), anchor, ...after];
+  }
+  pinObservation(id, pinned) {
+    const obs = this.getObservationById(id);
+    if (!obs)
       return false;
-    let changed = false;
-    if (settings.transcript_analysis !== undefined) {
-      const ta = settings.transcript_analysis;
-      if (typeof ta === "object" && ta !== null) {
-        const taObj = ta;
-        if (taObj.enabled !== undefined && taObj.enabled !== config.transcript_analysis.enabled) {
-          config.transcript_analysis.enabled = !!taObj.enabled;
-          changed = true;
-        }
-      }
-    }
-    if (settings.observer !== undefined) {
-      const obs = settings.observer;
-      if (typeof obs === "object" && obs !== null) {
-        const obsObj = obs;
-        if (obsObj.enabled !== undefined && obsObj.enabled !== config.observer.enabled) {
-          config.observer.enabled = !!obsObj.enabled;
-          changed = true;
-        }
-        if (obsObj.model !== undefined && typeof obsObj.model === "string" && obsObj.model !== config.observer.model) {
-          config.observer.model = obsObj.model;
-          changed = true;
-        }
-      }
+    if (pinned) {
+      if (obs.lifecycle !== "active" && obs.lifecycle !== "aging")
+        return false;
+      this.db.query("UPDATE observations SET lifecycle = 'pinned' WHERE id = ?").run(id);
+    } else {
+      if (obs.lifecycle !== "pinned")
+        return false;
+      this.db.query("UPDATE observations SET lifecycle = 'active' WHERE id = ?").run(id);
     }
-    if (changed) {
-      saveConfig(config);
+    return true;
+  }
+  getActiveObservationCount(userId) {
+    if (userId) {
+      const result2 = this.db.query(`SELECT COUNT(*) as count FROM observations
+          WHERE lifecycle IN ('active', 'aging')
+            AND sensitivity != 'secret'
+            AND user_id = ?`).get(userId);
+      return result2?.count ?? 0;
     }
-    return changed;
-  } catch {
-    return false;
+    const result = this.db.query(`SELECT COUNT(*) as count FROM observations
+        WHERE lifecycle IN ('active', 'aging')
+          AND sensitivity != 'secret'`).get();
+    return result?.count ?? 0;
   }
-}
-
-// src/sync/client.ts
-class VectorClient {
-  baseUrl;
-  apiKey;
-  siteId;
-  namespace;
-  constructor(config) {
-    const baseUrl = getBaseUrl(config);
-    const apiKey = getApiKey(config);
-    if (!baseUrl || !apiKey) {
-      throw new Error("VectorClient requires candengo_url and candengo_api_key");
+  supersedeObservation(oldId, newId) {
+    if (oldId === newId)
+      return false;
+    const replacement = this.getObservationById(newId);
+    if (!replacement)
+      return false;
+    let targetId = oldId;
+    const visited = new Set;
+    for (let depth = 0;depth < 10; depth++) {
+      const target2 = this.getObservationById(targetId);
+      if (!target2)
+        return false;
+      if (target2.superseded_by === null)
+        break;
+      if (target2.superseded_by === newId)
+        return true;
+      visited.add(targetId);
+      targetId = target2.superseded_by;
+      if (visited.has(targetId))
+        return false;
     }
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.apiKey = apiKey;
-    this.siteId = config.site_id;
-    this.namespace = config.namespace;
+    const target = this.getObservationById(targetId);
+    if (!target)
+      return false;
+    if (target.superseded_by !== null)
+      return false;
+    if (targetId === newId)
+      return false;
+    const now = Math.floor(Date.now() / 1000);
+    this.db.query(`UPDATE observations
+         SET superseded_by = ?, lifecycle = 'archived', archived_at_epoch = ?
+         WHERE id = ?`).run(newId, now, targetId);
+    this.ftsDelete(target);
+    this.vecDelete(targetId);
+    return true;
+  }
+  isSuperseded(id) {
+    const obs = this.getObservationById(id);
+    return obs !== null && obs.superseded_by !== null;
+  }
+  upsertSession(sessionId, projectId, userId, deviceId, agent = "claude-code") {
+    const existing = this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+    if (existing)
+      return existing;
+    const now = Math.floor(Date.now() / 1000);
+    this.db.query(`INSERT INTO sessions (session_id, project_id, user_id, device_id, agent, started_at_epoch)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(sessionId, projectId, userId, deviceId, agent, now);
+    return this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+  }
+  completeSession(sessionId) {
+    const now = Math.floor(Date.now() / 1000);
+    this.db.query("UPDATE sessions SET status = 'completed', completed_at_epoch = ? WHERE session_id = ?").run(now, sessionId);
+  }
+  addToOutbox(recordType, recordId) {
+    const now = Math.floor(Date.now() / 1000);
+    this.db.query(`INSERT INTO sync_outbox (record_type, record_id, created_at_epoch)
+        VALUES (?, ?, ?)`).run(recordType, recordId, now);
+  }
+  getSyncState(key) {
+    const row = this.db.query("SELECT value FROM sync_state WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setSyncState(key, value) {
+    this.db.query("INSERT INTO sync_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = ?").run(key, value, value);
   }
-  static isConfigured(config) {
-    return getApiKey(config) !== null && getBaseUrl(config) !== null;
+  ftsInsert(obs) {
+    this.db.query(`INSERT INTO observations_fts (rowid, title, narrative, facts, concepts)
+        VALUES (?, ?, ?, ?, ?)`).run(obs.id, obs.title, obs.narrative, obs.facts, obs.concepts);
   }
-  async ingest(doc) {
-    await this.request("POST", "/v1/ingest", doc);
+  ftsDelete(obs) {
+    this.db.query(`INSERT INTO observations_fts (observations_fts, rowid, title, narrative, facts, concepts)
+        VALUES ('delete', ?, ?, ?, ?, ?)`).run(obs.id, obs.title, obs.narrative, obs.facts, obs.concepts);
   }
-  async batchIngest(docs) {
-    if (docs.length === 0)
+  vecInsert(observationId, embedding) {
+    if (!this.vecAvailable)
       return;
-    await this.request("POST", "/v1/ingest/batch", { documents: docs });
+    this.db.query("INSERT OR REPLACE INTO vec_observations (observation_id, embedding) VALUES (?, ?)").run(observationId, new Uint8Array(embedding.buffer));
   }
-  async search(query, metadataFilter, limit = 10) {
-    const body = { query, limit };
-    if (metadataFilter) {
-      body.metadata_filter = metadataFilter;
+  vecDelete(observationId) {
+    if (!this.vecAvailable)
+      return;
+    this.db.query("DELETE FROM vec_observations WHERE observation_id = ?").run(observationId);
+  }
+  searchVec(queryEmbedding, projectId, lifecycles = ["active", "aging", "pinned"], limit = 20, userId) {
+    if (!this.vecAvailable)
+      return [];
+    const lifecyclePlaceholders = lifecycles.map(() => "?").join(",");
+    const embeddingBlob = new Uint8Array(queryEmbedding.buffer);
+    const visibilityClause = userId ? " AND (o.sensitivity != 'personal' OR o.user_id = ?)" : "";
+    if (projectId !== null) {
+      return this.db.query(`SELECT v.observation_id, v.distance
+           FROM vec_observations v
+           JOIN observations o ON o.id = v.observation_id
+           WHERE v.embedding MATCH ?
+             AND k = ?
+             AND o.project_id = ?
+             AND o.lifecycle IN (${lifecyclePlaceholders})
+             AND o.superseded_by IS NULL` + visibilityClause).all(embeddingBlob, limit, projectId, ...lifecycles, ...userId ? [userId] : []);
     }
-    return this.request("POST", "/v1/search", body);
+    return this.db.query(`SELECT v.observation_id, v.distance
+         FROM vec_observations v
+         JOIN observations o ON o.id = v.observation_id
+         WHERE v.embedding MATCH ?
+           AND k = ?
+           AND o.lifecycle IN (${lifecyclePlaceholders})
+           AND o.superseded_by IS NULL` + visibilityClause).all(embeddingBlob, limit, ...lifecycles, ...userId ? [userId] : []);
   }
-  async deleteBySourceIds(sourceIds) {
-    if (sourceIds.length === 0)
-      return;
-    await this.request("POST", "/v1/documents/delete", {
-      source_ids: sourceIds
-    });
+  getUnembeddedCount() {
+    if (!this.vecAvailable)
+      return 0;
+    const result = this.db.query(`SELECT COUNT(*) as count FROM observations o
+         WHERE o.lifecycle IN ('active', 'aging', 'pinned')
+         AND o.superseded_by IS NULL
+         AND NOT EXISTS (
+           SELECT 1 FROM vec_observations v WHERE v.observation_id = o.id
+         )`).get();
+    return result?.count ?? 0;
   }
-  async pullChanges(cursor, limit = 50) {
-    const params = new URLSearchParams;
-    if (cursor)
-      params.set("cursor", cursor);
-    params.set("namespace", this.namespace);
-    params.set("limit", String(limit));
-    return this.request("GET", `/v1/sync/changes?${params.toString()}`);
+  getUnembeddedObservations(limit = 100) {
+    if (!this.vecAvailable)
+      return [];
+    return this.db.query(`SELECT o.* FROM observations o
+         WHERE o.lifecycle IN ('active', 'aging', 'pinned')
+         AND o.superseded_by IS NULL
+         AND NOT EXISTS (
+           SELECT 1 FROM vec_observations v WHERE v.observation_id = o.id
+         )
+         ORDER BY o.created_at_epoch DESC
+         LIMIT ?`).all(limit);
   }
-  async sendTelemetry(beacon) {
-    await this.request("POST", "/v1/mem/telemetry", beacon);
+  insertSessionSummary(summary) {
+    const now = Math.floor(Date.now() / 1000);
+    const result = this.db.query(`INSERT INTO session_summaries (session_id, project_id, user_id, request, investigated, learned, completed, next_steps, created_at_epoch)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(summary.session_id, summary.project_id, summary.user_id, summary.request, summary.investigated, summary.learned, summary.completed, summary.next_steps, now);
+    const id = Number(result.lastInsertRowid);
+    return this.db.query("SELECT * FROM session_summaries WHERE id = ?").get(id);
   }
-  async fetchSettings() {
-    try {
-      return await this.request("GET", "/v1/mem/user-settings");
-    } catch {
-      return null;
+  getSessionSummary(sessionId) {
+    return this.db.query("SELECT * FROM session_summaries WHERE session_id = ?").get(sessionId) ?? null;
+  }
+  getRecentSummaries(projectId, limit = 5) {
+    return this.db.query(`SELECT * FROM session_summaries
+         WHERE project_id = ?
+         ORDER BY created_at_epoch DESC, id DESC
+         LIMIT ?`).all(projectId, limit);
+  }
+  incrementSessionMetrics(sessionId, increments) {
+    const sets = [];
+    const params = [];
+    if (increments.files) {
+      sets.push("files_touched_count = files_touched_count + ?");
+      params.push(increments.files);
+    }
+    if (increments.searches) {
+      sets.push("searches_performed = searches_performed + ?");
+      params.push(increments.searches);
     }
+    if (increments.toolCalls) {
+      sets.push("tool_calls_count = tool_calls_count + ?");
+      params.push(increments.toolCalls);
+    }
+    if (sets.length === 0)
+      return;
+    params.push(sessionId);
+    this.db.query(`UPDATE sessions SET ${sets.join(", ")} WHERE session_id = ?`).run(...params);
   }
-  async health() {
-    try {
-      await this.request("GET", "/health");
-      return true;
-    } catch {
-      return false;
+  getSessionMetrics(sessionId) {
+    return this.db.query("SELECT * FROM sessions WHERE session_id = ?").get(sessionId) ?? null;
+  }
+  insertSecurityFinding(finding) {
+    const now = Math.floor(Date.now() / 1000);
+    const result = this.db.query(`INSERT INTO security_findings (session_id, project_id, finding_type, severity, pattern_name, file_path, snippet, tool_name, user_id, device_id, created_at_epoch)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(finding.session_id ?? null, finding.project_id, finding.finding_type, finding.severity, finding.pattern_name, finding.file_path ?? null, finding.snippet ?? null, finding.tool_name ?? null, finding.user_id, finding.device_id, now);
+    const id = Number(result.lastInsertRowid);
+    return this.db.query("SELECT * FROM security_findings WHERE id = ?").get(id);
+  }
+  getSecurityFindings(projectId, options = {}) {
+    const limit = options.limit ?? 50;
+    if (options.severity) {
+      return this.db.query(`SELECT * FROM security_findings
+           WHERE project_id = ? AND severity = ?
+           ORDER BY created_at_epoch DESC
+           LIMIT ?`).all(projectId, options.severity, limit);
     }
+    return this.db.query(`SELECT * FROM security_findings
+         WHERE project_id = ?
+         ORDER BY created_at_epoch DESC
+         LIMIT ?`).all(projectId, limit);
   }
-  async request(method, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = {
-      Authorization: `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json"
+  getSecurityFindingsCount(projectId) {
+    const rows = this.db.query(`SELECT severity, COUNT(*) as count FROM security_findings
+         WHERE project_id = ?
+         GROUP BY severity`).all(projectId);
+    const counts = {
+      critical: 0,
+      high: 0,
+      medium: 0,
+      low: 0
     };
-    const init = { method, headers };
-    if (body && method !== "GET") {
-      init.body = JSON.stringify(body);
-    }
-    const response = await fetch(url, init);
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new VectorApiError(response.status, text, path);
+    for (const row of rows) {
+      counts[row.severity] = row.count;
     }
-    if (response.status === 204 || response.headers.get("content-length") === "0") {
-      return;
+    return counts;
+  }
+  setSessionRiskScore(sessionId, score) {
+    this.db.query("UPDATE sessions SET risk_score = ? WHERE session_id = ?").run(score, sessionId);
+  }
+  getObservationsBySession(sessionId) {
+    return this.db.query(`SELECT * FROM observations WHERE session_id = ? ORDER BY created_at_epoch ASC`).all(sessionId);
+  }
+  getInstalledPacks() {
+    try {
+      const rows = this.db.query("SELECT name FROM packs_installed").all();
+      return rows.map((r) => r.name);
+    } catch {
+      return [];
     }
-    return response.json();
   }
-}
-
-class VectorApiError extends Error {
-  status;
-  body;
-  path;
-  constructor(status, body, path) {
-    super(`Vector API error ${status} on ${path}: ${body}`);
-    this.status = status;
-    this.body = body;
-    this.path = path;
-    this.name = "VectorApiError";
+  markPackInstalled(name, observationCount) {
+    const now = Math.floor(Date.now() / 1000);
+    this.db.query("INSERT OR REPLACE INTO packs_installed (name, installed_at, observation_count) VALUES (?, ?, ?)").run(name, now, observationCount);
   }
 }
 
-// hooks/session-start.ts
-async function main() {
+// src/hooks/common.ts
+var c = {
+  dim: "\x1B[2m",
+  yellow: "\x1B[33m",
+  reset: "\x1B[0m"
+};
+async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString());
   }
-  const raw = chunks.join("");
+  return chunks.join("");
+}
+async function parseStdinJson() {
+  const raw = await readStdin();
   if (!raw.trim())
-    process.exit(0);
-  let event;
+    return null;
   try {
-    event = JSON.parse(raw);
+    return JSON.parse(raw);
   } catch {
-    process.exit(0);
+    return null;
+  }
+}
+function bootstrapHook(hookName) {
+  if (!configExists()) {
+    warnUser(hookName, "Engrm not configured. Run: npx engrm init");
+    return null;
   }
-  if (!configExists())
-    process.exit(0);
   let config;
-  let db;
   try {
     config = loadConfig();
+  } catch (err) {
+    warnUser(hookName, `Config error: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+  let db;
+  try {
     db = new MemDatabase(getDbPath());
-  } catch {
-    process.exit(0);
+  } catch (err) {
+    warnUser(hookName, `Database error: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
   }
+  return { config, db };
+}
+function warnUser(hookName, message) {
+  console.error(`${c.yellow}engrm ${hookName}:${c.reset} ${c.dim}${message}${c.reset}`);
+}
+function runHook(hookName, fn) {
+  fn().catch((err) => {
+    warnUser(hookName, `Unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(0);
+  });
+}
+
+// hooks/session-start.ts
+async function main() {
+  const event = await parseStdinJson();
+  if (!event)
+    process.exit(0);
+  const boot = bootstrapHook("session-start");
+  if (!boot)
+    process.exit(0);
+  const { config, db } = boot;
+  let syncedCount = 0;
   try {
     if (config.sync.enabled && config.candengo_api_key) {
       try {
         const client = new VectorClient(config);
         const pullResult = await pullFromVector(db, client, config, 50);
-        if (pullResult.merged > 0) {
-          console.error(`Engrm: synced ${pullResult.merged} observation(s) from server`);
-        }
+        syncedCount = pullResult.merged;
         await pullSettings(client, config);
       } catch {}
     }
+    try {
+      computeAndSaveFingerprint(event.cwd);
+    } catch {}
     const context = buildSessionContext(db, event.cwd, {
       tokenBudget: 800,
-      scope: config.search.scope
+      scope: config.search.scope,
+      userId: config.user_id
     });
+    if (context) {
+      try {
+        const dir = join6(homedir3(), ".engrm");
+        if (!existsSync6(dir))
+          mkdirSync3(dir, { recursive: true });
+        writeFileSync3(join6(dir, "hook-session-metrics.json"), JSON.stringify({
+          contextObsInjected: context.observations.length,
+          contextTotalAvailable: context.total_active
+        }), "utf-8");
+      } catch {}
+    }
     if (context && context.observations.length > 0) {
-      console.log(formatContextForInjection(context));
-      const parts = [];
-      parts.push(`${context.session_count} observation(s)`);
-      if (context.securityFindings && context.securityFindings.length > 0) {
-        parts.push(`${context.securityFindings.length} security finding(s)`);
-      }
       const remaining = context.total_active - context.session_count;
-      if (remaining > 0) {
-        parts.push(`${remaining} more searchable`);
-      }
+      let msgCount = 0;
       try {
         const readKey = `messages_read_${config.device_id}`;
         const lastReadId = parseInt(db.getSyncState(readKey) ?? "0", 10);
-        const msgCount = db.db.query("SELECT COUNT(*) as c FROM observations WHERE type = 'message' AND id > ? AND lifecycle IN ('active', 'pinned')").get(lastReadId)?.c ?? 0;
-        if (msgCount > 0) {
-          parts.push(`${msgCount} unread message(s)`);
+        msgCount = db.db.query(`SELECT COUNT(*) as c FROM observations
+             WHERE type = 'message'
+               AND id > ?
+               AND lifecycle IN ('active', 'pinned')
+               AND device_id != ?
+               AND (sensitivity != 'personal' OR user_id = ?)`).get(lastReadId, config.device_id, config.user_id)?.c ?? 0;
+      } catch {}
+      const splash = formatSplashScreen({
+        projectName: context.project_name,
+        loaded: context.session_count,
+        available: remaining,
+        securityFindings: context.securityFindings?.length ?? 0,
+        unreadMessages: msgCount,
+        synced: syncedCount
+      });
+      let packLine = "";
+      try {
+        const { stacks } = detectStacksFromProject(event.cwd);
+        if (stacks.length > 0) {
+          const installed = db.getInstalledPacks();
+          const recs = recommendPacks(stacks, installed);
+          if (recs.length > 0) {
+            const names = recs.map((r) => `\`${r.name}\``).join(", ");
+            packLine = `
+Help packs available for your stack: ${names}. ` + `Use the install_pack tool to load curated observations.`;
+          }
         }
       } catch {}
-      console.error(`Engrm: ${parts.join(" \xB7 ")} \u2014 memory loaded`);
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: formatContextForInjection(context) + packLine
+        },
+        systemMessage: splash
+      }));
     }
-    try {
-      const { stacks } = detectStacksFromProject(event.cwd);
-      if (stacks.length > 0) {
-        const installed = db.getInstalledPacks();
-        const recs = recommendPacks(stacks, installed);
-        if (recs.length > 0) {
-          const names = recs.map((r) => `\`${r.name}\``).join(", ");
-          console.log(`
-Help packs available for your stack: ${names}. ` + `Use the install_pack tool to load curated observations.`);
-        }
-      }
-    } catch {}
   } finally {
     db.close();
   }
 }
-main().catch(() => {
-  process.exit(0);
-});
+var c2 = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m"
+};
+function formatSplashScreen(data) {
+  const lines = [];
+  lines.push("");
+  lines.push(`${c2.cyan}${c2.bold}  ______  ____   _  ______  _____   ____    __${c2.reset}`);
+  lines.push(`${c2.cyan}${c2.bold}  |   ___||    \\ | ||   ___||     | |    \\  /  |${c2.reset}`);
+  lines.push(`${c2.cyan}${c2.bold}  |   ___||     \\| ||   |  ||     \\ |     \\/   |${c2.reset}`);
+  lines.push(`${c2.cyan}${c2.bold}  |______||__/\\____||______||__|\\__\\|__/\\__/|__|${c2.reset}`);
+  lines.push(`${c2.dim}  memory layer for AI agents${c2.reset}`);
+  lines.push("");
+  const dot = `${c2.dim} \xB7 ${c2.reset}`;
+  const statParts = [];
+  statParts.push(`${c2.green}${data.loaded}${c2.reset} loaded`);
+  if (data.available > 0) {
+    statParts.push(`${c2.dim}${data.available.toLocaleString()} searchable${c2.reset}`);
+  }
+  if (data.synced > 0) {
+    statParts.push(`${c2.cyan}${data.synced} synced${c2.reset}`);
+  }
+  lines.push(`  ${c2.white}${c2.bold}engrm${c2.reset}${dot}${statParts.join(dot)}`);
+  const alerts = [];
+  if (data.securityFindings > 0) {
+    alerts.push(`${c2.yellow}${data.securityFindings} security finding${data.securityFindings !== 1 ? "s" : ""}${c2.reset}`);
+  }
+  if (data.unreadMessages > 0) {
+    alerts.push(`${c2.magenta}${data.unreadMessages} unread message${data.unreadMessages !== 1 ? "s" : ""}${c2.reset}`);
+  }
+  if (alerts.length > 0) {
+    lines.push(`  ${alerts.join(dot)}`);
+  }
+  lines.push("");
+  lines.push(`  ${c2.dim}Dashboard: https://engrm.dev/dashboard${c2.reset}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+runHook("session-start", main);