@edihasaj/recall 0.5.2

package/dist/chunk-PC43MBX5.js

@@ -0,0 +1,2960 @@
+import {
+  computeHealthScore,
+  getRepoQualityProfile,
+  processCorrection,
+  seedScannedConfidence
+} from "./chunk-VEPXEHRZ.js";
+import {
+  CONFIDENCE,
+  RetrievalEvalCase,
+  RetrievalEvalFile,
+  activityEventDedupeKey,
+  bootstrapEmbeddings,
+  confirmMemory,
+  createMemory,
+  demoteMemory,
+  feedbackWeightedScore,
+  generateEmbedding,
+  generateEmbeddings,
+  getEmbeddingCacheRoot,
+  getMemory,
+  getMemoryFeedbackSummaries,
+  historySnippetDedupeKey,
+  hybridSearch,
+  loadEmbeddingConfigFromEnv,
+  projectEmbeddingToIndex,
+  promoteMemory,
+  queryMemories,
+  queueMemoryEmbeddingSync,
+  recordAudit,
+  recordFeedback,
+  rejectMemory,
+  resolveProvider,
+  statusFromConfidence,
+  tagActivitySource
+} from "./chunk-IILLSHLM.js";
+import {
+  activityEvents,
+  approvalRequests,
+  auditTrail,
+  evalSessions,
+  feedbackEvents,
+  historyInjections,
+  historySnippetEmbeddings,
+  historySnippets,
+  implicitSignals,
+  memories,
+  memoryInjections,
+  memoryMaintenanceTasks,
+  policyRules,
+  schema_exports
+} from "./chunk-A5UIRZU6.js";
+
+// src/db/client.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { join, dirname } from "path";
+import { mkdirSync, existsSync, rmSync } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var RECALL_DB_USER_VERSION = 9;
+function getDbPath() {
+  const dataDir = process.env.RECALL_DATA_DIR ?? join(
+    process.env.HOME ?? process.env.USERPROFILE ?? ".",
+    ".recall"
+  );
+  mkdirSync(dataDir, { recursive: true });
+  return join(dataDir, "recall.db");
+}
+function getMigrationsPath() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join(dir, "drizzle");
+    if (existsSync(join(candidate, "meta", "_journal.json"))) {
+      return candidate;
+    }
+    dir = dirname(dir);
+  }
+  return join(__dirname, "..", "drizzle");
+}
+var _sqlite = null;
+var _db = null;
+var _dbPath = null;
+function makeDb(sqlite) {
+  return drizzle(sqlite, { schema: schema_exports });
+}
+function applyPragmas(sqlite) {
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+}
+function setDbUserVersion(sqlite, version2 = RECALL_DB_USER_VERSION) {
+  sqlite.pragma(`user_version = ${version2}`);
+}
+function getDb(dbPath) {
+  if (!_db) {
+    const path = dbPath ?? getDbPath();
+    _sqlite = new Database(path);
+    applyPragmas(_sqlite);
+    _db = makeDb(_sqlite);
+    _dbPath = path;
+  }
+  return _db;
+}
+function initDb(dbPath) {
+  const db = getDb(dbPath);
+  migrate(db, { migrationsFolder: getMigrationsPath() });
+  setDbUserVersion(db.$client);
+  return db;
+}
+function closeDb() {
+  if (_sqlite) {
+    _sqlite.close();
+  }
+  _sqlite = null;
+  _db = null;
+  _dbPath = null;
+}
+function getDbUserVersion(dbPath) {
+  const path = dbPath ?? getDbPath();
+  if (!existsSync(path)) return 0;
+  const sqlite = new Database(path, { readonly: true, fileMustExist: true });
+  try {
+    return Number(sqlite.pragma("user_version", { simple: true }) ?? 0);
+  } finally {
+    sqlite.close();
+  }
+}
+function resetDb(dbPath, options = {}) {
+  const path = dbPath ?? getDbPath();
+  if (_dbPath === path) {
+    closeDb();
+  }
+  for (const suffix of ["", "-shm", "-wal"]) {
+    const candidate = `${path}${suffix}`;
+    if (existsSync(candidate)) {
+      rmSync(candidate, { force: true });
+    }
+  }
+  if (options.purgeModels) {
+    rmSync(getEmbeddingCacheRoot(), { recursive: true, force: true });
+  }
+}
+
+// src/scanner/repo.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
+import { execSync } from "child_process";
+import { eq } from "drizzle-orm";
+
+// src/scanner/signal.ts
+var ACTIVE_COMMAND_PATTERNS = [
+  /^use\b/i,
+  /^(test|build|lint|dev|start|typecheck|check):\s*`.+`$/i,
+  /^makefile targets:/i
+];
+var CANDIDATE_GOTCHA_PATTERNS = [
+  /^next\.js project$/i,
+  /^react project\b/i,
+  /^vue\.js project$/i,
+  /^svelte project$/i,
+  /^server framework:/i,
+  /^uses alembic\b/i
+];
+var ACTIONABLE_RULE_PATTERN = /\b(always|never|must|don't|do not|required|prefer|avoid|use|keep|run|update|add|remove|check|only)\b/i;
+function evaluateScannedMemory(input) {
+  const normalized = normalizeScannedText(input.text);
+  const lower = normalized.toLowerCase();
+  if (!normalized || normalized.length < 12) {
+    return reject(normalized, "too_short");
+  }
+  if (lower.startsWith("setup commands from readme:")) {
+    return reject(normalized, "readme_setup_noise");
+  }
+  if (lower === "what we do not build") {
+    return reject(normalized, "section_heading");
+  }
+  if (/^ci:\s*(github actions|gitlab ci)\b/i.test(normalized)) {
+    return reject(normalized, "generic_ci");
+  }
+  if (/^req-[a-z0-9-]+:/i.test(lower)) {
+    return reject(normalized, "spec_requirement");
+  }
+  if (/^[A-Z][A-Za-z0-9 /_-]{1,80}:$/.test(normalized)) {
+    return reject(normalized, "heading");
+  }
+  if (input.source === "config_parse" && lower.startsWith("linting/formatting: python project")) {
+    return reject(normalized, "generic_tooling");
+  }
+  if (input.source === "config_parse" && lower.startsWith("linting/formatting:")) {
+    return keep(normalized, toCandidateConfidence(input.confidence));
+  }
+  if (ACTIVE_COMMAND_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return keep(normalized, Math.max(input.confidence, 0.62));
+  }
+  if (input.type === "command") {
+    return keep(normalized, toCandidateConfidence(input.confidence));
+  }
+  if (input.type === "gotcha") {
+    if (CANDIDATE_GOTCHA_PATTERNS.some((pattern) => pattern.test(normalized))) {
+      return keep(normalized, toCandidateConfidence(input.confidence));
+    }
+    return reject(normalized, "generic_gotcha");
+  }
+  if (input.type === "rule") {
+    if (!ACTIONABLE_RULE_PATTERN.test(normalized)) {
+      return reject(normalized, "non_actionable_rule");
+    }
+    return keep(normalized, toCandidateConfidence(input.confidence));
+  }
+  return keep(normalized, toCandidateConfidence(input.confidence));
+}
+function normalizeScannedText(text) {
+  return text.replace(/\*\*/g, "").split("\n").map((line) => line.replace(/^[-*#>\s]+/, "").replace(/^\d+\.\s+/, "").trim()).filter(Boolean).join("\n").replace(/[ \t]+/g, " ").trim();
+}
+function toCandidateConfidence(confidence) {
+  return clamp(confidence, CONFIDENCE.TRANSIENT_MAX + 0.05, CONFIDENCE.ACTIVE_MIN - 0.01);
+}
+function keep(text, confidence) {
+  return { action: "keep", text, confidence: clamp(confidence) };
+}
+function reject(text, reason) {
+  return { action: "reject", text, confidence: 0, reason };
+}
+function clamp(n, min = 0, max = 1) {
+  return Math.max(min, Math.min(max, n));
+}
+
+// src/scanner/repo.ts
+function scanRepo(repoPath) {
+  const repoName = inferRepoName(repoPath);
+  const candidates = [];
+  candidates.push(...scanPackageJson(repoPath, repoName));
+  candidates.push(...scanMakefile(repoPath, repoName));
+  candidates.push(...scanCIConfig(repoPath, repoName));
+  candidates.push(...scanInstructionFiles(repoPath, repoName));
+  candidates.push(...scanLinterConfigs(repoPath, repoName));
+  candidates.push(...scanReadme(repoPath, repoName));
+  candidates.push(...scanPythonProject(repoPath, repoName));
+  return { candidates, repo: repoName };
+}
+function scanAndStore(db, repoPath) {
+  const { candidates, repo } = scanRepo(repoPath);
+  const profile = getRepoQualityProfile(db, repo);
+  const existing = queryMemories(db, { repo }).filter((mem) => mem.status !== "rejected");
+  const ids = [];
+  for (const candidate of candidates) {
+    const evaluated = evaluateScannedMemory({
+      text: candidate.text,
+      type: candidate.type,
+      source: candidate.source,
+      confidence: seedScannedConfidence(
+        candidate.confidence ?? 0.5,
+        profile
+      )
+    });
+    if (evaluated.action === "reject") {
+      continue;
+    }
+    const seededConfidence = evaluated.confidence;
+    const normalizedCandidate = {
+      ...candidate,
+      text: evaluated.text
+    };
+    const duplicate = existing.find(
+      (mem) => mem.type === normalizedCandidate.type && mem.source === normalizedCandidate.source && mem.text === normalizedCandidate.text
+    );
+    if (duplicate) {
+      if (duplicate.confidence < seededConfidence) {
+        db.update(memories).set({
+          confidence: seededConfidence,
+          status: statusFromConfidence(seededConfidence),
+          text: normalizedCandidate.text,
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).where(eq(memories.id, duplicate.id)).run();
+        queueMemoryEmbeddingSync(db, duplicate.id);
+      }
+      ids.push(duplicate.id);
+      continue;
+    }
+    normalizedCandidate.confidence = seededConfidence;
+    const id = createMemory(db, normalizedCandidate);
+    ids.push(id);
+    existing.push({
+      ...queryMemories(db, { repo }).find((mem) => mem.id === id),
+      confidence: seededConfidence,
+      status: statusFromConfidence(seededConfidence)
+    });
+  }
+  return ids;
+}
+function scanPackageJson(repoPath, repo) {
+  const pkgPath = join2(repoPath, "package.json");
+  if (!existsSync2(pkgPath)) return [];
+  const results = [];
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (pkg.packageManager) {
+      const pm = pkg.packageManager.split("@")[0];
+      results.push(makeCommand(
+        `Use ${pm} as the package manager (lockfile: ${pm === "pnpm" ? "pnpm-lock.yaml" : pm === "yarn" ? "yarn.lock" : "package-lock.json"})`,
+        repo,
+        "package.json"
+      ));
+    } else if (existsSync2(join2(repoPath, "pnpm-lock.yaml"))) {
+      results.push(makeCommand("Use pnpm as the package manager", repo, "package.json"));
+    } else if (existsSync2(join2(repoPath, "yarn.lock"))) {
+      results.push(makeCommand("Use yarn as the package manager", repo, "package.json"));
+    } else if (existsSync2(join2(repoPath, "bun.lockb")) || existsSync2(join2(repoPath, "bun.lock"))) {
+      results.push(makeCommand("Use bun as the package manager", repo, "package.json"));
+    }
+    const scripts = pkg.scripts ?? {};
+    const importantScripts = ["test", "build", "lint", "dev", "start", "typecheck", "check"];
+    for (const name of importantScripts) {
+      if (scripts[name]) {
+        results.push({
+          type: "command",
+          text: `${name}: \`${scripts[name]}\``,
+          scope: "repo",
+          repo,
+          source: "config_parse",
+          confidence: 0.65,
+          evidence: [
+            { type: "repo_scan", file: "package.json", timestamp: now() }
+          ]
+        });
+      }
+    }
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps.next) results.push(makeGotcha("Next.js project", repo, "package.json"));
+    if (allDeps.react && !allDeps.next) results.push(makeGotcha("React project (no Next.js)", repo, "package.json"));
+    if (allDeps.vue) results.push(makeGotcha("Vue.js project", repo, "package.json"));
+    if (allDeps.svelte) results.push(makeGotcha("Svelte project", repo, "package.json"));
+    if (allDeps.express || allDeps.fastify || allDeps.hono)
+      results.push(makeGotcha(`Server framework: ${allDeps.express ? "Express" : allDeps.fastify ? "Fastify" : "Hono"}`, repo, "package.json"));
+  } catch {
+  }
+  return results;
+}
+function scanMakefile(repoPath, repo) {
+  const mkPath = join2(repoPath, "Makefile");
+  if (!existsSync2(mkPath)) return [];
+  const results = [];
+  try {
+    const content = readFileSync(mkPath, "utf-8");
+    const targets = content.match(/^([a-zA-Z_-]+):/gm);
+    if (targets) {
+      const key = targets.map((t) => t.replace(":", "")).filter(
+        (t) => ["test", "build", "lint", "dev", "run", "deploy", "install", "setup", "clean"].includes(t)
+      );
+      if (key.length > 0) {
+        results.push({
+          type: "command",
+          text: `Makefile targets: ${key.map((t) => `\`make ${t}\``).join(", ")}`,
+          scope: "repo",
+          repo,
+          source: "config_parse",
+          confidence: 0.65,
+          evidence: [{ type: "repo_scan", file: "Makefile", timestamp: now() }]
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function scanCIConfig(repoPath, repo) {
+  const results = [];
+  const ghDir = join2(repoPath, ".github", "workflows");
+  if (existsSync2(ghDir)) {
+    results.push({
+      type: "gotcha",
+      text: "CI: GitHub Actions (check .github/workflows/ for pipeline config)",
+      scope: "repo",
+      repo,
+      source: "repo_scan",
+      confidence: 0.6,
+      evidence: [{ type: "repo_scan", file: ".github/workflows/", timestamp: now() }]
+    });
+  }
+  if (existsSync2(join2(repoPath, ".gitlab-ci.yml"))) {
+    results.push(makeGotcha("CI: GitLab CI", repo, ".gitlab-ci.yml"));
+  }
+  return results;
+}
+function scanInstructionFiles(repoPath, repo) {
+  const results = [];
+  const instructionFiles = [
+    "CLAUDE.md",
+    "AGENTS.md",
+    ".github/copilot-instructions.md",
+    ".cursorrules"
+  ];
+  for (const file of instructionFiles) {
+    const fPath = join2(repoPath, file);
+    if (!existsSync2(fPath)) continue;
+    try {
+      const content = readFileSync(fPath, "utf-8");
+      const rules = content.split("\n").filter(
+        (line) => /\b(always|never|must|don't|do not|required|forbidden)\b/i.test(line)
+      ).map((l) => l.replace(/^[-*#>\s]+/, "").trim()).filter((l) => l.length > 10 && l.length < 200);
+      for (const rule of rules.slice(0, 5)) {
+        results.push({
+          type: "rule",
+          text: rule,
+          scope: "repo",
+          repo,
+          source: "repo_scan",
+          confidence: 0.7,
+          // high — explicit instruction files
+          evidence: [{ type: "repo_scan", file, timestamp: now() }]
+        });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function scanLinterConfigs(repoPath, repo) {
+  const results = [];
+  const configs = [
+    [".eslintrc.json", "ESLint"],
+    [".eslintrc.js", "ESLint"],
+    [".eslintrc.cjs", "ESLint"],
+    ["eslint.config.js", "ESLint (flat config)"],
+    ["eslint.config.mjs", "ESLint (flat config)"],
+    [".prettierrc", "Prettier"],
+    ["prettier.config.js", "Prettier"],
+    ["biome.json", "Biome"],
+    ["biome.jsonc", "Biome"],
+    [".rustfmt.toml", "rustfmt"],
+    ["ruff.toml", "Ruff"],
+    ["pyproject.toml", "Python project (pyproject.toml)"]
+  ];
+  const found = [];
+  for (const [file, name] of configs) {
+    if (existsSync2(join2(repoPath, file))) {
+      found.push(name);
+    }
+  }
+  if (found.length > 0) {
+    results.push({
+      type: "rule",
+      text: `Linting/formatting: ${[...new Set(found)].join(", ")}`,
+      scope: "repo",
+      repo,
+      source: "config_parse",
+      confidence: 0.65,
+      evidence: [{ type: "repo_scan", file: "config files", timestamp: now() }]
+    });
+  }
+  return results;
+}
+function scanReadme(repoPath, repo) {
+  const results = [];
+  const readmePath = join2(repoPath, "README.md");
+  if (!existsSync2(readmePath)) return [];
+  try {
+    const content = readFileSync(readmePath, "utf-8");
+    const setupMatch = content.match(
+      /^##\s*(setup|install|getting.started|quick.start|development)\s*\n([\s\S]*?)(?=^##\s|\z)/im
+    );
+    if (setupMatch) {
+      const codeBlocks = setupMatch[2].match(/```(?:sh|bash|shell|zsh)?\n([\s\S]*?)```/g);
+      if (codeBlocks && codeBlocks.length > 0) {
+        const commands = codeBlocks.map((b) => b.replace(/```(?:sh|bash|shell|zsh)?\n?/, "").replace(/```$/, "").trim()).join("\n");
+        if (commands.length < 500) {
+          results.push({
+            type: "command",
+            text: `Setup commands from README:
+${commands}`,
+            scope: "repo",
+            repo,
+            source: "repo_scan",
+            confidence: 0.5,
+            evidence: [{ type: "repo_scan", file: "README.md", timestamp: now() }]
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function scanPythonProject(repoPath, repo) {
+  const results = [];
+  if (existsSync2(join2(repoPath, "pyproject.toml"))) {
+    if (existsSync2(join2(repoPath, "uv.lock"))) {
+      results.push(makeCommand("Use `uv` for Python dependency management", repo, "uv.lock"));
+    } else if (existsSync2(join2(repoPath, "poetry.lock"))) {
+      results.push(makeCommand("Use `poetry` for Python dependency management", repo, "poetry.lock"));
+    }
+    if (existsSync2(join2(repoPath, "alembic.ini")) || existsSync2(join2(repoPath, "alembic"))) {
+      results.push(makeGotcha("Uses Alembic for database migrations", repo, "alembic.ini"));
+    }
+  }
+  return results;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function inferRepoName(repoPath) {
+  try {
+    const remote = execSync("git remote get-url origin", {
+      cwd: repoPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const repo = extractRepoSlugFromRemote(remote);
+    if (repo) return repo;
+  } catch {
+  }
+  return basename(repoPath);
+}
+function extractRepoSlugFromRemote(remote) {
+  const trimmed = remote.trim().replace(/\.git$/, "");
+  const parts = trimmed.split(/[:/]/).filter(Boolean);
+  if (parts.length < 2) return null;
+  return `${parts.at(-2)}/${parts.at(-1)}`;
+}
+function makeCommand(text, repo, file) {
+  return {
+    type: "command",
+    text,
+    scope: "repo",
+    repo,
+    source: "config_parse",
+    confidence: 0.65,
+    evidence: [{ type: "repo_scan", file, timestamp: now() }]
+  };
+}
+function makeGotcha(text, repo, file) {
+  return {
+    type: "gotcha",
+    text,
+    scope: "repo",
+    repo,
+    source: "repo_scan",
+    confidence: 0.6,
+    evidence: [{ type: "repo_scan", file, timestamp: now() }]
+  };
+}
+
+// src/history/snippets.ts
+import { desc, eq as eq2, and } from "drizzle-orm";
+import { randomUUID } from "crypto";
+function createHistorySnippet(db, input) {
+  const dedupeKey = historySnippetDedupeKey(input);
+  const existing = db.select().from(historySnippets).where(eq2(historySnippets.dedupe_key, dedupeKey)).get();
+  if (existing) return existing.id;
+  const id = randomUUID();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(historySnippets).values({
+    id,
+    repo: input.repo ?? null,
+    session_id: input.session_id ?? null,
+    kind: input.kind,
+    text: input.text,
+    dedupe_key: dedupeKey,
+    source_activity_ids: input.source_activity_ids ?? [],
+    created_at: now2,
+    updated_at: now2
+  }).run();
+  return id;
+}
+function getHistorySnippet(db, id) {
+  const row = db.select().from(historySnippets).where(eq2(historySnippets.id, id)).get();
+  return row ? rowToHistorySnippet(row) : void 0;
+}
+function listHistorySnippets(db, query = {}) {
+  const conditions = [];
+  if (query.repo) conditions.push(eq2(historySnippets.repo, query.repo));
+  if (query.session_id) conditions.push(eq2(historySnippets.session_id, query.session_id));
+  if (query.kind) conditions.push(eq2(historySnippets.kind, query.kind));
+  let stmt = db.select().from(historySnippets).$dynamic();
+  if (conditions.length > 0) {
+    stmt = stmt.where(and(...conditions));
+  }
+  stmt = stmt.orderBy(desc(historySnippets.updated_at));
+  if (query.limit != null) {
+    stmt = stmt.limit(query.limit);
+  }
+  return stmt.all().map(rowToHistorySnippet);
+}
+function findHistorySnippetBySession(db, sessionId, kind = "session_summary") {
+  const row = db.select().from(historySnippets).where(and(
+    eq2(historySnippets.session_id, sessionId),
+    eq2(historySnippets.kind, kind)
+  )).get();
+  return row ? rowToHistorySnippet(row) : void 0;
+}
+function findHistorySnippetByRepoKind(db, repo, kind) {
+  const row = db.select().from(historySnippets).where(and(
+    eq2(historySnippets.repo, repo),
+    eq2(historySnippets.kind, kind)
+  )).get();
+  return row ? rowToHistorySnippet(row) : void 0;
+}
+function updateHistorySnippet(db, id, updates) {
+  const current = getHistorySnippet(db, id);
+  if (!current) return;
+  const nextText = updates.text ?? current.text;
+  const dedupeKey = historySnippetDedupeKey({
+    repo: current.repo,
+    session_id: current.session_id,
+    kind: current.kind,
+    text: nextText
+  });
+  const collision = db.select().from(historySnippets).where(eq2(historySnippets.dedupe_key, dedupeKey)).get();
+  if (collision && collision.id !== id) return;
+  db.update(historySnippets).set({
+    ...updates.text != null ? { text: updates.text } : {},
+    dedupe_key: dedupeKey,
+    ...updates.source_activity_ids ? { source_activity_ids: updates.source_activity_ids } : {},
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq2(historySnippets.id, id)).run();
+}
+function rowToHistorySnippet(row) {
+  const sourceActivityIds = typeof row.source_activity_ids === "string" ? JSON.parse(row.source_activity_ids) : Array.isArray(row.source_activity_ids) ? row.source_activity_ids : [];
+  return {
+    id: row.id,
+    repo: row.repo,
+    session_id: row.session_id,
+    kind: row.kind,
+    text: row.text,
+    source_activity_ids: sourceActivityIds,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+
+// src/history/retrieval.ts
+import { createHash } from "crypto";
+import { eq as eq5 } from "drizzle-orm";
+
+// src/vector/sqlite-vec-history.ts
+import * as sqliteVec from "sqlite-vec";
+import { eq as eq3 } from "drizzle-orm";
+var VEC_HISTORY_INDEX = "vec_history_index";
+var loadedClients = /* @__PURE__ */ new WeakSet();
+function getSqlite(db) {
+  return db.$client;
+}
+function hasHistoryVecIndex(db) {
+  return Boolean(
+    getSqlite(db).prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_HISTORY_INDEX)
+  );
+}
+function ensureLoaded(db) {
+  const sqlite = getSqlite(db);
+  if (loadedClients.has(sqlite)) return;
+  sqliteVec.load(sqlite);
+  loadedClients.add(sqlite);
+}
+function getHistoryVecDimension(rows) {
+  const dimensions = [...new Set(rows.map((row) => row.index_dimensions))];
+  if (dimensions.length === 0) return null;
+  if (dimensions.length > 1) {
+    throw new Error(
+      `sqlite-vec history index rebuild refused mixed history embedding dimensions: ${dimensions.join(", ")}.`
+    );
+  }
+  return dimensions[0];
+}
+function ensureHistoryVecIndex(db, dimensions) {
+  ensureLoaded(db);
+  const sqlite = getSqlite(db);
+  const existing = sqlite.prepare("select sql from sqlite_master where type = 'table' and name = ?").get(VEC_HISTORY_INDEX);
+  const expectedDimension = `float[${dimensions}]`;
+  if (existing?.sql && !existing.sql.includes(expectedDimension)) {
+    throw new Error(
+      `sqlite-vec history index dimension mismatch. Expected ${expectedDimension}. Run history index rebuild.`
+    );
+  }
+  sqlite.exec(`
+    create virtual table if not exists ${VEC_HISTORY_INDEX} using vec0(
+      embedding float[${dimensions}] distance_metric=cosine,
+      snippet_id text,
+      repo text,
+      kind text
+    );
+  `);
+}
+function removeHistoryVecRow(db, snippetId) {
+  ensureLoaded(db);
+  if (!hasHistoryVecIndex(db)) return;
+  getSqlite(db).prepare(`delete from ${VEC_HISTORY_INDEX} where snippet_id = ?`).run(snippetId);
+}
+function rebuildHistoryVecIndex(db, config, options = {}) {
+  const rows = db.select({
+    id: historySnippets.id,
+    repo: historySnippets.repo,
+    kind: historySnippets.kind,
+    index_dimensions: historySnippetEmbeddings.index_dimensions,
+    embedding: historySnippetEmbeddings.embedding
+  }).from(historySnippets).innerJoin(historySnippetEmbeddings, eq3(historySnippetEmbeddings.snippet_id, historySnippets.id)).all().filter((row) => !options.repo || row.repo === options.repo);
+  const storedDimension = getHistoryVecDimension(rows);
+  const targetDimension = storedDimension ?? config.dimensions;
+  const sqlite = getSqlite(db);
+  if (options.repo) {
+    if (rows.length > 0) {
+      ensureHistoryVecIndex(db, targetDimension);
+    }
+    if (!hasHistoryVecIndex(db)) return 0;
+    sqlite.prepare(`delete from ${VEC_HISTORY_INDEX} where repo = ?`).run(options.repo);
+    if (rows.length === 0) return 0;
+  } else {
+    sqlite.exec(`drop table if exists ${VEC_HISTORY_INDEX};`);
+    ensureHistoryVecIndex(db, targetDimension);
+  }
+  const stmt = getSqlite(db).prepare(`
+    insert into ${VEC_HISTORY_INDEX} (
+      embedding,
+      snippet_id,
+      repo,
+      kind
+    ) values (?, ?, ?, ?)
+  `);
+  const insertMany = getSqlite(db).transaction((batch) => {
+    for (const row of batch) {
+      stmt.run(projectIndexBuffer(row.embedding, row.index_dimensions), row.id, row.repo ?? "", row.kind);
+    }
+  });
+  insertMany(rows);
+  return rows.length;
+}
+function projectIndexBuffer(buffer, indexDimensions) {
+  const embedding = new Float32Array(
+    buffer.buffer,
+    buffer.byteOffset,
+    buffer.byteLength / Float32Array.BYTES_PER_ELEMENT
+  );
+  if (embedding.length === indexDimensions) {
+    return buffer;
+  }
+  if (embedding.length < indexDimensions) {
+    throw new Error(`Canonical history embedding width ${embedding.length} is smaller than index width ${indexDimensions}.`);
+  }
+  const sliced = embedding.slice(0, indexDimensions);
+  let norm = 0;
+  for (const value of sliced) norm += value * value;
+  const scale = Math.sqrt(norm) || 1;
+  for (let i = 0; i < sliced.length; i++) {
+    sliced[i] /= scale;
+  }
+  return Buffer.from(sliced.buffer, sliced.byteOffset, sliced.byteLength);
+}
+function verifyHistoryVecIndex(db, options = {}) {
+  ensureLoaded(db);
+  const sqlite = getSqlite(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_HISTORY_INDEX);
+  const expected = db.select({
+    snippet_id: historySnippetEmbeddings.snippet_id,
+    repo: historySnippets.repo
+  }).from(historySnippetEmbeddings).innerJoin(historySnippets, eq3(historySnippets.id, historySnippetEmbeddings.snippet_id)).all().filter((row) => !options.repo || row.repo === options.repo).length;
+  let indexed = 0;
+  if (exists) {
+    if (options.repo) {
+      indexed = sqlite.prepare(`select count(*) as count from ${VEC_HISTORY_INDEX} where repo = ?`).get(options.repo).count;
+    } else {
+      indexed = sqlite.prepare(`select count(*) as count from ${VEC_HISTORY_INDEX}`).get().count;
+    }
+  }
+  return { expected, indexed, drift: expected - indexed };
+}
+function searchHistoryVecIndex(db, queryEmbedding, options = {}) {
+  ensureLoaded(db);
+  const sqlite = getSqlite(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(VEC_HISTORY_INDEX);
+  if (!exists) return [];
+  const limit = options.limit ?? 10;
+  if (options.repo) {
+    return sqlite.prepare(`
+      select snippet_id, distance
+      from ${VEC_HISTORY_INDEX}
+      where embedding match ?
+        and k = ?
+        and repo = ?
+      order by distance
+    `).all(queryEmbedding, limit, options.repo);
+  }
+  return sqlite.prepare(`
+    select snippet_id, distance
+    from ${VEC_HISTORY_INDEX}
+    where embedding match ?
+      and k = ?
+    order by distance
+  `).all(queryEmbedding, limit);
+}
+
+// src/vector/sqlite-fts-history.ts
+import { eq as eq4 } from "drizzle-orm";
+var FTS_HISTORY_INDEX = "fts_history_index";
+function getSqlite2(db) {
+  return db.$client;
+}
+function ensureHistoryFtsIndex(db) {
+  getSqlite2(db).exec(`
+    create virtual table if not exists ${FTS_HISTORY_INDEX} using fts5(
+      snippet_id UNINDEXED,
+      text,
+      repo UNINDEXED,
+      kind UNINDEXED
+    );
+  `);
+}
+function removeHistoryFtsRow(db, snippetId) {
+  const sqlite = getSqlite2(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(FTS_HISTORY_INDEX);
+  if (!exists) return;
+  sqlite.prepare(`delete from ${FTS_HISTORY_INDEX} where snippet_id = ?`).run(snippetId);
+}
+function upsertHistoryFtsRow(db, snippet) {
+  ensureHistoryFtsIndex(db);
+  const sqlite = getSqlite2(db);
+  sqlite.prepare(`delete from ${FTS_HISTORY_INDEX} where snippet_id = ?`).run(snippet.id);
+  sqlite.prepare(`
+    insert into ${FTS_HISTORY_INDEX} (
+      snippet_id,
+      text,
+      repo,
+      kind
+    ) values (?, ?, ?, ?)
+  `).run(snippet.id, snippet.text, snippet.repo ?? "", snippet.kind);
+}
+function syncHistoryFtsIndex(db, snippetId) {
+  const snippet = db.select().from(historySnippets).where(eq4(historySnippets.id, snippetId)).get();
+  if (!snippet) {
+    removeHistoryFtsRow(db, snippetId);
+    return "removed";
+  }
+  upsertHistoryFtsRow(db, snippet);
+  return "stored";
+}
+function rebuildHistoryFtsIndex(db, options = {}) {
+  const sqlite = getSqlite2(db);
+  if (options.repo) {
+    ensureHistoryFtsIndex(db);
+    sqlite.prepare(`delete from ${FTS_HISTORY_INDEX} where repo = ?`).run(options.repo);
+  } else {
+    sqlite.exec(`drop table if exists ${FTS_HISTORY_INDEX};`);
+    ensureHistoryFtsIndex(db);
+  }
+  const rows = db.select().from(historySnippets).all().filter((row) => !options.repo || row.repo === options.repo);
+  const stmt = sqlite.prepare(`
+    insert into ${FTS_HISTORY_INDEX} (
+      snippet_id,
+      text,
+      repo,
+      kind
+    ) values (?, ?, ?, ?)
+  `);
+  const insertMany = sqlite.transaction((batch) => {
+    for (const row of batch) {
+      stmt.run(row.id, row.text, row.repo ?? "", row.kind);
+    }
+  });
+  insertMany(rows);
+  return rows.length;
+}
+function verifyHistoryFtsIndex(db, options = {}) {
+  const sqlite = getSqlite2(db);
+  const exists = sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(FTS_HISTORY_INDEX);
+  const expected = db.select().from(historySnippets).all().filter((row) => !options.repo || row.repo === options.repo).length;
+  let indexed = 0;
+  if (exists) {
+    if (options.repo) {
+      indexed = sqlite.prepare(`select count(*) as count from ${FTS_HISTORY_INDEX} where repo = ?`).get(options.repo).count;
+    } else {
+      indexed = sqlite.prepare(`select count(*) as count from ${FTS_HISTORY_INDEX}`).get().count;
+    }
+  }
+  return { expected, indexed, drift: expected - indexed };
+}
+function buildFtsQuery(query) {
+  const tokens = query.match(/[A-Za-z0-9_.:/-]+/g)?.map((token) => token.replace(/"/g, '""')).filter(Boolean) ?? [];
+  if (tokens.length === 0) return null;
+  return tokens.map((token) => `"${token}"`).join(" ");
+}
+function searchHistoryFtsIndex(db, query, options = {}) {
+  ensureHistoryFtsIndex(db);
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery) return [];
+  const sqlite = getSqlite2(db);
+  const limit = options.limit ?? 10;
+  if (options.repo) {
+    return sqlite.prepare(`
+      select snippet_id, bm25(${FTS_HISTORY_INDEX}) as lexical_rank
+      from ${FTS_HISTORY_INDEX}
+      where ${FTS_HISTORY_INDEX} match ?
+        and repo = ?
+      order by lexical_rank
+      limit ?
+    `).all(ftsQuery, options.repo, limit);
+  }
+  return sqlite.prepare(`
+    select snippet_id, bm25(${FTS_HISTORY_INDEX}) as lexical_rank
+    from ${FTS_HISTORY_INDEX}
+    where ${FTS_HISTORY_INDEX} match ?
+    order by lexical_rank
+    limit ?
+  `).all(ftsQuery, limit);
+}
+
+// src/history/retrieval.ts
+function hashText(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function version(config) {
+  return config.version || `${config.provider}:${config.model}:${config.dimensions}`;
+}
+function rowNeedsRefresh(row, existing, config) {
+  const metadata = resolveProvider(config).metadata();
+  if (!existing) return true;
+  return existing.model !== config.model || existing.embedding_dimensions !== metadata.canonical_dimensions || existing.index_dimensions !== metadata.index_dimensions || existing.version !== version(config) || existing.content_hash !== hashText(row.text);
+}
+function rowToHistorySnippet2(row) {
+  const sourceActivityIds = typeof row.source_activity_ids === "string" ? JSON.parse(row.source_activity_ids) : Array.isArray(row.source_activity_ids) ? row.source_activity_ids : [];
+  return {
+    id: row.id,
+    repo: row.repo,
+    session_id: row.session_id,
+    kind: row.kind,
+    text: row.text,
+    source_activity_ids: sourceActivityIds,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function storeHistoryEmbedding(db, snippetId, text, embedding, config) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = resolveProvider(config).metadata();
+  const payload = {
+    snippet_id: snippetId,
+    model: config.model,
+    embedding_dimensions: metadata.canonical_dimensions,
+    index_dimensions: metadata.index_dimensions,
+    version: version(config),
+    content_hash: hashText(text),
+    updated_at: now2,
+    embedding: Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength)
+  };
+  db.insert(historySnippetEmbeddings).values(payload).onConflictDoUpdate({
+    target: historySnippetEmbeddings.snippet_id,
+    set: {
+      model: payload.model,
+      embedding_dimensions: payload.embedding_dimensions,
+      index_dimensions: payload.index_dimensions,
+      version: payload.version,
+      content_hash: payload.content_hash,
+      updated_at: payload.updated_at,
+      embedding: payload.embedding
+    }
+  }).run();
+}
+async function bootstrapHistoryEmbeddings(db, config, options = {}) {
+  const rows = db.select().from(historySnippets).all().filter((row) => !options.repo || row.repo === options.repo);
+  const existing = new Map(
+    db.select().from(historySnippetEmbeddings).all().map((row) => [row.snippet_id, row])
+  );
+  const pending = rows.filter((row) => rowNeedsRefresh(row, existing.get(row.id), config));
+  for (const row of rows) {
+    syncHistoryFtsIndex(db, row.id);
+  }
+  const BATCH_SIZE = 100;
+  let total = 0;
+  for (let i = 0; i < pending.length; i += BATCH_SIZE) {
+    const batch = pending.slice(i, i + BATCH_SIZE);
+    const embeddings = await generateEmbeddings(batch.map((row) => row.text), config, "document");
+    for (let j = 0; j < batch.length; j++) {
+      storeHistoryEmbedding(db, batch[j].id, batch[j].text, embeddings[j], config);
+      total++;
+    }
+  }
+  rebuildHistoryFtsIndex(db, options);
+  rebuildHistoryVecIndex(db, config, options);
+  return total;
+}
+function verifyHistoryEmbeddings(db, config, options = {}) {
+  const rows = db.select().from(historySnippets).all().filter((row) => !options.repo || row.repo === options.repo);
+  const embeddings = db.select().from(historySnippetEmbeddings).all();
+  const byId = new Map(embeddings.map((row) => [row.snippet_id, row]));
+  let eligible = 0;
+  let stale = 0;
+  for (const row of rows) {
+    eligible++;
+    if (rowNeedsRefresh(row, byId.get(row.id), config)) stale++;
+  }
+  const vec = verifyHistoryVecIndex(db, options);
+  const fts = verifyHistoryFtsIndex(db, options);
+  return {
+    eligible,
+    stored: embeddings.filter((row) => {
+      if (!options.repo) return true;
+      const snippet = rows.find((item) => item.id === row.snippet_id);
+      return snippet?.repo === options.repo;
+    }).length,
+    stale,
+    indexed: vec.indexed,
+    index_drift: vec.drift,
+    lexical_indexed: fts.indexed,
+    lexical_drift: fts.drift
+  };
+}
+function lexicalRankToScore(rank, position) {
+  const safeRank = Number.isFinite(rank) ? Math.abs(rank) : position + 1;
+  return 1 / (1 + safeRank + position);
+}
+async function searchHistorySnippets(db, query, options = {}) {
+  const limit = options.limit ?? 10;
+  const lexicalMatches = searchHistoryFtsIndex(db, query, {
+    repo: options.repo,
+    limit: Math.max(limit * 2, 20)
+  });
+  const config = loadEmbeddingConfigFromEnv();
+  const vectorMatches = config ? searchHistoryVecIndex(db, projectEmbeddingToIndex(
+    await generateEmbedding(query, config, "query"),
+    resolveProvider(config).metadata().index_dimensions
+  ), {
+    repo: options.repo,
+    limit: Math.max(limit * 2, 20)
+  }) : [];
+  const rowsById = new Map(
+    db.select().from(historySnippets).all().map((row) => [row.id, row])
+  );
+  const merged = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lexicalMatches.length; i++) {
+    const match = lexicalMatches[i];
+    const row = rowsById.get(match.snippet_id);
+    if (!row) continue;
+    const lexicalScore = lexicalRankToScore(match.lexical_rank, i);
+    merged.set(match.snippet_id, {
+      snippet: rowToHistorySnippet2(row),
+      score: lexicalScore * 0.35,
+      similarity: 0,
+      lexical_score: lexicalScore
+    });
+  }
+  for (const match of vectorMatches) {
+    const row = rowsById.get(match.snippet_id);
+    if (!row) continue;
+    const similarity = Math.max(0, 1 - match.distance);
+    const existing = merged.get(match.snippet_id);
+    if (existing) {
+      existing.similarity = similarity;
+      existing.score = similarity * 0.65 + existing.lexical_score * 0.35;
+    } else {
+      merged.set(match.snippet_id, {
+        snippet: rowToHistorySnippet2(row),
+        score: similarity * 0.65,
+        similarity,
+        lexical_score: 0
+      });
+    }
+  }
+  return [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// src/models/memory-injections.ts
+import { and as and2, asc, eq as eq6, gt, isNull } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+function recordMemoryInjections(db, input) {
+  if (!input.session_id || input.memory_ids.length === 0) return 0;
+  const injectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let inserted = 0;
+  for (const memoryId of input.memory_ids) {
+    const result = db.insert(memoryInjections).values({
+      id: randomUUID2(),
+      memory_id: memoryId,
+      session_id: input.session_id,
+      repo: input.repo ?? null,
+      injected_at: injectedAt,
+      outcome: null,
+      outcome_at: null
+    }).onConflictDoNothing({
+      target: [memoryInjections.memory_id, memoryInjections.session_id]
+    }).run();
+    inserted += Number(result.changes ?? 0);
+  }
+  return inserted;
+}
+function listInjectedMemoryIdsForSession(db, sessionId) {
+  const rows = db.select({ memory_id: memoryInjections.memory_id }).from(memoryInjections).where(eq6(memoryInjections.session_id, sessionId)).all();
+  return new Set(rows.map((row) => row.memory_id));
+}
+function listPendingMemoryInjections(db, sessionId) {
+  const rows = db.select().from(memoryInjections).where(and2(
+    eq6(memoryInjections.session_id, sessionId),
+    isNull(memoryInjections.outcome)
+  )).orderBy(asc(memoryInjections.injected_at)).all();
+  return rows.map((row) => ({
+    ...rowToMemoryInjection(row),
+    memory: getMemory(db, row.memory_id) ?? null
+  }));
+}
+function resolveMemoryInjectionOutcome(db, memoryId, sessionId, outcome) {
+  const outcomeAt = (/* @__PURE__ */ new Date()).toISOString();
+  const result = db.update(memoryInjections).set({
+    outcome,
+    outcome_at: outcomeAt
+  }).where(and2(
+    eq6(memoryInjections.memory_id, memoryId),
+    eq6(memoryInjections.session_id, sessionId),
+    isNull(memoryInjections.outcome)
+  )).run();
+  return Number(result.changes ?? 0) > 0;
+}
+function pathMatchesMemory(mem, targetPath) {
+  if (!targetPath) return mem.scope === "repo" || mem.scope === "team";
+  if (mem.scope === "repo" || mem.scope === "team") return true;
+  if (!mem.path_scope) return true;
+  const pattern = mem.path_scope;
+  if (pattern.endsWith("**")) {
+    return targetPath.startsWith(pattern.slice(0, -2));
+  }
+  if (pattern.includes("*")) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, "[^/]*").replace(/\*\*/g, ".*") + "$"
+    );
+    return regex.test(targetPath);
+  }
+  return targetPath.startsWith(pattern);
+}
+function toolCallTouchesMemory(mem, toolCall) {
+  if (toolCall.path && pathMatchesMemory(mem, toolCall.path)) return true;
+  if (toolCall.input_summary) {
+    const inferredPath = extractPath(toolCall.input_summary);
+    if (inferredPath && pathMatchesMemory(mem, inferredPath)) return true;
+  }
+  return mem.scope === "repo" || mem.scope === "team";
+}
+function rowToMemoryInjection(row) {
+  return {
+    id: row.id,
+    memory_id: row.memory_id,
+    session_id: row.session_id,
+    repo: row.repo,
+    injected_at: row.injected_at,
+    outcome: row.outcome,
+    outcome_at: row.outcome_at
+  };
+}
+function extractPath(text) {
+  const match = text.match(
+    /\b((?:src|lib|app|components|utils|test|spec)\/[\w./-]+|[\w./-]+\.(?:ts|tsx|js|jsx|py|rs|go|swift|java|rb|json|toml|ya?ml))\b/
+  );
+  return match?.[1];
+}
+
+// src/models/history-injections.ts
+import { eq as eq7 } from "drizzle-orm";
+import { randomUUID as randomUUID3 } from "crypto";
+function recordHistoryInjections(db, input) {
+  if (!input.session_id || input.snippet_ids.length === 0) return 0;
+  const injectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let inserted = 0;
+  for (const snippetId of input.snippet_ids) {
+    const result = db.insert(historyInjections).values({
+      id: randomUUID3(),
+      snippet_id: snippetId,
+      session_id: input.session_id,
+      repo: input.repo ?? null,
+      injected_at: injectedAt
+    }).onConflictDoNothing({
+      target: [historyInjections.snippet_id, historyInjections.session_id]
+    }).run();
+    inserted += Number(result.changes ?? 0);
+  }
+  return inserted;
+}
+function listInjectedHistoryIdsForSession(db, sessionId) {
+  const rows = db.select({ snippet_id: historyInjections.snippet_id }).from(historyInjections).where(eq7(historyInjections.session_id, sessionId)).all();
+  return new Set(rows.map((row) => row.snippet_id));
+}
+
+// src/compiler/context.ts
+var DEFAULT_CONFIG = {
+  confidence_threshold: CONFIDENCE.ACTIVE_MIN,
+  max_lines: 15,
+  max_commands: 3,
+  max_gotchas: 3,
+  max_history_snippets: 2,
+  token_budget: 2e3,
+  include_candidates: false
+};
+var QUERY_RESULT_LIMIT = 2;
+var QUERY_VECTOR_RELEVANCE_FLOOR = 0.7;
+function compileContext(db, req) {
+  const profile = getRepoQualityProfile(db, req.repo);
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...req.config,
+    confidence_threshold: req.config?.confidence_threshold ?? profile.compile_confidence_threshold
+  };
+  const selectedHistory = selectRepoHistory(db, req.repo, config.max_history_snippets);
+  const repoActive = queryMemories(db, {
+    repo: req.repo,
+    status: "active",
+    auto_inject: true
+  });
+  const globalActive = queryMemories(db, {
+    scope: "global",
+    status: "active",
+    auto_inject: true
+  });
+  const allActive = dedupeById([...repoActive, ...globalActive]);
+  const scoped = req.path ? allActive.filter((m) => pathMatches(m, req.path)) : allActive;
+  const passing = scoped.filter(
+    (m) => m.confidence >= config.confidence_threshold
+  );
+  const dropped = scoped.filter(
+    (m) => m.confidence < config.confidence_threshold
+  );
+  if (passing.length === 0 && selectedHistory.length === 0) {
+    return {
+      text: "",
+      memories_included: [],
+      memories_dropped: dropped.map((m) => m.id),
+      history_included: [],
+      token_estimate: 0
+    };
+  }
+  const summaries = getMemoryFeedbackSummaries(db, passing.map((m) => m.id));
+  const scored = passing.map((m) => ({
+    mem: m,
+    score: feedbackWeightedScore(m.confidence, summaries.get(m.id) ?? {
+      followed: 0,
+      overridden: 0,
+      contradicted: 0,
+      ignored: 0,
+      resolved: 0
+    })
+  }));
+  const sorted = scored.sort((a, b) => {
+    const typePrio = typePriority(a.mem.type) - typePriority(b.mem.type);
+    if (typePrio !== 0) return typePrio;
+    return b.score - a.score;
+  }).map((s) => s.mem);
+  const deduped = dedupeMemoriesForInjection(sorted);
+  const selected = [];
+  let commandCount = 0;
+  let gotchaCount = 0;
+  let lineCount = 0;
+  for (const mem of deduped) {
+    const memLines = renderMemoryText(mem).split("\n").length;
+    if (lineCount + memLines > config.max_lines) continue;
+    if (mem.type === "command" && commandCount >= config.max_commands) continue;
+    if (mem.type === "gotcha" && gotchaCount >= config.max_gotchas) continue;
+    selected.push(mem);
+    lineCount += memLines;
+    if (mem.type === "command") commandCount++;
+    if (mem.type === "gotcha") gotchaCount++;
+  }
+  const text = renderPack(selected, req.repo, selectedHistory);
+  const tokenEstimate = Math.ceil(text.length / 4);
+  if (tokenEstimate > config.token_budget) {
+    while (selected.length > 1 && Math.ceil(renderPack(selected, req.repo, selectedHistory).length / 4) > config.token_budget) {
+      selected.pop();
+    }
+  }
+  const finalText = renderPack(selected, req.repo, selectedHistory);
+  recordMemoryInjections(db, {
+    memory_ids: selected.map((memory) => memory.id),
+    session_id: req.session_id,
+    repo: req.repo
+  });
+  recordHistoryInjections(db, {
+    snippet_ids: selectedHistory.map((snippet) => snippet.id),
+    session_id: req.session_id,
+    repo: req.repo
+  });
+  return {
+    text: finalText,
+    memories_included: selected.map((m) => m.id),
+    memories_dropped: [
+      ...dropped.map((m) => m.id),
+      ...sorted.filter((m) => !selected.includes(m)).map((m) => m.id)
+    ],
+    history_included: selectedHistory.map((snippet) => snippet.id),
+    token_estimate: Math.ceil(finalText.length / 4)
+  };
+}
+async function compileContextHybrid(db, req) {
+  const embeddingConfig = req.embedding_config ?? loadEmbeddingConfigFromEnv();
+  const profile = getRepoQualityProfile(db, req.repo);
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...req.config,
+    confidence_threshold: req.config?.confidence_threshold ?? profile.compile_confidence_threshold
+  };
+  const selectedHistory = req.query_text ? await selectRelevantHistory(db, req.repo, req.query_text, config.max_history_snippets) : selectRepoHistory(db, req.repo, config.max_history_snippets);
+  const repoMemories = queryMemories(db, { repo: req.repo });
+  const globalMemories = queryMemories(db, { scope: "global" });
+  const allMemories = dedupeById([...repoMemories, ...globalMemories]).filter(
+    (memory) => memory.auto_inject && (memory.status === "active" || config.include_candidates && memory.status === "candidate")
+  );
+  const scoped = req.path ? allMemories.filter((memory) => pathMatches(memory, req.path)) : allMemories;
+  const candidateConfidenceFloor = Math.min(config.confidence_threshold, 0.45);
+  const passing = scoped.filter((memory) => {
+    if (memory.status === "active") {
+      return memory.confidence >= config.confidence_threshold;
+    }
+    if (memory.status === "candidate" && config.include_candidates) {
+      return memory.confidence >= candidateConfidenceFloor;
+    }
+    return false;
+  });
+  const dropped = scoped.filter((memory) => !passing.includes(memory));
+  if (passing.length === 0 && selectedHistory.length === 0) {
+    return {
+      text: "",
+      memories_included: [],
+      memories_dropped: dropped.map((m) => m.id),
+      history_included: [],
+      token_estimate: 0
+    };
+  }
+  const retrieval = req.query_text ? await hybridSearch(db, req.query_text, embeddingConfig, {
+    repo: req.repo,
+    limit: QUERY_RESULT_LIMIT
+  }) : [];
+  const retrievalById = new Map(
+    retrieval.map((item) => [item.memory.id, item])
+  );
+  const summaries = getMemoryFeedbackSummaries(db, passing.map((m) => m.id));
+  const emptySummary = { followed: 0, overridden: 0, contradicted: 0, ignored: 0, resolved: 0 };
+  const ranked = passing.filter((memory) => {
+    const retrievalItem = retrievalById.get(memory.id);
+    if (req.query_text) {
+      if (!retrievalItem) return false;
+      if (embeddingConfig && retrievalItem.similarity < QUERY_VECTOR_RELEVANCE_FLOOR) {
+        return false;
+      }
+      return true;
+    }
+    if (memory.status !== "candidate") return true;
+    const retrievalScore = retrievalItem?.score ?? 0;
+    return retrievalScore >= 0.2;
+  }).map((memory) => {
+    const retrievalScore = retrievalById.get(memory.id)?.score ?? 0;
+    const weighted = feedbackWeightedScore(memory.confidence, summaries.get(memory.id) ?? emptySummary);
+    const score = req.query_text ? retrievalScore * 0.45 + weighted * 0.25 + scopeScore(memory, req.path) * 0.15 + freshnessScore(memory) * 0.05 + typeScore(memory.type) * 0.1 : weighted * 0.55 + scopeScore(memory, req.path) * 0.2 + freshnessScore(memory) * 0.1 + typeScore(memory.type) * 0.15;
+    return { memory, score };
+  }).sort((a, b) => b.score - a.score);
+  const dedupedRanked = dedupeRankedMemoriesForInjection(ranked);
+  const selected = [];
+  let commandCount = 0;
+  let gotchaCount = 0;
+  let lineCount = 0;
+  for (const item of dedupedRanked) {
+    const memory = item.memory;
+    const memLines = renderMemoryText(memory).split("\n").length;
+    if (lineCount + memLines > config.max_lines) continue;
+    if (memory.type === "command" && commandCount >= config.max_commands) continue;
+    if (memory.type === "gotcha" && gotchaCount >= config.max_gotchas) continue;
+    selected.push(memory);
+    lineCount += memLines;
+    if (memory.type === "command") commandCount++;
+    if (memory.type === "gotcha") gotchaCount++;
+  }
+  if (selected.length === 0) {
+    const historyOnlyText = renderPack([], req.repo, selectedHistory);
+    if (historyOnlyText) {
+      recordHistoryInjections(db, {
+        snippet_ids: selectedHistory.map((snippet) => snippet.id),
+        session_id: req.session_id,
+        repo: req.repo
+      });
+      return {
+        text: historyOnlyText,
+        memories_included: [],
+        memories_dropped: [...dropped, ...passing].map((m) => m.id),
+        history_included: selectedHistory.map((snippet) => snippet.id),
+        token_estimate: Math.ceil(historyOnlyText.length / 4)
+      };
+    }
+    return {
+      text: "",
+      memories_included: [],
+      memories_dropped: [...dropped, ...passing].map((m) => m.id),
+      history_included: [],
+      token_estimate: 0
+    };
+  }
+  while (selected.length > 1 && Math.ceil(renderPack(selected, req.repo, selectedHistory).length / 4) > config.token_budget) {
+    selected.pop();
+  }
+  const finalText = renderPack(selected, req.repo, selectedHistory);
+  recordMemoryInjections(db, {
+    memory_ids: selected.map((memory) => memory.id),
+    session_id: req.session_id,
+    repo: req.repo
+  });
+  recordHistoryInjections(db, {
+    snippet_ids: selectedHistory.map((snippet) => snippet.id),
+    session_id: req.session_id,
+    repo: req.repo
+  });
+  return {
+    text: finalText,
+    memories_included: selected.map((m) => m.id),
+    memories_dropped: [
+      ...dropped.map((m) => m.id),
+      ...ranked.map((item) => item.memory).filter((memory) => !selected.includes(memory)).map((memory) => memory.id)
+    ],
+    history_included: selectedHistory.map((snippet) => snippet.id),
+    token_estimate: Math.ceil(finalText.length / 4)
+  };
+}
+function renderPack(items, repo, history = []) {
+  if (items.length === 0 && history.length === 0) return "";
+  const rules = items.filter((m) => m.type === "rule" || m.type === "decision");
+  const commands = items.filter((m) => m.type === "command");
+  const gotchas = items.filter(
+    (m) => m.type === "gotcha" || m.type === "review_pattern"
+  );
+  const sections = [];
+  if (rules.length > 0) {
+    sections.push(
+      "## Rules\n" + rules.map(renderMemoryBullet).join("\n")
+    );
+  }
+  if (commands.length > 0) {
+    sections.push(
+      "## Commands\n" + commands.map(renderMemoryBullet).join("\n")
+    );
+  }
+  if (gotchas.length > 0) {
+    sections.push(
+      "## Gotchas\n" + gotchas.map(renderMemoryBullet).join("\n")
+    );
+  }
+  if (history.length > 0) {
+    sections.push(
+      "## History\n" + history.map(renderHistorySnippet).join("\n")
+    );
+  }
+  return `# Recall: ${repo}
+
+${sections.join("\n\n")}
+`;
+}
+function renderMemoryBullet(memory) {
+  const prefix = memory.scope === "global" ? "[global] " : "";
+  return `- ${prefix}${renderMemoryText(memory)}`;
+}
+function renderMemoryText(memory) {
+  const text = memory.text.replace(/\r\n/g, "\n").trim();
+  const injectedHeading = text.search(/##\s+(Rules|Commands|Gotchas|History)\b/i);
+  const stripped = injectedHeading > 0 ? text.slice(0, injectedHeading).trim() : text;
+  return stripped.replace(/\s+/g, " ");
+}
+function dedupeMemoriesForInjection(memories4) {
+  const seen = /* @__PURE__ */ new Set();
+  return memories4.filter((memory) => {
+    const key = canonicalInjectionText(memory);
+    if (!key) return false;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function dedupeRankedMemoriesForInjection(ranked) {
+  const seen = /* @__PURE__ */ new Set();
+  return ranked.filter((item) => {
+    const key = canonicalInjectionText(item.memory);
+    if (!key) return false;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function canonicalInjectionText(memory) {
+  return renderMemoryText(memory).toLowerCase().replace(/[`*_]/g, "").replace(/\s+/g, " ").trim();
+}
+var HISTORY_KINDS = /* @__PURE__ */ new Set([
+  "decision_summary",
+  "correction_summary",
+  "review_summary",
+  "repo_synthesis"
+]);
+function selectRepoHistory(db, repo, limit) {
+  if (limit <= 0) return [];
+  return listHistorySnippets(db, { repo, limit: Math.max(limit * 3, 6) }).filter((snippet) => !snippet.session_id && HISTORY_KINDS.has(snippet.kind)).slice(0, limit);
+}
+async function selectRelevantHistory(db, repo, query, limit) {
+  if (limit <= 0) return [];
+  const results = await searchHistorySnippets(db, query, {
+    repo,
+    limit: Math.max(limit * 3, 6)
+  });
+  return results.map((result) => result.snippet).filter((snippet) => HISTORY_KINDS.has(snippet.kind)).slice(0, limit);
+}
+var HISTORY_ENTRY_MAX_CHARS = 120;
+var HISTORY_MAX_ENTRIES_PER_SNIPPET = 2;
+function renderHistorySnippet(snippet) {
+  const lines = snippet.text.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => !line.startsWith("Repo: ") && !line.endsWith(":"));
+  const entries = lines.slice(0, HISTORY_MAX_ENTRIES_PER_SNIPPET).map(
+    (line) => line.length > HISTORY_ENTRY_MAX_CHARS ? line.slice(0, HISTORY_ENTRY_MAX_CHARS - 1).trimEnd() + "\u2026" : line
+  );
+  const body = entries.length > 0 ? entries.join(" | ") : "";
+  return `- [${snippet.kind}] ${body}`;
+}
+function pathMatches(mem, targetPath) {
+  if (mem.scope === "repo" || mem.scope === "team" || mem.scope === "global") return true;
+  if (!mem.path_scope) return true;
+  const pattern = mem.path_scope;
+  if (pattern.endsWith("**")) {
+    const prefix = pattern.slice(0, -2);
+    return targetPath.startsWith(prefix);
+  }
+  if (pattern.includes("*")) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, "[^/]*").replace(/\*\*/g, ".*") + "$"
+    );
+    return regex.test(targetPath);
+  }
+  return targetPath.startsWith(pattern);
+}
+function scopeScore(mem, targetPath) {
+  if (!targetPath) {
+    if (mem.scope === "repo" || mem.scope === "team") return 0.9;
+    if (mem.scope === "global") return 0.8;
+    return 0.7;
+  }
+  if (mem.scope === "global") return 0.8;
+  if (mem.scope === "path" && mem.path_scope) return 1;
+  if (mem.scope === "repo" || mem.scope === "team") return 0.75;
+  return pathMatches(mem, targetPath) ? 0.6 : 0;
+}
+function freshnessScore(mem) {
+  const basis = mem.last_validated_at ?? mem.last_injected_at ?? mem.updated_at;
+  const ageMs = Date.now() - new Date(basis).getTime();
+  const ageDays = ageMs / 864e5;
+  return Math.max(0, 1 - ageDays / 180);
+}
+function typePriority(type) {
+  switch (type) {
+    case "rule":
+      return 0;
+    case "command":
+      return 1;
+    case "gotcha":
+      return 2;
+    case "review_pattern":
+      return 3;
+    case "decision":
+      return 4;
+    default:
+      return 5;
+  }
+}
+function typeScore(type) {
+  switch (type) {
+    case "rule":
+      return 1;
+    case "command":
+      return 0.95;
+    case "decision":
+      return 0.9;
+    case "gotcha":
+      return 0.8;
+    case "review_pattern":
+      return 0.75;
+    default:
+      return 0.5;
+  }
+}
+function dedupeById(memories4) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const m of memories4) {
+    if (seen.has(m.id)) continue;
+    seen.add(m.id);
+    out.push(m);
+  }
+  return out;
+}
+
+// src/adapters/markdown.ts
+function exportMarkdown(db, repo) {
+  const result = compileContext(db, { repo });
+  if (!result.text) {
+    return `# ${repo}
+
+No active memories above confidence threshold.
+`;
+  }
+  return result.text;
+}
+function exportClaude(db, repo) {
+  const result = compileContext(db, { repo });
+  if (!result.text) return "";
+  return `# CLAUDE.md \u2014 Auto-generated by Recall
+# Do not edit manually. Run \`recall export -r ${repo} -f claude\` to regenerate.
+
+${result.text}`;
+}
+function exportCodex(db, repo) {
+  const result = compileContext(db, { repo });
+  if (!result.text) return "";
+  return `# AGENTS.md \u2014 Auto-generated by Recall
+# Do not edit manually. Run \`recall export -r ${repo} -f codex\` to regenerate.
+
+${result.text}`;
+}
+
+// src/repo/discovery.ts
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { execFileSync } from "child_process";
+import { join as join3, resolve } from "path";
+var repoPathCache = /* @__PURE__ */ new Map();
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".venv",
+  "venv"
+]);
+function ensureRepoBootstrapped(db, opts) {
+  const repo = normalizeRepoSlug(opts.repo);
+  const repoPathHint = opts.repoPathHint ?? null;
+  if (!repo && !repoPathHint) {
+    return {
+      repo: null,
+      repo_path: null,
+      created_ids: [],
+      status: "skipped"
+    };
+  }
+  const resolvedRepo = repo ?? inferRepoSlugFromPath(repoPathHint);
+  if (!resolvedRepo) {
+    return {
+      repo: null,
+      repo_path: null,
+      created_ids: [],
+      status: "unresolved"
+    };
+  }
+  if (queryMemories(db, { repo: resolvedRepo }).length > 0) {
+    return {
+      repo: resolvedRepo,
+      repo_path: null,
+      created_ids: [],
+      status: "already_known"
+    };
+  }
+  const repoPath = resolveLocalRepoPath(resolvedRepo, {
+    repoPathHint,
+    searchRoots: opts.searchRoots
+  });
+  if (!repoPath) {
+    return {
+      repo: resolvedRepo,
+      repo_path: null,
+      created_ids: [],
+      status: "unresolved"
+    };
+  }
+  const createdIds = scanAndStore(db, repoPath);
+  return {
+    repo: resolvedRepo,
+    repo_path: repoPath,
+    created_ids: createdIds,
+    status: createdIds.length > 0 ? "bootstrapped" : "scanned_empty"
+  };
+}
+function resolveLocalRepoPath(repo, opts = {}) {
+  const normalizedRepo = normalizeRepoSlug(repo);
+  if (!normalizedRepo) return null;
+  if (repoPathCache.has(normalizedRepo)) {
+    return repoPathCache.get(normalizedRepo) ?? null;
+  }
+  const directHint = normalizeRepoPathHint(opts.repoPathHint);
+  if (directHint && pathMatchesRepo(directHint, normalizedRepo)) {
+    repoPathCache.set(normalizedRepo, directHint);
+    return directHint;
+  }
+  const candidates = collectCandidateRepos(opts.searchRoots ?? getDefaultSearchRoots());
+  const basenameMatches = [];
+  for (const candidate of candidates) {
+    const candidateRepo = inferRepoSlugFromPath(candidate);
+    if (candidateRepo === normalizedRepo) {
+      repoPathCache.set(normalizedRepo, candidate);
+      return candidate;
+    }
+    if (candidate.endsWith(`/${normalizedRepo.split("/").at(-1)}`)) {
+      basenameMatches.push(candidate);
+    }
+  }
+  const fallback = basenameMatches.length === 1 ? basenameMatches[0] : null;
+  repoPathCache.set(normalizedRepo, fallback);
+  return fallback;
+}
+function inferRepoSlugFromPath(repoPath) {
+  const root = normalizeRepoPathHint(repoPath);
+  if (!root) return null;
+  try {
+    const remote = execFileSync(
+      "git",
+      ["-C", root, "remote", "get-url", "origin"],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    return extractRepoSlugFromRemote2(remote);
+  } catch {
+    const parts = root.split("/").filter(Boolean);
+    return parts.at(-1) ?? null;
+  }
+}
+function extractRepoSlugFromRemote2(remote) {
+  const trimmed = remote.trim().replace(/\.git$/, "");
+  const parts = trimmed.split(/[:/]/).filter(Boolean);
+  if (parts.length < 2) return null;
+  return `${parts.at(-2)}/${parts.at(-1)}`;
+}
+function pathMatchesRepo(repoPath, repo) {
+  const inferred = inferRepoSlugFromPath(repoPath);
+  if (inferred === repo) return true;
+  return repoPath.endsWith(`/${repo.split("/").at(-1)}`);
+}
+function normalizeRepoSlug(repo) {
+  if (!repo) return null;
+  const trimmed = repo.trim().replace(/\.git$/, "").replace(/^https?:\/\/[^/]+\//, "");
+  if (!trimmed.includes("/")) return null;
+  return trimmed.replace(/^git@[^:]+:/, "");
+}
+function normalizeRepoPathHint(repoPath) {
+  if (!repoPath) return null;
+  const expanded = repoPath.trim().replace(/^~(?=\/)/, process.env.HOME ?? "~");
+  try {
+    const root = execFileSync(
+      "git",
+      ["-C", expanded, "rev-parse", "--show-toplevel"],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    return root || null;
+  } catch {
+    const resolved = resolve(expanded);
+    return existsSync3(join3(resolved, ".git")) ? resolved : null;
+  }
+}
+function getDefaultSearchRoots() {
+  const configured = process.env.RECALL_REPO_ROOTS?.split(",").map((value) => value.trim()).filter(Boolean);
+  if (configured?.length) return configured;
+  const home = process.env.HOME ?? process.cwd();
+  return [join3(home, "Projects")];
+}
+function collectCandidateRepos(searchRoots) {
+  const seen = /* @__PURE__ */ new Set();
+  const repos = [];
+  for (const root of searchRoots) {
+    walkRepos(resolve(root), 4, seen, repos);
+  }
+  return repos;
+}
+function walkRepos(dir, depthRemaining, seen, repos) {
+  if (depthRemaining < 0 || seen.has(dir) || !existsSync3(dir)) return;
+  seen.add(dir);
+  if (existsSync3(join3(dir, ".git"))) {
+    repos.push(dir);
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (SKIP_DIRS.has(entry.name)) continue;
+    walkRepos(join3(dir, entry.name), depthRemaining - 1, seen, repos);
+  }
+}
+
+// src/artifacts/context.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join4 } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+function getRepoContextArtifactPath(repoPath) {
+  return join4(repoPath, ".recall", "context.md");
+}
+function renderRepoContextArtifact(db, repo) {
+  const compiled = exportMarkdown(db, repo).trimEnd();
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return [
+    "<!-- Auto-generated by Recall. Do not edit manually. -->",
+    `<!-- Generated at: ${generatedAt} -->`,
+    "",
+    "# Recall Context",
+    "",
+    `Repo: \`${repo}\``,
+    "",
+    "Read this file before making repo-specific assumptions.",
+    "",
+    compiled,
+    ""
+  ].join("\n");
+}
+function writeRepoContextArtifact(db, input) {
+  const repo = input.repo ?? inferRepoSlugFromPath(input.repo_path) ?? null;
+  const repoPath = input.repo_path ?? (repo ? resolveLocalRepoPath(repo) : null);
+  if (!repo || !repoPath) {
+    return {
+      repo,
+      repo_path: repoPath,
+      output_path: null,
+      written: false
+    };
+  }
+  const outputPath = getRepoContextArtifactPath(repoPath);
+  mkdirSync2(join4(repoPath, ".recall"), { recursive: true });
+  ensureRepoContextExcluded(repoPath);
+  const content = renderRepoContextArtifact(db, repo);
+  const existing = existsSync4(outputPath) ? readFileSync2(outputPath, "utf-8") : null;
+  if (existing !== content) {
+    writeFileSync(outputPath, content);
+  }
+  return {
+    repo,
+    repo_path: repoPath,
+    output_path: outputPath,
+    written: existing !== content
+  };
+}
+function ensureRepoContextExcluded(repoPath) {
+  try {
+    const excludePath = execFileSync2(
+      "git",
+      ["-C", repoPath, "rev-parse", "--git-path", "info/exclude"],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    if (!excludePath) return;
+    const existing = existsSync4(excludePath) ? readFileSync2(excludePath, "utf-8") : "";
+    if (existing.split("\n").some((line) => line.trim() === ".recall/")) return;
+    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+    writeFileSync(
+      excludePath,
+      `${existing}${prefix}# Recall generated context
+.recall/
+`
+    );
+  } catch {
+  }
+}
+
+// src/eval/harness.ts
+import { eq as eq8, sql, and as and3, gte, like } from "drizzle-orm";
+import { randomUUID as randomUUID4 } from "crypto";
+function startEvalSession(db, repo) {
+  const id = randomUUID4();
+  db.insert(evalSessions).values({
+    id,
+    repo,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+  return id;
+}
+function endEvalSession(db, sessionId) {
+  db.update(evalSessions).set({ ended_at: (/* @__PURE__ */ new Date()).toISOString() }).where(eq8(evalSessions.id, sessionId)).run();
+}
+function incrementEvalCounter(db, sessionId, field, amount = 1) {
+  const col = evalSessions[field];
+  db.update(evalSessions).set({ [field]: sql`${col} + ${amount}` }).where(eq8(evalSessions.id, sessionId)).run();
+}
+function computeMetrics(db, options = {}) {
+  const conditions = [];
+  if (options.repo) conditions.push(eq8(evalSessions.repo, options.repo));
+  if (options.since) conditions.push(gte(evalSessions.started_at, options.since));
+  const sessions = conditions.length > 0 ? db.select().from(evalSessions).where(and3(...conditions)).all() : db.select().from(evalSessions).all();
+  if (sessions.length === 0) {
+    const maintenance2 = computeMaintenanceMetrics(db);
+    return {
+      total_sessions: 0,
+      injection_rate: 0,
+      follow_rate: 0,
+      override_rate: 0,
+      correction_frequency: 0,
+      avg_confidence_at_injection: 0,
+      memory_effectiveness: 0,
+      ...maintenance2 ? { maintenance: maintenance2 } : {}
+    };
+  }
+  const totals = sessions.reduce(
+    (acc, s) => ({
+      injected: acc.injected + s.memories_injected,
+      followed: acc.followed + s.memories_followed,
+      overridden: acc.overridden + s.memories_overridden,
+      corrections: acc.corrections + s.user_corrections,
+      test_passes: acc.test_passes + s.test_passes,
+      test_failures: acc.test_failures + s.test_failures
+    }),
+    {
+      injected: 0,
+      followed: 0,
+      overridden: 0,
+      corrections: 0,
+      test_passes: 0,
+      test_failures: 0
+    }
+  );
+  const totalTests = totals.test_passes + totals.test_failures;
+  const feedbackRows = db.select().from(feedbackEvents).all();
+  const injectedFeedback = feedbackRows.filter((f) => f.injected);
+  let avgConfidence = 0;
+  if (injectedFeedback.length > 0) {
+    const memIds = [...new Set(injectedFeedback.map((f) => f.memory_id))];
+    let totalConf = 0;
+    let count = 0;
+    for (const memId of memIds) {
+      const mem = db.select({ confidence: memories.confidence }).from(memories).where(eq8(memories.id, memId)).get();
+      if (mem) {
+        totalConf += mem.confidence;
+        count++;
+      }
+    }
+    avgConfidence = count > 0 ? totalConf / count : 0;
+  }
+  const effectiveness = totals.injected > 0 ? (totals.followed - totals.overridden) / totals.injected : 0;
+  const maintenance = computeMaintenanceMetrics(db);
+  return {
+    total_sessions: sessions.length,
+    injection_rate: totals.injected / Math.max(sessions.length, 1),
+    follow_rate: totals.injected > 0 ? totals.followed / totals.injected : 0,
+    override_rate: totals.injected > 0 ? totals.overridden / totals.injected : 0,
+    correction_frequency: totals.corrections / Math.max(sessions.length, 1),
+    avg_confidence_at_injection: avgConfidence,
+    memory_effectiveness: effectiveness,
+    ...maintenance ? { maintenance } : {}
+  };
+}
+function computeMaintenanceMetrics(db) {
+  const rows = db.select().from(memoryMaintenanceTasks).all();
+  if (rows.length === 0) return void 0;
+  let completed = 0;
+  let abandoned = 0;
+  const completed_by_kind = {};
+  let completionDurations = [];
+  let mergeCompleted = 0;
+  for (const row of rows) {
+    if (row.status === "completed") {
+      completed += 1;
+      completed_by_kind[row.kind] = (completed_by_kind[row.kind] ?? 0) + 1;
+      if (row.kind === "merge_duplicates") mergeCompleted += 1;
+      if (row.completed_at) {
+        const delta = new Date(row.completed_at).getTime() - new Date(row.created_at).getTime();
+        if (Number.isFinite(delta) && delta >= 0) completionDurations.push(delta);
+      }
+    } else if (row.status === "abandoned") {
+      abandoned += 1;
+    }
+  }
+  const mergeTouched = db.select().from(auditTrail).where(and3(
+    like(auditTrail.reason, "merged_%"),
+    like(auditTrail.actor, "maintenance:%")
+  )).all();
+  const touchedMemoryIds = new Set(mergeTouched.map((r) => r.memory_id));
+  let mergeRollbacks = 0;
+  if (touchedMemoryIds.size > 0) {
+    const rollbacks = db.select().from(auditTrail).where(eq8(auditTrail.action, "rolled_back")).all();
+    for (const r of rollbacks) {
+      if (touchedMemoryIds.has(r.memory_id)) mergeRollbacks += 1;
+    }
+  }
+  const merge_precision = mergeCompleted >= 5 && touchedMemoryIds.size > 0 ? Math.max(0, 1 - mergeRollbacks / touchedMemoryIds.size) : null;
+  const mean_completion_ms = completionDurations.length ? completionDurations.reduce((a, b) => a + b, 0) / completionDurations.length : null;
+  return {
+    total_completed: completed,
+    total_abandoned: abandoned,
+    abandon_rate: completed + abandoned > 0 ? abandoned / (completed + abandoned) : 0,
+    mean_completion_ms,
+    completed_by_kind,
+    merge_precision,
+    merge_rollbacks: mergeRollbacks
+  };
+}
+function formatMetricsReport(metrics) {
+  const pct = (n) => `${(n * 100).toFixed(1)}%`;
+  const lines = [
+    `# Recall Evaluation Report`,
+    ``,
+    `Sessions: ${metrics.total_sessions}`,
+    `Avg memories injected/session: ${metrics.injection_rate.toFixed(1)}`,
+    ``,
+    `## Trust`,
+    `Follow rate:    ${pct(metrics.follow_rate)}`,
+    `Override rate:  ${pct(metrics.override_rate)}`,
+    `Effectiveness:  ${pct(metrics.memory_effectiveness)}`,
+    ``,
+    `## Learning`,
+    `Corrections/session: ${metrics.correction_frequency.toFixed(1)}`,
+    `Avg confidence at injection: ${metrics.avg_confidence_at_injection.toFixed(2)}`
+  ];
+  if (metrics.maintenance) {
+    const m = metrics.maintenance;
+    lines.push(``, `## Maintenance (tier-2)`);
+    lines.push(`Completed tasks:     ${m.total_completed}`);
+    lines.push(`Abandoned tasks:     ${m.total_abandoned}`);
+    lines.push(`Abandon rate:        ${pct(m.abandon_rate)}`);
+    if (m.mean_completion_ms != null) {
+      lines.push(`Mean completion:     ${(m.mean_completion_ms / 1e3).toFixed(1)}s`);
+    }
+    if (m.merge_precision != null) {
+      lines.push(`Merge precision:     ${pct(m.merge_precision)} (rollbacks: ${m.merge_rollbacks})`);
+    }
+    const kinds = Object.entries(m.completed_by_kind).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k}=${n}`).join(", ");
+    if (kinds) lines.push(`By kind: ${kinds}`);
+  }
+  return lines.join("\n");
+}
+
+// src/eval/retrieval.ts
+import { readFileSync as readFileSync3 } from "fs";
+function loadRetrievalEvalFile(path) {
+  return RetrievalEvalFile.parse(JSON.parse(readFileSync3(path, "utf8")));
+}
+async function runRetrievalEval(db, input, options = {}) {
+  const providers = options.providers?.length ? options.providers : ["current"];
+  const providerReports = [];
+  for (const provider of providers) {
+    const cases = [];
+    const embeddingConfig = provider === "current" ? loadEmbeddingConfigFromEnv() : embeddingConfigForProvider(provider);
+    if (embeddingConfig) {
+      await bootstrapEmbeddings(db, embeddingConfig);
+    }
+    for (const raw of input.cases) {
+      const testCase = RetrievalEvalCase.parse(raw);
+      const config = caseConfig(testCase);
+      const baselineCompiled = compileContext(db, {
+        repo: testCase.repo,
+        path: testCase.path,
+        config
+      });
+      const hybridCompiled = await compileContextHybrid(db, {
+        repo: testCase.repo,
+        path: testCase.path,
+        query_text: testCase.query_text,
+        config: {
+          ...config,
+          include_candidates: testCase.include_candidates
+        },
+        embedding_config: embeddingConfig
+      });
+      const baseline = evaluateCaseRun(db, testCase, baselineCompiled.memories_included, baselineCompiled.token_estimate);
+      const hybrid = evaluateCaseRun(db, testCase, hybridCompiled.memories_included, hybridCompiled.token_estimate);
+      cases.push({
+        name: testCase.name,
+        baseline,
+        hybrid,
+        improved: !baseline.passed && hybrid.passed,
+        regressed: baseline.passed && !hybrid.passed
+      });
+    }
+    const total = cases.length;
+    const baselinePassed = cases.filter((item) => item.baseline.passed).length;
+    const hybridPassed = cases.filter((item) => item.hybrid.passed).length;
+    const improved = cases.filter((item) => item.improved).length;
+    const regressed = cases.filter((item) => item.regressed).length;
+    const baselineExpectedAnyHits = cases.filter((item) => item.baseline.expected_any_hit).length;
+    const hybridExpectedAnyHits = cases.filter((item) => item.hybrid.expected_any_hit).length;
+    const baselineForbiddenHits = cases.filter((item) => item.baseline.forbidden_hits.length > 0).length;
+    const hybridForbiddenHits = cases.filter((item) => item.hybrid.forbidden_hits.length > 0).length;
+    const reciprocalRanks = cases.map((item) => item.hybrid.first_expected_rank).filter((rank) => rank != null).map((rank) => 1 / rank);
+    providerReports.push({
+      provider,
+      summary: {
+        total_cases: total,
+        baseline_passed: baselinePassed,
+        hybrid_passed: hybridPassed,
+        improved_cases: improved,
+        regressed_cases: regressed,
+        baseline_expected_any_hit_rate: ratio(baselineExpectedAnyHits, total),
+        hybrid_expected_any_hit_rate: ratio(hybridExpectedAnyHits, total),
+        baseline_forbidden_hit_rate: ratio(baselineForbiddenHits, total),
+        hybrid_forbidden_hit_rate: ratio(hybridForbiddenHits, total)
+      },
+      metrics: {
+        recall_at_k: ratio(hybridExpectedAnyHits, total),
+        mrr: reciprocalRanks.length > 0 ? reciprocalRanks.reduce((sum, value) => sum + value, 0) / total : 0,
+        override_rate: ratio(hybridForbiddenHits, total)
+      },
+      cases
+    });
+  }
+  return {
+    summary: providerReports[0].summary,
+    cases: providerReports[0].cases,
+    provider_reports: providerReports
+  };
+}
+function formatRetrievalEvalReport(report) {
+  const pct = (value) => `${(value * 100).toFixed(1)}%`;
+  if (report.provider_reports.length > 1) {
+    const lines = [
+      "# Retrieval Eval",
+      "",
+      "## Provider Comparison"
+    ];
+    for (const provider of report.provider_reports) {
+      lines.push(
+        `- ${provider.provider}: passed=${provider.summary.hybrid_passed}/${provider.summary.total_cases} recall@k=${pct(provider.metrics.recall_at_k)} mrr=${provider.metrics.mrr.toFixed(3)} override=${pct(provider.metrics.override_rate)}`
+      );
+    }
+    for (const provider of report.provider_reports) {
+      lines.push("", `## ${provider.provider}`);
+      lines.push(formatSingleProviderReport(provider.summary, provider.cases));
+    }
+    return lines.join("\n");
+  }
+  return formatSingleProviderReport(report.summary, report.cases);
+}
+function formatSingleProviderReport(summary, cases) {
+  const pct = (value) => `${(value * 100).toFixed(1)}%`;
+  const lines = [
+    "# Retrieval Eval",
+    "",
+    `Cases: ${summary.total_cases}`,
+    `Baseline passed: ${summary.baseline_passed}`,
+    `Hybrid passed:   ${summary.hybrid_passed}`,
+    `Improved:        ${summary.improved_cases}`,
+    `Regressed:       ${summary.regressed_cases}`,
+    "",
+    `Baseline expected-any hit rate: ${pct(summary.baseline_expected_any_hit_rate)}`,
+    `Hybrid expected-any hit rate:   ${pct(summary.hybrid_expected_any_hit_rate)}`,
+    `Baseline forbidden hit rate:    ${pct(summary.baseline_forbidden_hit_rate)}`,
+    `Hybrid forbidden hit rate:      ${pct(summary.hybrid_forbidden_hit_rate)}`
+  ];
+  const failedCases = cases.filter((item) => !item.hybrid.passed || item.regressed || item.improved);
+  if (failedCases.length > 0) {
+    lines.push("", "## Case Details");
+    for (const item of failedCases) {
+      lines.push(`- ${item.name}`);
+      lines.push(`  baseline: ${describeRun(item.baseline)}`);
+      lines.push(`  hybrid:   ${describeRun(item.hybrid)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function caseConfig(testCase) {
+  return {
+    ...testCase.confidence_threshold != null ? { confidence_threshold: testCase.confidence_threshold } : {},
+    ...testCase.max_lines != null ? { max_lines: testCase.max_lines } : {},
+    ...testCase.max_commands != null ? { max_commands: testCase.max_commands } : {},
+    ...testCase.max_gotchas != null ? { max_gotchas: testCase.max_gotchas } : {},
+    ...testCase.token_budget != null ? { token_budget: testCase.token_budget } : {}
+  };
+}
+function evaluateCaseRun(db, testCase, memoryIds, tokenEstimate) {
+  const includedTexts = memoryIds.map((id) => getMemory(db, id)?.text).filter((text) => Boolean(text));
+  const expectedAllMissing = testCase.expected_all_texts.filter((expected) => !includedTexts.includes(expected));
+  const expectedAnyHit = testCase.expected_any_texts.length === 0 ? true : testCase.expected_any_texts.some((expected) => includedTexts.includes(expected));
+  const forbiddenHits = testCase.forbidden_texts.filter((forbidden) => includedTexts.includes(forbidden));
+  const relevantTexts = [
+    ...testCase.expected_all_texts,
+    ...testCase.expected_any_texts
+  ];
+  const firstExpectedRank = relevantTexts.length === 0 ? null : includedTexts.findIndex((text) => relevantTexts.includes(text)) + 1 || null;
+  let countViolation;
+  if (testCase.min_included != null && memoryIds.length < testCase.min_included) {
+    countViolation = `included ${memoryIds.length} < min ${testCase.min_included}`;
+  } else if (testCase.max_included != null && memoryIds.length > testCase.max_included) {
+    countViolation = `included ${memoryIds.length} > max ${testCase.max_included}`;
+  }
+  const passed = expectedAllMissing.length === 0 && expectedAnyHit && forbiddenHits.length === 0 && !countViolation;
+  return {
+    included_ids: memoryIds,
+    included_texts: includedTexts,
+    token_estimate: tokenEstimate,
+    passed,
+    expected_all_missing: expectedAllMissing,
+    expected_any_hit: expectedAnyHit,
+    forbidden_hits: forbiddenHits,
+    first_expected_rank: firstExpectedRank,
+    count_violation: countViolation
+  };
+}
+function describeRun(result) {
+  const parts = [
+    result.passed ? "pass" : "fail",
+    `included=${result.included_ids.length}`
+  ];
+  if (result.expected_all_missing.length > 0) {
+    parts.push(`missing_all=${result.expected_all_missing.join(" | ")}`);
+  }
+  if (!result.expected_any_hit) {
+    parts.push("expected_any=miss");
+  }
+  if (result.forbidden_hits.length > 0) {
+    parts.push(`forbidden=${result.forbidden_hits.join(" | ")}`);
+  }
+  if (result.count_violation) {
+    parts.push(result.count_violation);
+  }
+  return parts.join(" ; ");
+}
+function ratio(value, total) {
+  return total > 0 ? value / total : 0;
+}
+function embeddingConfigForProvider(provider) {
+  const overrideDimensions = process.env.RECALL_EMBEDDING_DIMS ? parseInt(process.env.RECALL_EMBEDDING_DIMS, 10) : null;
+  if (provider === "bge-small-en-v1.5") {
+    return {
+      provider,
+      model: "Xenova/bge-small-en-v1.5",
+      dimensions: overrideDimensions ?? 384,
+      version: "eval",
+      similarity_threshold: 0.8
+    };
+  }
+  if (provider === "multilingual-e5") {
+    return {
+      provider,
+      model: "Xenova/multilingual-e5-small",
+      dimensions: overrideDimensions ?? 384,
+      version: "eval",
+      similarity_threshold: 0.8
+    };
+  }
+  return {
+    provider: "nomic",
+    model: "nomic-ai/nomic-embed-text-v1.5",
+    dimensions: overrideDimensions ?? 512,
+    version: "eval",
+    similarity_threshold: 0.8
+  };
+}
+
+// src/feedback/implicit.ts
+import { eq as eq9 } from "drizzle-orm";
+import { randomUUID as randomUUID5 } from "crypto";
+import { execSync as execSync2 } from "child_process";
+var SIGNAL_WEIGHTS = {
+  test_pass: 0.03,
+  test_fail: -0.15,
+  file_unchanged: 0.02,
+  file_rewritten: -0.1,
+  task_accepted: 0.05,
+  task_rejected: -0.2
+};
+function recordSignal(db, memoryId, sessionId, signalType, context) {
+  const id = randomUUID5();
+  db.insert(implicitSignals).values({
+    id,
+    memory_id: memoryId,
+    session_id: sessionId,
+    signal_type: signalType,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    context: context ?? null
+  }).run();
+  const weight = SIGNAL_WEIGHTS[signalType];
+  if (weight > 0) {
+    promoteMemory(db, memoryId, "passive_gain");
+  } else if (weight < 0) {
+    demoteMemory(db, memoryId, `implicit:${signalType}`);
+  }
+  return id;
+}
+function getSignals(db, memoryId) {
+  return db.select().from(implicitSignals).where(eq9(implicitSignals.memory_id, memoryId)).all();
+}
+function runTests(repoPath, command) {
+  try {
+    const output = execSync2(command, {
+      cwd: repoPath,
+      encoding: "utf-8",
+      timeout: 12e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { passed: true, output };
+  } catch (err) {
+    return {
+      passed: false,
+      output: err.stdout ?? err.stderr ?? err.message
+    };
+  }
+}
+function recordTestSignals(db, sessionId, injectedMemoryIds, testResult) {
+  const signalType = testResult.passed ? "test_pass" : "test_fail";
+  const ids = [];
+  for (const memId of injectedMemoryIds) {
+    const id = recordSignal(
+      db,
+      memId,
+      sessionId,
+      signalType,
+      testResult.output?.slice(0, 500)
+    );
+    ids.push(id);
+  }
+  return ids;
+}
+function getSignalStats(db, memoryId) {
+  const signals = getSignals(db, memoryId);
+  const stats = {
+    test_pass: 0,
+    test_fail: 0,
+    file_unchanged: 0,
+    file_rewritten: 0,
+    task_accepted: 0,
+    task_rejected: 0
+  };
+  for (const s of signals) {
+    stats[s.signal_type] = (stats[s.signal_type] ?? 0) + 1;
+  }
+  return stats;
+}
+
+// src/policy/engine.ts
+import { eq as eq10, and as and4 } from "drizzle-orm";
+import { randomUUID as randomUUID6 } from "crypto";
+function createPolicy(db, orgId, ruleType, config) {
+  const id = randomUUID6();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(policyRules).values({
+    id,
+    org_id: orgId,
+    rule_type: ruleType,
+    config,
+    enabled: true,
+    created_at: now2,
+    updated_at: now2
+  }).run();
+  return id;
+}
+function listPolicies(db, orgId) {
+  return db.select().from(policyRules).where(eq10(policyRules.org_id, orgId)).all().map(rowToPolicy);
+}
+function togglePolicy(db, policyId, enabled) {
+  db.update(policyRules).set({ enabled, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).where(eq10(policyRules.id, policyId)).run();
+}
+function deletePolicy(db, policyId) {
+  db.delete(policyRules).where(eq10(policyRules.id, policyId)).run();
+}
+function evaluatePolicy(db, orgId, memory) {
+  const rules = listPolicies(db, orgId).filter((r) => r.enabled);
+  const violations = [];
+  for (const rule of rules) {
+    const cfg = rule.config;
+    switch (rule.rule_type) {
+      case "min_confidence": {
+        const min = cfg.min_confidence ?? 0.6;
+        if (memory.confidence < min) {
+          violations.push({
+            rule_id: rule.id,
+            rule_type: rule.rule_type,
+            message: `Confidence ${memory.confidence.toFixed(2)} below minimum ${min}`,
+            blocking: true
+          });
+        }
+        break;
+      }
+      case "require_approval": {
+        const forTypes = cfg.for_types;
+        if (!forTypes || forTypes.includes(memory.type)) {
+          violations.push({
+            rule_id: rule.id,
+            rule_type: rule.rule_type,
+            message: `Memory type "${memory.type}" requires approval before activation`,
+            blocking: true
+          });
+        }
+        break;
+      }
+      case "allowed_sources": {
+        const allowed = cfg.sources;
+        if (allowed && !allowed.includes(memory.source)) {
+          violations.push({
+            rule_id: rule.id,
+            rule_type: rule.rule_type,
+            message: `Source "${memory.source}" not in allowed list: ${allowed.join(", ")}`,
+            blocking: true
+          });
+        }
+        break;
+      }
+      case "blocked_scopes": {
+        const blocked = cfg.scopes;
+        if (blocked && blocked.includes(memory.scope)) {
+          violations.push({
+            rule_id: rule.id,
+            rule_type: rule.rule_type,
+            message: `Scope "${memory.scope}" is blocked by policy`,
+            blocking: true
+          });
+        }
+        break;
+      }
+      case "max_active_per_repo": {
+        const max = cfg.max ?? 50;
+        if (memory.repo) {
+          const active = queryMemories(db, { repo: memory.repo, status: "active" });
+          if (active.length >= max) {
+            violations.push({
+              rule_id: rule.id,
+              rule_type: rule.rule_type,
+              message: `Repo "${memory.repo}" has ${active.length}/${max} active memories`,
+              blocking: true
+            });
+          }
+        }
+        break;
+      }
+      case "require_evidence_count": {
+        const minEvidence = cfg.min_evidence ?? 2;
+        if (memory.evidence.length < minEvidence) {
+          violations.push({
+            rule_id: rule.id,
+            rule_type: rule.rule_type,
+            message: `Memory has ${memory.evidence.length} evidence entries, needs ${minEvidence}`,
+            blocking: true
+          });
+        }
+        break;
+      }
+      case "auto_approve_pattern": {
+        break;
+      }
+    }
+  }
+  return violations;
+}
+function requestApproval(db, memoryId, orgId, requestedBy) {
+  const id = randomUUID6();
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  db.insert(approvalRequests).values({
+    id,
+    memory_id: memoryId,
+    org_id: orgId,
+    requested_by: requestedBy,
+    status: "pending",
+    created_at: now2
+  }).run();
+  recordAudit(db, memoryId, "approval_requested", requestedBy, null);
+  return id;
+}
+function resolveApproval(db, approvalId, status, reviewedBy, reason) {
+  const row = db.select().from(approvalRequests).where(eq10(approvalRequests.id, approvalId)).get();
+  if (!row) return false;
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  db.update(approvalRequests).set({
+    status,
+    reviewed_by: reviewedBy,
+    reason: reason ?? null,
+    resolved_at: now2
+  }).where(eq10(approvalRequests.id, approvalId)).run();
+  if (status === "approved") {
+    confirmMemory(db, row.memory_id);
+  } else {
+    rejectMemory(db, row.memory_id);
+  }
+  recordAudit(db, row.memory_id, "approval_resolved", reviewedBy, reason ?? null);
+  return true;
+}
+function listPendingApprovals(db, orgId) {
+  return db.select().from(approvalRequests).where(
+    and4(
+      eq10(approvalRequests.org_id, orgId),
+      eq10(approvalRequests.status, "pending")
+    )
+  ).all();
+}
+function rowToPolicy(row) {
+  return {
+    ...row,
+    config: typeof row.config === "string" ? JSON.parse(row.config) : row.config ?? {},
+    enabled: Boolean(row.enabled)
+  };
+}
+
+// src/pruning/pruner.ts
+import { eq as eq11 } from "drizzle-orm";
+var DEFAULT_CONFIG2 = {
+  stale_days: 90,
+  rejected_retention_days: 30,
+  transient_retention_days: 7,
+  min_health_score: 0.2,
+  dry_run: false
+};
+function pruneMemories(db, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
+  const now2 = Date.now();
+  const dayMs = 864e5;
+  const result = {
+    stale_rejected: [],
+    rejected_pruned: [],
+    transient_pruned: [],
+    unhealthy_demoted: [],
+    total: 0
+  };
+  const staleCutoff = new Date(now2 - cfg.stale_days * dayMs).toISOString();
+  const staleCandidates = queryMemories(db, {
+    repo: cfg.repo,
+    limit: void 0
+  }).filter((mem) => mem.status !== "rejected" && mem.status !== "transient");
+  for (const mem of staleCandidates) {
+    const lastActivity = mem.last_validated_at ?? mem.last_injected_at ?? mem.updated_at;
+    if (lastActivity < staleCutoff) {
+      if (!cfg.dry_run) {
+        db.update(memories).set({ status: "rejected", dedupe_key: null, updated_at: (/* @__PURE__ */ new Date()).toISOString() }).where(eq11(memories.id, mem.id)).run();
+        queueMemoryEmbeddingSync(db, mem.id);
+        recordAudit(db, mem.id, "rejected", "auto-pruner", `Stale: no activity since ${lastActivity}`);
+      }
+      result.stale_rejected.push(mem.id);
+    }
+  }
+  const rejectedCutoff = new Date(
+    now2 - cfg.rejected_retention_days * dayMs
+  ).toISOString();
+  const rejectedMemories = queryMemories(db, {
+    repo: cfg.repo,
+    status: "rejected"
+  });
+  for (const mem of rejectedMemories) {
+    if (mem.updated_at < rejectedCutoff) {
+      if (!cfg.dry_run) {
+        db.delete(memories).where(eq11(memories.id, mem.id)).run();
+        recordAudit(db, mem.id, "pruned", "auto-pruner", `Rejected memory past ${cfg.rejected_retention_days}d retention`);
+      }
+      result.rejected_pruned.push(mem.id);
+    }
+  }
+  const transientCutoff = new Date(
+    now2 - cfg.transient_retention_days * dayMs
+  ).toISOString();
+  const transientMemories = queryMemories(db, {
+    repo: cfg.repo,
+    status: "transient"
+  });
+  for (const mem of transientMemories) {
+    if (mem.updated_at < transientCutoff) {
+      if (!cfg.dry_run) {
+        db.delete(memories).where(eq11(memories.id, mem.id)).run();
+        recordAudit(db, mem.id, "pruned", "auto-pruner", `Transient memory past ${cfg.transient_retention_days}d retention`);
+      }
+      result.transient_pruned.push(mem.id);
+    }
+  }
+  const activeMemories = queryMemories(db, {
+    repo: cfg.repo,
+    status: "active"
+  });
+  for (const mem of activeMemories) {
+    const health = computeHealthScore(db, mem.id);
+    if (health && health.score < cfg.min_health_score) {
+      if (!cfg.dry_run) {
+        db.update(memories).set({ status: "candidate", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).where(eq11(memories.id, mem.id)).run();
+        queueMemoryEmbeddingSync(db, mem.id);
+        recordAudit(
+          db,
+          mem.id,
+          "demoted",
+          "auto-pruner",
+          `Health score ${health.score.toFixed(2)} below threshold ${cfg.min_health_score}`
+        );
+      }
+      result.unhealthy_demoted.push(mem.id);
+    }
+  }
+  result.total = result.stale_rejected.length + result.rejected_pruned.length + result.transient_pruned.length + result.unhealthy_demoted.length;
+  return result;
+}
+function formatPruneReport(result, dryRun) {
+  const prefix = dryRun ? "[DRY RUN] " : "";
+  const lines = [
+    `${prefix}Prune Report`,
+    ``,
+    `Stale rejected:    ${result.stale_rejected.length}`,
+    `Rejected pruned:   ${result.rejected_pruned.length}`,
+    `Transient pruned:  ${result.transient_pruned.length}`,
+    `Unhealthy demoted: ${result.unhealthy_demoted.length}`,
+    `Total affected:    ${result.total}`
+  ];
+  if (result.stale_rejected.length > 0) {
+    lines.push("", "Stale Rejected:");
+    for (const id of result.stale_rejected.slice(0, 10)) {
+      lines.push(`  ${id.slice(0, 8)}`);
+    }
+  }
+  if (result.unhealthy_demoted.length > 0) {
+    lines.push("", "Unhealthy:");
+    for (const id of result.unhealthy_demoted.slice(0, 10)) {
+      lines.push(`  ${id.slice(0, 8)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/models/activity.ts
+import { and as and5, desc as desc2, eq as eq12, gte as gte2 } from "drizzle-orm";
+import { randomUUID as randomUUID7 } from "crypto";
+function createActivityEvent(db, input) {
+  const dedupeKey = activityEventDedupeKey(input);
+  const duplicateId = findDuplicateActivityEvent(db, input, dedupeKey);
+  if (duplicateId) return duplicateId;
+  const id = randomUUID7();
+  db.insert(activityEvents).values({
+    id,
+    session_id: input.session_id ?? null,
+    repo: input.repo ?? null,
+    path: input.path ?? null,
+    source: input.source,
+    event_type: input.event_type,
+    memory_ids: input.memory_ids ?? [],
+    dedupe_key: dedupeKey,
+    request: input.request ?? {},
+    result: input.result ?? {},
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  }).run();
+  return id;
+}
+function findDuplicateActivityEvent(db, input, dedupeKey) {
+  if (!input.session_id) return null;
+  if (dedupeKey) {
+    const existing = db.select().from(activityEvents).where(eq12(activityEvents.dedupe_key, dedupeKey)).get();
+    if (existing) return existing.id;
+  }
+  const since = new Date(Date.now() - 2e3).toISOString();
+  const rows = db.select().from(activityEvents).where(and5(
+    eq12(activityEvents.session_id, input.session_id),
+    eq12(activityEvents.source, input.source),
+    eq12(activityEvents.event_type, input.event_type),
+    gte2(activityEvents.created_at, since)
+  )).all();
+  const requestKey = JSON.stringify(input.request ?? {});
+  const resultKey = JSON.stringify(input.result ?? {});
+  const repo = input.repo ?? null;
+  const path = input.path ?? null;
+  for (const row of rows) {
+    if (row.repo !== repo || row.path !== path) continue;
+    const request = typeof row.request === "string" ? JSON.parse(row.request) : row.request ?? {};
+    const result = typeof row.result === "string" ? JSON.parse(row.result) : row.result ?? {};
+    if (JSON.stringify(request) === requestKey && JSON.stringify(result) === resultKey) {
+      return row.id;
+    }
+  }
+  return null;
+}
+function listActivityEvents(db, query = {}) {
+  const conditions = [];
+  if (query.repo) conditions.push(eq12(activityEvents.repo, query.repo));
+  if (query.session_id) conditions.push(eq12(activityEvents.session_id, query.session_id));
+  if (query.source) conditions.push(eq12(activityEvents.source, query.source));
+  if (query.event_type) conditions.push(eq12(activityEvents.event_type, query.event_type));
+  if (query.since) conditions.push(gte2(activityEvents.created_at, query.since));
+  const base = db.select().from(activityEvents);
+  const rows = conditions.length > 0 ? base.where(and5(...conditions)).orderBy(desc2(activityEvents.created_at)).all() : base.orderBy(desc2(activityEvents.created_at)).all();
+  const limited = query.limit ? rows.slice(0, query.limit) : rows;
+  return limited.map(rowToActivityEvent);
+}
+function listActivitySessions(db, query = {}) {
+  const events = listActivityEvents(db, query).filter((event) => event.session_id);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const sessionId = event.session_id;
+    const bucket = grouped.get(sessionId) ?? [];
+    bucket.push(event);
+    grouped.set(sessionId, bucket);
+  }
+  const sessions = [...grouped.entries()].map(([session_id, items]) => {
+    const sorted = [...items].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    return {
+      session_id,
+      repo: sorted[0]?.repo ?? null,
+      event_count: items.length,
+      event_types: [...new Set(items.map((item) => item.event_type))],
+      first_at: sorted[0].created_at,
+      last_at: sorted[sorted.length - 1].created_at
+    };
+  });
+  sessions.sort((a, b) => b.last_at.localeCompare(a.last_at));
+  return query.limit ? sessions.slice(0, query.limit) : sessions;
+}
+function rowToActivityEvent(row) {
+  const memory_ids = typeof row.memory_ids === "string" ? JSON.parse(row.memory_ids) : Array.isArray(row.memory_ids) ? row.memory_ids : [];
+  const request = typeof row.request === "string" ? JSON.parse(row.request) : row.request ?? {};
+  const result = typeof row.result === "string" ? JSON.parse(row.result) : row.result ?? {};
+  return {
+    id: row.id,
+    session_id: row.session_id,
+    repo: row.repo,
+    path: row.path,
+    source: row.source,
+    event_type: row.event_type,
+    memory_ids,
+    request,
+    result,
+    created_at: row.created_at
+  };
+}
+
+// src/session/lifecycle.ts
+function resolveLifecycleSource(input) {
+  if (input.source) return input.source;
+  return input.client ? tagActivitySource("hook", input.client) : "daemon";
+}
+function startSessionLifecycle(db, input) {
+  const repo = input.repo ?? inferRepoSlugFromPath(input.repo_path) ?? null;
+  const bootstrap = ensureRepoBootstrapped(db, {
+    repo,
+    repoPathHint: input.repo_path
+  });
+  if (bootstrap.status === "bootstrapped" || bootstrap.status === "scanned_empty") {
+    createActivityEvent(db, {
+      session_id: input.session_id,
+      repo: bootstrap.repo,
+      path: input.path ?? null,
+      source: resolveLifecycleSource(input),
+      event_type: "scan",
+      memory_ids: bootstrap.created_ids,
+      request: {
+        repo_path: bootstrap.repo_path,
+        client: input.client ?? null,
+        trigger: "session_start_bootstrap"
+      },
+      result: {
+        created: bootstrap.created_ids.length,
+        status: bootstrap.status
+      }
+    });
+  }
+  const artifact = writeRepoContextArtifact(db, {
+    repo: bootstrap.repo,
+    repo_path: bootstrap.repo_path ?? input.repo_path ?? null
+  });
+  createActivityEvent(db, {
+    session_id: input.session_id,
+    repo: bootstrap.repo,
+    path: input.path ?? null,
+    source: resolveLifecycleSource(input),
+    event_type: "session_start",
+    request: {
+      client: input.client ?? null,
+      repo_path: bootstrap.repo_path ?? input.repo_path ?? null,
+      meta: input.meta ?? {}
+    },
+    result: {
+      bootstrap_status: bootstrap.status,
+      created: bootstrap.created_ids.length,
+      artifact_path: artifact.output_path,
+      artifact_written: artifact.written
+    }
+  });
+  return {
+    session_id: input.session_id,
+    repo: bootstrap.repo,
+    repo_path: bootstrap.repo_path ?? input.repo_path ?? null,
+    bootstrap_status: bootstrap.status,
+    created_ids: bootstrap.created_ids
+  };
+}
+function recordSessionLifecycleEvent(db, input) {
+  const repo = input.repo ?? inferRepoSlugFromPath(input.repo_path) ?? null;
+  createActivityEvent(db, {
+    session_id: input.session_id,
+    repo,
+    path: input.path ?? null,
+    source: resolveLifecycleSource(input),
+    event_type: "session_event",
+    request: {
+      client: input.client ?? null,
+      name: input.name,
+      repo_path: input.repo_path ?? null,
+      meta: input.meta ?? {}
+    },
+    result: input.payload ?? {}
+  });
+  return {
+    session_id: input.session_id,
+    repo,
+    repo_path: input.repo_path ?? null,
+    bootstrap_status: "skipped",
+    created_ids: []
+  };
+}
+function endSessionLifecycle(db, input) {
+  const repo = input.repo ?? inferRepoSlugFromPath(input.repo_path) ?? null;
+  createActivityEvent(db, {
+    session_id: input.session_id,
+    repo,
+    path: input.path ?? null,
+    source: resolveLifecycleSource(input),
+    event_type: "session_end",
+    request: {
+      client: input.client ?? null,
+      repo_path: input.repo_path ?? null,
+      meta: input.meta ?? {}
+    },
+    result: input.payload ?? {}
+  });
+  return {
+    session_id: input.session_id,
+    repo,
+    repo_path: input.repo_path ?? null,
+    bootstrap_status: "skipped",
+    created_ids: []
+  };
+}
+
+// src/mcp/fallback.ts
+async function captureCorrectionFallback(db, input, source) {
+  const sessionId = input.session_id ?? `${source}-capture`;
+  const ids = await processCorrection(db, input.text, {
+    sessionId,
+    repo: input.repo,
+    path: input.path,
+    agent: input.agent,
+    prev_assistant_turn: input.prev_assistant_turn,
+    recent_tool_calls: input.recent_tool_calls
+  });
+  createActivityEvent(db, {
+    session_id: sessionId,
+    repo: input.repo ?? null,
+    path: input.path ?? null,
+    source,
+    event_type: "correction",
+    memory_ids: ids,
+    request: {
+      agent: input.agent ?? null,
+      prev_assistant_turn: input.prev_assistant_turn ?? null,
+      recent_tool_calls: normalizeRecentToolCalls(input.recent_tool_calls),
+      text: input.text
+    },
+    result: {
+      created: ids,
+      created_count: ids.length
+    }
+  });
+  return {
+    ids,
+    session_id: sessionId
+  };
+}
+function signalOutcomeFallback(db, input, source) {
+  const feedbackId = recordFeedback(
+    db,
+    input.memory_id,
+    input.session_id,
+    input.injected ?? true,
+    input.outcome
+  );
+  resolveMemoryInjectionOutcome(db, input.memory_id, input.session_id, input.outcome);
+  const memory = getMemory(db, input.memory_id);
+  createActivityEvent(db, {
+    session_id: input.session_id,
+    repo: memory?.repo ?? null,
+    path: memory?.path_scope ?? null,
+    source,
+    event_type: "feedback",
+    memory_ids: [input.memory_id],
+    request: {
+      context: input.context ?? null,
+      injected: input.injected ?? true,
+      outcome: input.outcome
+    },
+    result: {
+      feedback_id: feedbackId
+    }
+  });
+  return {
+    feedback_id: feedbackId
+  };
+}
+function sessionEndFallback(db, input) {
+  const result = endSessionLifecycle(db, {
+    session_id: input.session_id,
+    client: input.agent ?? "mcp",
+    repo: input.repo ?? null,
+    repo_path: input.repo_path ?? null,
+    path: input.path ?? null,
+    payload: {
+      ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+      turn_count: input.turn_count ?? null
+    }
+  });
+  return {
+    session_id: result.session_id,
+    repo: result.repo
+  };
+}
+function normalizeRecentToolCalls(toolCalls) {
+  if (!toolCalls) return [];
+  return toolCalls.map((toolCall) => ({
+    name: toolCall.name,
+    path: toolCall.path,
+    input_summary: toolCall.input_summary,
+    exit_code: toolCall.exit_code
+  }));
+}
+
+export {
+  RECALL_DB_USER_VERSION,
+  getDbPath,
+  initDb,
+  getDbUserVersion,
+  resetDb,
+  evaluateScannedMemory,
+  scanAndStore,
+  listInjectedMemoryIdsForSession,
+  listPendingMemoryInjections,
+  pathMatchesMemory,
+  toolCallTouchesMemory,
+  listInjectedHistoryIdsForSession,
+  createHistorySnippet,
+  listHistorySnippets,
+  findHistorySnippetBySession,
+  findHistorySnippetByRepoKind,
+  updateHistorySnippet,
+  removeHistoryVecRow,
+  removeHistoryFtsRow,
+  syncHistoryFtsIndex,
+  bootstrapHistoryEmbeddings,
+  verifyHistoryEmbeddings,
+  searchHistorySnippets,
+  compileContext,
+  compileContextHybrid,
+  exportMarkdown,
+  exportClaude,
+  exportCodex,
+  ensureRepoBootstrapped,
+  inferRepoSlugFromPath,
+  writeRepoContextArtifact,
+  startEvalSession,
+  endEvalSession,
+  incrementEvalCounter,
+  computeMetrics,
+  formatMetricsReport,
+  loadRetrievalEvalFile,
+  runRetrievalEval,
+  formatRetrievalEvalReport,
+  recordSignal,
+  runTests,
+  recordTestSignals,
+  getSignalStats,
+  createPolicy,
+  listPolicies,
+  togglePolicy,
+  deletePolicy,
+  evaluatePolicy,
+  requestApproval,
+  resolveApproval,
+  listPendingApprovals,
+  pruneMemories,
+  formatPruneReport,
+  createActivityEvent,
+  listActivityEvents,
+  listActivitySessions,
+  startSessionLifecycle,
+  recordSessionLifecycleEvent,
+  endSessionLifecycle,
+  captureCorrectionFallback,
+  signalOutcomeFallback,
+  sessionEndFallback
+};
+//# sourceMappingURL=chunk-PC43MBX5.js.map