akm-cli 0.9.0-beta.45 → 0.9.0-beta.47

package/dist/scripts/migrate-storage.js

@@ -8751,11 +8751,15 @@ var init_paths = __esm(() => {
 
 // src/storage/database.ts
 import { createRequire } from "module";
-function openDatabase(path5, opts) {
-  if (isBun) {
-    return openBunDatabase(path5, opts);
+function selectProvider() {
+  const provider = PROVIDERS.find((p) => p.supported());
+  if (!provider) {
+    throw new Error(`No storage provider supports the current runtime (${isBun ? "Bun" : "Node"}).`);
   }
-  return openNodeDatabase(path5, opts);
+  return provider;
+}
+function openDatabase(path5, opts) {
+  return selectProvider().open(path5, opts);
 }
 function openBunDatabase(path5, opts) {
   const { Database: BunDatabase } = loadBunSqlite();
@@ -8778,7 +8782,16 @@ function loadBunSqlite() {
 }
 function loadBetterSqlite3() {
   if (!betterSqlite3Ctor) {
-    const mod = nodeRequire("better-sqlite3");
+    let mod;
+    try {
+      mod = nodeRequire("better-sqlite3");
+    } catch (err) {
+      throw new Error(`akm could not load 'better-sqlite3', the SQLite driver it needs on Node.js.
+` + `  \u2022 Reinstall akm with a working C/C++ build toolchain so its optional
+` + "    'better-sqlite3' native binding rebuilds (a global `npm i -g better-sqlite3`\n" + `    will NOT be resolved \u2014 Node loads it from akm's own node_modules).
+` + `  \u2022 Or run akm under Bun, which has a built-in SQLite driver and needs no native build.
+` + `  Underlying load error: ${err instanceof Error ? err.message : String(err)}`);
+    }
     betterSqlite3Ctor = mod.default ?? mod;
   }
   return betterSqlite3Ctor;
@@ -8793,36 +8806,23 @@ function openNodeDatabase(path5, opts) {
   const db = opts ? new BetterSqlite3(path5, options) : new BetterSqlite3(path5);
   return db;
 }
-var isBun, nodeRequire, bunSqliteModule, betterSqlite3Ctor;
+var isBun, nodeRequire, bunSqliteProvider, nodeSqliteProvider, PROVIDERS, bunSqliteModule, betterSqlite3Ctor;
 var init_database = __esm(() => {
   isBun = !!process.versions?.bun;
   nodeRequire = createRequire(import.meta.url);
+  bunSqliteProvider = {
+    name: "bun:sqlite",
+    supported: () => isBun,
+    open: openBunDatabase
+  };
+  nodeSqliteProvider = {
+    name: "better-sqlite3",
+    supported: () => !isBun,
+    open: openNodeDatabase
+  };
+  PROVIDERS = [bunSqliteProvider, nodeSqliteProvider];
 });
 
-// src/storage/engines/sqlite-migrations.ts
-function ensureMigrationsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      id         TEXT    PRIMARY KEY,
-      applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-}
-function runMigrations(db, migrations, opts) {
-  ensureMigrationsTable(db);
-  opts?.bootstrap?.(db);
-  const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
-  const applied = new Set(appliedRows.map((r) => r.id));
-  for (const migration of migrations) {
-    if (applied.has(migration.id))
-      continue;
-    db.transaction(() => {
-      db.exec(migration.up);
-      db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
-    })();
-  }
-}
-
 // src/runtime.ts
 import { createHash } from "crypto";
 import { createWriteStream, statfsSync } from "fs";
@@ -8920,6 +8920,46 @@ var init_sqlite_pragmas = __esm(() => {
   ]);
 });
 
+// src/storage/managed-db.ts
+import fs5 from "fs";
+import path5 from "path";
+function openManagedDatabase(spec) {
+  const dir = path5.dirname(spec.path);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  const db = openDatabase(spec.path);
+  applyStandardPragmas(db, spec.pragmas ?? { dataDir: dir });
+  spec.init?.(db);
+  return db;
+}
+function withManagedDb(open, fn, opts) {
+  if (opts?.borrowed) {
+    return fn(opts.borrowed);
+  }
+  const db = open();
+  try {
+    return fn(db);
+  } finally {
+    db.close();
+  }
+}
+async function withManagedDbAsync(open, fn, opts) {
+  if (opts?.borrowed) {
+    return fn(opts.borrowed);
+  }
+  const db = open();
+  try {
+    return await fn(db);
+  } finally {
+    db.close();
+  }
+}
+var init_managed_db = __esm(() => {
+  init_database();
+  init_sqlite_pragmas();
+});
+
 // src/core/assert.ts
 function assertNever(x, context) {
   let serialized;
@@ -8959,683 +8999,36 @@ function classifyImproveAction(mode) {
 }
 var init_improve_types = () => {};
 
-// src/core/state-db.ts
-var exports_state_db = {};
-__export(exports_state_db, {
-  withImmediateTransaction: () => withImmediateTransaction,
-  upsertTaskHistory: () => upsertTaskHistory,
-  upsertProposal: () => upsertProposal,
-  upsertExtractedSession: () => upsertExtractedSession,
-  upsertConsolidationJudged: () => upsertConsolidationJudged,
-  upsertBodyEmbeddings: () => upsertBodyEmbeddings,
-  shouldSkipAlreadyExtractedSession: () => shouldSkipAlreadyExtractedSession,
-  runMigrations: () => runMigrations2,
-  recordRecombineInduction: () => recordRecombineInduction,
-  recordImproveRun: () => recordImproveRun,
-  recordFsProposalsImport: () => recordFsProposalsImport,
-  readStateEvents: () => readStateEvents,
-  queryTaskHistory: () => queryTaskHistory,
-  queryImproveRuns: () => queryImproveRuns,
-  queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
-  purgeOldImproveRuns: () => purgeOldImproveRuns,
-  purgeOldEvents: () => purgeOldEvents,
-  proposalToRowValues: () => proposalToRowValues,
-  proposalRowToProposal: () => proposalRowToProposal,
-  persistPhaseThreshold: () => persistPhaseThreshold,
-  openStateDatabase: () => openStateDatabase,
-  markRecombineHypothesisPromoted: () => markRecombineHypothesisPromoted,
-  listStateProposals: () => listStateProposals,
-  listStateProposalIdsByPrefix: () => listStateProposalIdsByPrefix,
-  listProposalGateDecisions: () => listProposalGateDecisions,
-  listExistingTableNames: () => listExistingTableNames,
-  insertProposalIfAbsent: () => insertProposalIfAbsent,
-  insertEvent: () => insertEvent,
-  importEventsJsonl: () => importEventsJsonl,
-  hasImportedFsProposals: () => hasImportedFsProposals,
-  getTaskHistoryRuns: () => getTaskHistoryRuns,
-  getTaskHistory: () => getTaskHistory,
-  getStateProposal: () => getStateProposal,
-  getStateDbPath: () => getStateDbPath,
-  getRecombineHypothesis: () => getRecombineHypothesis,
-  getPhaseThreshold: () => getPhaseThreshold,
-  getLastExtractRunAt: () => getLastExtractRunAt,
-  getExtractedSessionsMap: () => getExtractedSessionsMap,
-  getExtractedSession: () => getExtractedSession,
-  getConsolidationJudgedMap: () => getConsolidationJudgedMap,
-  getBodyEmbeddings: () => getBodyEmbeddings,
-  findMatchingRecombineHypothesis: () => findMatchingRecombineHypothesis,
-  eventRowToEnvelope: () => eventRowToEnvelope,
-  embeddingToBlob: () => embeddingToBlob,
-  decayUnseenRecombineHypotheses: () => decayUnseenRecombineHypotheses,
-  computeImproveRunMetrics: () => computeImproveRunMetrics,
-  blobToEmbedding: () => blobToEmbedding,
-  REGISTRY_INDEX_CACHE_DDL: () => REGISTRY_INDEX_CACHE_DDL
-});
-import fs5 from "fs";
-import path5 from "path";
-function getStateDbPath() {
-  return path5.join(getDataDir(), "state.db");
+// src/storage/engines/sqlite-migrations.ts
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id         TEXT    PRIMARY KEY,
+      applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
 }
-function openStateDatabase(dbPath) {
-  const resolvedPath = dbPath ?? getStateDbPath();
-  const dir = path5.dirname(resolvedPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+function runMigrations(db, migrations, opts) {
+  ensureMigrationsTable(db);
+  opts?.bootstrap?.(db);
+  const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
+  const applied = new Set(appliedRows.map((r) => r.id));
+  for (const migration of migrations) {
+    if (applied.has(migration.id))
+      continue;
+    db.transaction(() => {
+      db.exec(migration.up);
+      db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
+    })();
   }
-  const db = openDatabase(resolvedPath);
-  applyStandardPragmas(db, { dataDir: dir });
-  runMigrations2(db);
-  return db;
 }
+
+// src/core/state/migrations.ts
 function runMigrations2(db) {
   runMigrations(db, MIGRATIONS);
 }
-function eventRowToEnvelope(row) {
-  let metadata;
-  try {
-    const parsed = JSON.parse(row.metadata_json);
-    if (Object.keys(parsed).length > 0) {
-      metadata = parsed;
-    }
-  } catch {}
-  return {
-    schemaVersion: 1,
-    id: row.id,
-    ts: row.ts,
-    eventType: row.event_type,
-    ...row.ref !== null ? { ref: row.ref } : {},
-    ...metadata !== undefined ? { metadata } : {}
-  };
-}
-function proposalRowToProposal(row) {
-  let frontmatter;
-  if (row.frontmatter_json) {
-    try {
-      frontmatter = JSON.parse(row.frontmatter_json);
-    } catch {}
-  }
-  let meta = {};
-  try {
-    meta = JSON.parse(row.metadata_json);
-  } catch {}
-  return {
-    id: row.id,
-    ref: row.ref,
-    status: row.status,
-    source: row.source,
-    ...typeof meta.sourceRun === "string" ? { sourceRun: meta.sourceRun } : {},
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    payload: {
-      content: row.content,
-      ...frontmatter !== undefined ? { frontmatter } : {}
-    },
-    ...meta.review !== undefined ? { review: meta.review } : {},
-    ...typeof meta.confidence === "number" ? { confidence: meta.confidence } : {},
-    ...meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {},
-    ...typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {},
-    ...typeof meta.eligibilitySource === "string" ? { eligibilitySource: meta.eligibilitySource } : {}
-  };
-}
-function proposalToRowValues(proposal, stashDir) {
-  const metaObj = {};
-  if (proposal.sourceRun !== undefined)
-    metaObj.sourceRun = proposal.sourceRun;
-  if (proposal.review !== undefined)
-    metaObj.review = proposal.review;
-  if (proposal.confidence !== undefined)
-    metaObj.confidence = proposal.confidence;
-  if (proposal.gateDecision !== undefined)
-    metaObj.gateDecision = proposal.gateDecision;
-  if (proposal.backupContent !== undefined)
-    metaObj.backupContent = proposal.backupContent;
-  if (proposal.eligibilitySource !== undefined)
-    metaObj.eligibilitySource = proposal.eligibilitySource;
-  return {
-    id: proposal.id,
-    stash_dir: stashDir,
-    ref: proposal.ref,
-    status: proposal.status,
-    source: proposal.source,
-    created_at: proposal.createdAt,
-    updated_at: proposal.updatedAt,
-    content: proposal.payload.content,
-    frontmatter_json: proposal.payload.frontmatter ? JSON.stringify(proposal.payload.frontmatter) : null,
-    metadata_json: JSON.stringify(metaObj)
-  };
-}
-function insertEvent(db, input) {
-  try {
-    const result = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
-         VALUES (?, ?, ?, ?)
-         RETURNING id`).get(input.eventType, input.ts, input.ref ?? null, JSON.stringify(input.metadata ?? {}));
-    return result?.id;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    error(`akm: state.db event insert failed (${message})`);
-    return;
-  }
-}
-function readStateEvents(db, options = {}) {
-  const conditions = [];
-  const params = [];
-  if (options.sinceId !== undefined && options.sinceId > 0) {
-    conditions.push("id > ?");
-    params.push(options.sinceId);
-  }
-  if (options.since) {
-    conditions.push("ts >= ?");
-    params.push(options.since);
-  }
-  if (options.type) {
-    conditions.push("event_type = ?");
-    params.push(options.type);
-  }
-  if (options.ref) {
-    conditions.push("ref = ?");
-    params.push(options.ref);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = db.prepare(`SELECT id, event_type, ts, ref, metadata_json FROM events ${where} ORDER BY id ASC`).all(...params);
-  const events = rows.map(eventRowToEnvelope);
-  const nextId = events.length > 0 ? events[events.length - 1].id : options.sinceId ?? 0;
-  return { events, nextId };
-}
-function purgeOldEvents(db, retentionDays = 90) {
-  if (!Number.isFinite(retentionDays) || retentionDays <= 0)
-    return 0;
-  const cutoff = new Date(Date.now() - retentionDays * 86400000).toISOString();
-  const result = db.prepare("DELETE FROM events WHERE ts < ?").run(cutoff);
-  const changes = result.changes ?? 0;
-  return typeof changes === "bigint" ? Number(changes) : changes;
-}
-function upsertProposal(db, proposal, stashDir) {
-  const v = proposalToRowValues(proposal, stashDir);
-  db.prepare(`
-    INSERT INTO proposals
-      (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(id) DO UPDATE SET
-      stash_dir        = excluded.stash_dir,
-      ref              = excluded.ref,
-      status           = excluded.status,
-      source           = excluded.source,
-      updated_at       = excluded.updated_at,
-      content          = excluded.content,
-      frontmatter_json = excluded.frontmatter_json,
-      metadata_json    = excluded.metadata_json
-  `).run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
-}
-function listStateProposals(db, options = {}) {
-  const conditions = [];
-  const params = [];
-  if (options.stashDir) {
-    conditions.push("stash_dir = ?");
-    params.push(options.stashDir);
-  }
-  if (options.status) {
-    conditions.push("status = ?");
-    params.push(options.status);
-  }
-  if (options.ref) {
-    conditions.push("ref = ?");
-    params.push(options.ref);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = db.prepare(`SELECT id, stash_dir, ref, status, source, created_at, updated_at,
-              content, frontmatter_json, metadata_json
-       FROM proposals ${where} ORDER BY created_at ASC, rowid ASC`).all(...params);
-  return rows.map(proposalRowToProposal);
-}
-function listProposalGateDecisions(db) {
-  const rows = db.prepare("SELECT metadata_json FROM proposals ORDER BY created_at ASC, rowid ASC").all();
-  const decisions = [];
-  for (const row of rows) {
-    let meta;
-    try {
-      meta = JSON.parse(row.metadata_json);
-    } catch {
-      continue;
-    }
-    const decision = meta.gateDecision;
-    if (decision && typeof decision === "object" && typeof decision.outcome === "string") {
-      decisions.push(decision);
-    }
-  }
-  decisions.sort((a, b) => new Date(a.decidedAt).getTime() - new Date(b.decidedAt).getTime());
-  return decisions;
-}
-function getPhaseThreshold(db, phase) {
-  const row = db.prepare("SELECT threshold FROM improve_gate_thresholds WHERE phase = ?").get(phase);
-  return row?.threshold;
-}
-function persistPhaseThreshold(db, phase, threshold) {
-  db.prepare(`INSERT OR REPLACE INTO improve_gate_thresholds (phase, threshold, updated_at)
-     VALUES (?, ?, ?)`).run(phase, Math.round(threshold), Date.now());
-}
-function getStateProposal(db, id, stashDir) {
-  const sql = `SELECT id, stash_dir, ref, status, source, created_at, updated_at,
-              content, frontmatter_json, metadata_json
-       FROM proposals WHERE id = ?${stashDir ? " AND stash_dir = ?" : ""}`;
-  const row = stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id);
-  return row ? proposalRowToProposal(row) : undefined;
-}
-function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
-  const escaped = idPrefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
-  const rows = db.prepare(`SELECT id FROM proposals
-       WHERE stash_dir = ? AND status = 'pending' AND id LIKE ? ESCAPE '\\'
-       ORDER BY id ASC`).all(stashDir, `${escaped}%`);
-  return rows.map((r) => r.id);
-}
-function hasImportedFsProposals(db, stashDir) {
-  return Boolean(db.prepare("SELECT 1 FROM proposal_fs_imports WHERE stash_dir = ?").get(stashDir));
-}
-function recordFsProposalsImport(db, stashDir, importedCount) {
-  db.prepare("INSERT OR REPLACE INTO proposal_fs_imports (stash_dir, imported_at, imported_count) VALUES (?, ?, ?)").run(stashDir, new Date().toISOString(), importedCount);
-}
-function insertProposalIfAbsent(db, proposal, stashDir) {
-  const v = proposalToRowValues(proposal, stashDir);
-  const result = db.prepare(`
-      INSERT OR IGNORE INTO proposals
-        (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
-  const changes = result.changes ?? 0;
-  return Number(changes) > 0;
-}
-function withImmediateTransaction(db, fn) {
-  db.exec("BEGIN IMMEDIATE");
-  try {
-    const result = fn();
-    db.exec("COMMIT");
-    return result;
-  } catch (err) {
-    try {
-      db.exec("ROLLBACK");
-    } catch {}
-    throw err;
-  }
-}
-function upsertTaskHistory(db, row) {
-  db.prepare(`
-    INSERT OR IGNORE INTO task_history
-      (task_id, status, started_at, completed_at, failed_at, log_path,
-       target_kind, target_ref, metadata_json)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(row.task_id, row.status, row.started_at, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json);
-}
-function getTaskHistory(db, taskId) {
-  return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
-              target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT 1`).get(taskId);
-}
-function getTaskHistoryRuns(db, taskId, limit = 50) {
-  return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
-              target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT ?`).all(taskId, limit);
-}
-function queryTaskHistory(db, options = {}) {
-  const conditions = [];
-  const params = [];
-  if (options.since) {
-    conditions.push("started_at >= ?");
-    params.push(options.since);
-  }
-  if (options.until) {
-    conditions.push("started_at <= ?");
-    params.push(options.until);
-  }
-  if (options.status) {
-    conditions.push("status = ?");
-    params.push(options.status);
-  }
-  if (options.targetKind) {
-    conditions.push("target_kind = ?");
-    params.push(options.targetKind);
-  }
-  if (options.targetRef) {
-    conditions.push("target_ref = ?");
-    params.push(options.targetRef);
-  }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  return db.prepare(`SELECT task_id, status, started_at, completed_at, failed_at, log_path,
-              target_kind, target_ref, metadata_json
-       FROM task_history ${where} ORDER BY started_at DESC`).all(...params);
-}
-function queryCompletedTaskIntervals(db, since, until) {
-  const sql = until ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL ORDER BY started_at" : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";
-  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
-}
-function listExistingTableNames(db, names) {
-  if (names.length === 0)
-    return [];
-  const placeholders = names.map(() => "?").join(", ");
-  return db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${placeholders}) ORDER BY name`).all(...names);
-}
-async function importEventsJsonl(db, jsonlPath) {
-  const { readFileSync, existsSync } = await import("fs");
-  if (!existsSync(jsonlPath)) {
-    return { imported: 0, maxId: 0, skipped: 0 };
-  }
-  const text = readFileSync(jsonlPath, "utf8");
-  const lines = text.split(`
-`).filter((l) => l.trim().length > 0);
-  let imported = 0;
-  let maxId = 0;
-  let skipped = 0;
-  const insertStmt = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
-     VALUES (?, ?, ?, ?)
-     RETURNING id`);
-  const existsStmt = db.prepare(`SELECT 1 FROM events
-     WHERE event_type = ?
-       AND ts = ?
-       AND ref IS ?
-       AND metadata_json = ?
-     LIMIT 1`);
-  db.transaction(() => {
-    for (const line of lines) {
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const eventType = typeof parsed.eventType === "string" ? parsed.eventType : "unknown";
-      const ts = typeof parsed.ts === "string" ? parsed.ts : new Date().toISOString();
-      const ref = typeof parsed.ref === "string" ? parsed.ref : null;
-      const metadata = parsed.metadata !== undefined && typeof parsed.metadata === "object" ? JSON.stringify(parsed.metadata) : "{}";
-      const duplicate = existsStmt.get(eventType, ts, ref, metadata);
-      if (duplicate) {
-        skipped++;
-        continue;
-      }
-      const result = insertStmt.get(eventType, ts, ref, metadata);
-      if (result) {
-        imported++;
-        if (result.id > maxId)
-          maxId = result.id;
-      }
-    }
-  })();
-  return { imported, maxId, skipped };
-}
-function computeImproveRunMetrics(result) {
-  const plannedCount = Array.isArray(result.plannedRefs) ? result.plannedRefs.length : 0;
-  const actions = Array.isArray(result.actions) ? result.actions : [];
-  const actionsCount = actions.length;
-  let acceptedCount = 0;
-  let rejectedCount = 0;
-  let autoAcceptedCount = 0;
-  let errorCount = 0;
-  for (const action of actions) {
-    switch (classifyImproveAction(action.mode)) {
-      case "accepted":
-        acceptedCount++;
-        break;
-      case "rejected":
-        rejectedCount++;
-        break;
-      case "error":
-        errorCount++;
-        break;
-      case "noop":
-        break;
-    }
-    const r = action.result;
-    if (r && r.autoAccepted === true)
-      autoAcceptedCount++;
-  }
-  autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
-  return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
-}
-function recordImproveRun(db, input) {
-  const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);
-  db.prepare(`
-    INSERT INTO improve_runs
-      (id, started_at, completed_at, stash_dir, dry_run, profile,
-       scope_mode, scope_value, guidance, ok, result_json, metrics_json, metadata_json)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(input.id, input.startedAt, input.completedAt, input.stashDir, input.dryRun ? 1 : 0, input.profile, input.scopeMode, input.scopeValue, input.guidance, input.ok ? 1 : 0, JSON.stringify(input.result), JSON.stringify(metricsObj), JSON.stringify(input.metadata ?? {}));
-}
-function queryImproveRuns(db, since, until) {
-  const sql = until ? "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND started_at < ? AND dry_run = 0 ORDER BY started_at DESC" : "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND dry_run = 0 ORDER BY started_at DESC";
-  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
-}
-function purgeOldImproveRuns(db, retentionDays = 90) {
-  if (!Number.isFinite(retentionDays) || retentionDays <= 0)
-    return 0;
-  const cutoff = new Date(Date.now() - retentionDays * 86400000).toISOString();
-  const result = db.prepare("DELETE FROM improve_runs WHERE started_at < ?").run(cutoff);
-  const changes = result.changes ?? 0;
-  return typeof changes === "bigint" ? Number(changes) : changes;
-}
-function upsertExtractedSession(db, input) {
-  const endedAtIso = typeof input.sessionEndedAt === "number" && Number.isFinite(input.sessionEndedAt) ? new Date(input.sessionEndedAt).toISOString() : null;
-  db.prepare(`
-    INSERT OR REPLACE INTO extract_sessions_seen
-      (harness, session_id, processed_at, session_ended_at, outcome,
-       candidate_count, proposal_count, rationale, source_run, metadata_json,
-       content_hash)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(input.harness, input.sessionId, input.processedAt, endedAtIso, input.outcome, input.candidateCount, input.proposalCount, input.rationale ?? null, input.sourceRun ?? null, JSON.stringify(input.metadata ?? {}), input.contentHash);
-}
-function getExtractedSession(db, harness, sessionId) {
-  const row = db.prepare("SELECT * FROM extract_sessions_seen WHERE harness = ? AND session_id = ?").get(harness, sessionId);
-  return row ?? undefined;
-}
-function getExtractedSessionsMap(db, harness, sessionIds) {
-  const out = new Map;
-  if (sessionIds.length === 0)
-    return out;
-  const CHUNK = 500;
-  for (let i = 0;i < sessionIds.length; i += CHUNK) {
-    const chunk = sessionIds.slice(i, i + CHUNK);
-    const placeholders = chunk.map(() => "?").join(",");
-    const rows = db.prepare(`SELECT * FROM extract_sessions_seen
-         WHERE harness = ? AND session_id IN (${placeholders})`).all(harness, ...chunk);
-    for (const row of rows)
-      out.set(row.session_id, row);
-  }
-  return out;
-}
-function getLastExtractRunAt(db, harness) {
-  const row = db.prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?").get(harness);
-  if (!row?.last)
-    return null;
-  const ms = Date.parse(row.last);
-  return Number.isFinite(ms) ? ms : null;
-}
-function shouldSkipAlreadyExtractedSession(prior, currentContentHash) {
-  if (!prior)
-    return false;
-  if (prior.content_hash == null)
-    return false;
-  return prior.content_hash === currentContentHash;
-}
-function getConsolidationJudgedMap(db, entryKeys) {
-  const out = new Map;
-  if (entryKeys.length === 0)
-    return out;
-  const CHUNK = 500;
-  for (let i = 0;i < entryKeys.length; i += CHUNK) {
-    const chunk = entryKeys.slice(i, i + CHUNK);
-    const placeholders = chunk.map(() => "?").join(",");
-    const rows = db.prepare(`SELECT * FROM consolidation_judged WHERE entry_key IN (${placeholders})`).all(...chunk);
-    for (const row of rows)
-      out.set(row.entry_key, row);
-  }
-  return out;
-}
-function upsertConsolidationJudged(db, input) {
-  db.prepare(`
-    INSERT OR REPLACE INTO consolidation_judged
-      (entry_key, content_hash, judged_at, outcome)
-    VALUES (?, ?, ?, ?)
-  `).run(input.entryKey, input.contentHash, input.judgedAt, input.outcome);
-}
-function recordRecombineInduction(db, input) {
-  const row = db.prepare(`
-      INSERT INTO recombine_hypotheses
-        (hypothesis_ref, signature, member_key, consecutive_count, first_seen_at, last_seen_at, last_run)
-      VALUES (?, ?, ?, 1, ?, ?, ?)
-      ON CONFLICT(hypothesis_ref) DO UPDATE SET
-        consecutive_count = consecutive_count + (CASE WHEN last_run IS excluded.last_run THEN 0 ELSE 1 END),
-        last_seen_at = excluded.last_seen_at,
-        last_run = excluded.last_run,
-        signature = excluded.signature,
-        member_key = excluded.member_key
-      RETURNING consecutive_count
-    `).get(input.hypothesisRef, input.signature, input.memberKey, input.seenAt, input.seenAt, input.run);
-  return row?.consecutive_count ?? 0;
-}
-function findMatchingRecombineHypothesis(db, input) {
-  const candidateMembers = new Set(input.memberKey.split("|").filter((m) => m.length > 0));
-  if (candidateMembers.size === 0)
-    return;
-  const rows = db.prepare("SELECT * FROM recombine_hypotheses WHERE signature = ? AND promoted_at IS NULL ORDER BY last_seen_at DESC").all(input.signature);
-  let best;
-  let bestOverlap = -1;
-  for (const row of rows) {
-    const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
-    if (rowMembers.length === 0)
-      continue;
-    let intersection = 0;
-    for (const m of rowMembers) {
-      if (candidateMembers.has(m))
-        intersection += 1;
-    }
-    const union = candidateMembers.size + rowMembers.length - intersection;
-    const overlap = union === 0 ? 0 : intersection / union;
-    if (overlap >= input.minOverlap && overlap > bestOverlap) {
-      best = row;
-      bestOverlap = overlap;
-    }
-  }
-  return best;
-}
-function getRecombineHypothesis(db, hypothesisRef) {
-  const row = db.prepare("SELECT * FROM recombine_hypotheses WHERE hypothesis_ref = ?").get(hypothesisRef);
-  return row ?? undefined;
-}
-function markRecombineHypothesisPromoted(db, hypothesisRef, promotedAt) {
-  db.prepare("UPDATE recombine_hypotheses SET promoted_at = ?, consecutive_count = 0 WHERE hypothesis_ref = ?").run(promotedAt, hypothesisRef);
-}
-function hypothesisMatchesAnyPresentCluster(row, presentClusters, minOverlap) {
-  const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
-  if (rowMembers.length === 0)
-    return false;
-  const rowSet = new Set(rowMembers);
-  for (const cluster of presentClusters) {
-    if (cluster.signature !== row.signature)
-      continue;
-    const clusterMembers = cluster.memberKey.split("|").filter((m) => m.length > 0);
-    if (clusterMembers.length === 0)
-      continue;
-    let intersection = 0;
-    for (const m of clusterMembers) {
-      if (rowSet.has(m))
-        intersection += 1;
-    }
-    const union = rowSet.size + clusterMembers.length - intersection;
-    const overlap = union === 0 ? 0 : intersection / union;
-    if (overlap >= minOverlap)
-      return true;
-  }
-  return false;
-}
-function decayUnseenRecombineHypotheses(db, currentRun, seenRefs, opts) {
-  let effectiveSeen = seenRefs;
-  if (opts && opts.presentClusters.length > 0) {
-    const candidates = db.prepare("SELECT hypothesis_ref, signature, member_key FROM recombine_hypotheses WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").all(currentRun);
-    const seenSet = new Set(seenRefs);
-    for (const row of candidates) {
-      if (seenSet.has(row.hypothesis_ref))
-        continue;
-      if (hypothesisMatchesAnyPresentCluster(row, opts.presentClusters, opts.minOverlap)) {
-        seenSet.add(row.hypothesis_ref);
-      }
-    }
-    effectiveSeen = [...seenSet];
-  }
-  return decayUnseenRecombineHypothesesInner(db, currentRun, effectiveSeen);
-}
-function decayUnseenRecombineHypothesesInner(db, currentRun, seenRefs) {
-  if (seenRefs.length === 0) {
-    const res2 = db.prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").run(currentRun);
-    return Number(res2.changes);
-  }
-  if (seenRefs.length > 900) {
-    const res2 = db.prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").run(currentRun);
-    return Number(res2.changes);
-  }
-  const placeholders = seenRefs.map(() => "?").join(",");
-  const res = db.prepare(`UPDATE recombine_hypotheses SET consecutive_count = 0
-       WHERE promoted_at IS NULL
-         AND (last_run IS NULL OR last_run != ?)
-         AND consecutive_count != 0
-         AND hypothesis_ref NOT IN (${placeholders})`).run(currentRun, ...seenRefs);
-  return Number(res.changes);
-}
-function embeddingToBlob(vec) {
-  const f32 = new Float32Array(vec);
-  return new Uint8Array(f32.buffer);
-}
-function blobToEmbedding(blob) {
-  const f32 = new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
-  return Array.from(f32);
-}
-function getBodyEmbeddings(db, contentHashes, expectedModelId) {
-  const out = new Map;
-  if (contentHashes.length === 0)
-    return out;
-  const firstRow = db.prepare("SELECT model_id FROM body_embeddings LIMIT 1").get();
-  if (firstRow && firstRow.model_id !== expectedModelId) {
-    db.exec("DELETE FROM body_embeddings");
-    return out;
-  }
-  const CHUNK = 500;
-  for (let i = 0;i < contentHashes.length; i += CHUNK) {
-    const chunk = contentHashes.slice(i, i + CHUNK);
-    const placeholders = chunk.map(() => "?").join(",");
-    const rows = db.prepare(`SELECT content_hash, embedding FROM body_embeddings WHERE content_hash IN (${placeholders})`).all(...chunk);
-    for (const row of rows) {
-      out.set(row.content_hash, blobToEmbedding(row.embedding));
-    }
-  }
-  return out;
-}
-function upsertBodyEmbeddings(db, entries) {
-  if (entries.length === 0)
-    return;
-  const now = Date.now();
-  const stmt = db.prepare(`
-    INSERT OR REPLACE INTO body_embeddings (content_hash, embedding, model_id, created_at)
-    VALUES (?, ?, ?, ?)
-  `);
-  db.transaction(() => {
-    for (const { contentHash, embedding, modelId } of entries) {
-      stmt.run(contentHash, embeddingToBlob(embedding), modelId, now);
-    }
-  })();
-}
-var MIGRATIONS, REGISTRY_INDEX_CACHE_DDL = `
-  CREATE TABLE IF NOT EXISTS registry_index_cache (
-    registry_url  TEXT    PRIMARY KEY,
-    fetched_at    TEXT    NOT NULL,
-    etag          TEXT,
-    last_modified TEXT,
-    index_json    TEXT    NOT NULL DEFAULT '{}'
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_registry_cache_fetched
-    ON registry_index_cache(fetched_at);
-`;
-var init_state_db = __esm(() => {
-  init_database();
-  init_sqlite_pragmas();
-  init_improve_types();
-  init_paths();
-  init_warn();
+var MIGRATIONS;
+var init_migrations = __esm(() => {
   MIGRATIONS = [
     {
       id: "001-initial-schema",
@@ -10018,13 +9411,676 @@ var init_state_db = __esm(() => {
         ON recombine_hypotheses(last_seen_at);
     `
     },
-    {
-      id: "015-asset-salience-encoding-source",
-      up: `
-      ALTER TABLE asset_salience ADD COLUMN encoding_source TEXT DEFAULT NULL;
-    `
+    {
+      id: "015-asset-salience-encoding-source",
+      up: `
+      ALTER TABLE asset_salience ADD COLUMN encoding_source TEXT DEFAULT NULL;
+    `
+    }
+  ];
+});
+
+// src/core/state-db.ts
+var exports_state_db = {};
+__export(exports_state_db, {
+  withStateDbAsync: () => withStateDbAsync,
+  withStateDb: () => withStateDb,
+  withImmediateTransaction: () => withImmediateTransaction,
+  upsertTaskHistory: () => upsertTaskHistory,
+  upsertProposal: () => upsertProposal,
+  upsertExtractedSession: () => upsertExtractedSession,
+  upsertConsolidationJudged: () => upsertConsolidationJudged,
+  upsertBodyEmbeddings: () => upsertBodyEmbeddings,
+  shouldSkipAlreadyExtractedSession: () => shouldSkipAlreadyExtractedSession,
+  runMigrations: () => runMigrations2,
+  recordRecombineInduction: () => recordRecombineInduction,
+  recordImproveRun: () => recordImproveRun,
+  recordFsProposalsImport: () => recordFsProposalsImport,
+  readStateEvents: () => readStateEvents,
+  queryTaskHistory: () => queryTaskHistory,
+  queryImproveRuns: () => queryImproveRuns,
+  queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
+  purgeOldImproveRuns: () => purgeOldImproveRuns,
+  purgeOldEvents: () => purgeOldEvents,
+  proposalToRowValues: () => proposalToRowValues,
+  proposalRowToProposal: () => proposalRowToProposal,
+  persistPhaseThreshold: () => persistPhaseThreshold,
+  openStateDatabase: () => openStateDatabase,
+  markRecombineHypothesisPromoted: () => markRecombineHypothesisPromoted,
+  listStateProposals: () => listStateProposals,
+  listStateProposalIdsByPrefix: () => listStateProposalIdsByPrefix,
+  listProposalGateDecisions: () => listProposalGateDecisions,
+  listExistingTableNames: () => listExistingTableNames,
+  insertProposalIfAbsent: () => insertProposalIfAbsent,
+  insertEvent: () => insertEvent,
+  importEventsJsonl: () => importEventsJsonl,
+  hasImportedFsProposals: () => hasImportedFsProposals,
+  getTaskHistoryRuns: () => getTaskHistoryRuns,
+  getTaskHistory: () => getTaskHistory,
+  getStateProposal: () => getStateProposal,
+  getStateDbPath: () => getStateDbPath,
+  getRecombineHypothesis: () => getRecombineHypothesis,
+  getPhaseThreshold: () => getPhaseThreshold,
+  getLastExtractRunAt: () => getLastExtractRunAt,
+  getExtractedSessionsMap: () => getExtractedSessionsMap,
+  getExtractedSession: () => getExtractedSession,
+  getConsolidationJudgedMap: () => getConsolidationJudgedMap,
+  getBodyEmbeddings: () => getBodyEmbeddings,
+  findMatchingRecombineHypothesis: () => findMatchingRecombineHypothesis,
+  eventRowToEnvelope: () => eventRowToEnvelope,
+  embeddingToBlob: () => embeddingToBlob,
+  decayUnseenRecombineHypotheses: () => decayUnseenRecombineHypotheses,
+  computeImproveRunMetrics: () => computeImproveRunMetrics,
+  blobToEmbedding: () => blobToEmbedding
+});
+import path6 from "path";
+function getStateDbPath() {
+  return path6.join(getDataDir(), "state.db");
+}
+function openStateDatabase(dbPath) {
+  return openManagedDatabase({ path: dbPath ?? getStateDbPath(), init: runMigrations2 });
+}
+function withStateDb(fn, opts) {
+  return withManagedDb(() => openStateDatabase(opts?.path), fn, opts);
+}
+function withStateDbAsync(fn, opts) {
+  return withManagedDbAsync(() => openStateDatabase(opts?.path), fn, opts);
+}
+function eventRowToEnvelope(row) {
+  let metadata;
+  try {
+    const parsed = JSON.parse(row.metadata_json);
+    if (Object.keys(parsed).length > 0) {
+      metadata = parsed;
+    }
+  } catch {}
+  return {
+    schemaVersion: 1,
+    id: row.id,
+    ts: row.ts,
+    eventType: row.event_type,
+    ...row.ref !== null ? { ref: row.ref } : {},
+    ...metadata !== undefined ? { metadata } : {}
+  };
+}
+function proposalRowToProposal(row) {
+  let frontmatter;
+  if (row.frontmatter_json) {
+    try {
+      frontmatter = JSON.parse(row.frontmatter_json);
+    } catch {}
+  }
+  let meta = {};
+  try {
+    meta = JSON.parse(row.metadata_json);
+  } catch {}
+  return {
+    id: row.id,
+    ref: row.ref,
+    status: row.status,
+    source: row.source,
+    ...typeof meta.sourceRun === "string" ? { sourceRun: meta.sourceRun } : {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    payload: {
+      content: row.content,
+      ...frontmatter !== undefined ? { frontmatter } : {}
+    },
+    ...meta.review !== undefined ? { review: meta.review } : {},
+    ...typeof meta.confidence === "number" ? { confidence: meta.confidence } : {},
+    ...meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {},
+    ...typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {},
+    ...typeof meta.eligibilitySource === "string" ? { eligibilitySource: meta.eligibilitySource } : {}
+  };
+}
+function proposalToRowValues(proposal, stashDir) {
+  const metaObj = {};
+  if (proposal.sourceRun !== undefined)
+    metaObj.sourceRun = proposal.sourceRun;
+  if (proposal.review !== undefined)
+    metaObj.review = proposal.review;
+  if (proposal.confidence !== undefined)
+    metaObj.confidence = proposal.confidence;
+  if (proposal.gateDecision !== undefined)
+    metaObj.gateDecision = proposal.gateDecision;
+  if (proposal.backupContent !== undefined)
+    metaObj.backupContent = proposal.backupContent;
+  if (proposal.eligibilitySource !== undefined)
+    metaObj.eligibilitySource = proposal.eligibilitySource;
+  return {
+    id: proposal.id,
+    stash_dir: stashDir,
+    ref: proposal.ref,
+    status: proposal.status,
+    source: proposal.source,
+    created_at: proposal.createdAt,
+    updated_at: proposal.updatedAt,
+    content: proposal.payload.content,
+    frontmatter_json: proposal.payload.frontmatter ? JSON.stringify(proposal.payload.frontmatter) : null,
+    metadata_json: JSON.stringify(metaObj)
+  };
+}
+function insertEvent(db, input) {
+  try {
+    const result = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
+         VALUES (?, ?, ?, ?)
+         RETURNING id`).get(input.eventType, input.ts, input.ref ?? null, JSON.stringify(input.metadata ?? {}));
+    return result?.id;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(`akm: state.db event insert failed (${message})`);
+    return;
+  }
+}
+function readStateEvents(db, options = {}) {
+  const conditions = [];
+  const params = [];
+  if (options.sinceId !== undefined && options.sinceId > 0) {
+    conditions.push("id > ?");
+    params.push(options.sinceId);
+  }
+  if (options.since) {
+    conditions.push("ts >= ?");
+    params.push(options.since);
+  }
+  if (options.type) {
+    conditions.push("event_type = ?");
+    params.push(options.type);
+  }
+  if (options.ref) {
+    conditions.push("ref = ?");
+    params.push(options.ref);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`SELECT id, event_type, ts, ref, metadata_json FROM events ${where} ORDER BY id ASC`).all(...params);
+  const events = rows.map(eventRowToEnvelope);
+  const nextId = events.length > 0 ? events[events.length - 1].id : options.sinceId ?? 0;
+  return { events, nextId };
+}
+function purgeOldEvents(db, retentionDays = 90) {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+    return 0;
+  const cutoff = new Date(Date.now() - retentionDays * 86400000).toISOString();
+  const result = db.prepare("DELETE FROM events WHERE ts < ?").run(cutoff);
+  const changes = result.changes ?? 0;
+  return typeof changes === "bigint" ? Number(changes) : changes;
+}
+function upsertProposal(db, proposal, stashDir) {
+  const v = proposalToRowValues(proposal, stashDir);
+  db.prepare(`
+    INSERT INTO proposals
+      (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      stash_dir        = excluded.stash_dir,
+      ref              = excluded.ref,
+      status           = excluded.status,
+      source           = excluded.source,
+      updated_at       = excluded.updated_at,
+      content          = excluded.content,
+      frontmatter_json = excluded.frontmatter_json,
+      metadata_json    = excluded.metadata_json
+  `).run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
+}
+function listStateProposals(db, options = {}) {
+  const conditions = [];
+  const params = [];
+  if (options.stashDir) {
+    conditions.push("stash_dir = ?");
+    params.push(options.stashDir);
+  }
+  if (options.status) {
+    conditions.push("status = ?");
+    params.push(options.status);
+  }
+  if (options.ref) {
+    conditions.push("ref = ?");
+    params.push(options.ref);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(`SELECT id, stash_dir, ref, status, source, created_at, updated_at,
+              content, frontmatter_json, metadata_json
+       FROM proposals ${where} ORDER BY created_at ASC, rowid ASC`).all(...params);
+  return rows.map(proposalRowToProposal);
+}
+function listProposalGateDecisions(db) {
+  const rows = db.prepare("SELECT metadata_json FROM proposals ORDER BY created_at ASC, rowid ASC").all();
+  const decisions = [];
+  for (const row of rows) {
+    let meta;
+    try {
+      meta = JSON.parse(row.metadata_json);
+    } catch {
+      continue;
+    }
+    const decision = meta.gateDecision;
+    if (decision && typeof decision === "object" && typeof decision.outcome === "string") {
+      decisions.push(decision);
+    }
+  }
+  decisions.sort((a, b) => new Date(a.decidedAt).getTime() - new Date(b.decidedAt).getTime());
+  return decisions;
+}
+function getPhaseThreshold(db, phase) {
+  const row = db.prepare("SELECT threshold FROM improve_gate_thresholds WHERE phase = ?").get(phase);
+  return row?.threshold;
+}
+function persistPhaseThreshold(db, phase, threshold) {
+  db.prepare(`INSERT OR REPLACE INTO improve_gate_thresholds (phase, threshold, updated_at)
+     VALUES (?, ?, ?)`).run(phase, Math.round(threshold), Date.now());
+}
+function getStateProposal(db, id, stashDir) {
+  const sql = `SELECT id, stash_dir, ref, status, source, created_at, updated_at,
+              content, frontmatter_json, metadata_json
+       FROM proposals WHERE id = ?${stashDir ? " AND stash_dir = ?" : ""}`;
+  const row = stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id);
+  return row ? proposalRowToProposal(row) : undefined;
+}
+function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
+  const escaped = idPrefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+  const rows = db.prepare(`SELECT id FROM proposals
+       WHERE stash_dir = ? AND status = 'pending' AND id LIKE ? ESCAPE '\\'
+       ORDER BY id ASC`).all(stashDir, `${escaped}%`);
+  return rows.map((r) => r.id);
+}
+function hasImportedFsProposals(db, stashDir) {
+  return Boolean(db.prepare("SELECT 1 FROM proposal_fs_imports WHERE stash_dir = ?").get(stashDir));
+}
+function recordFsProposalsImport(db, stashDir, importedCount) {
+  db.prepare("INSERT OR REPLACE INTO proposal_fs_imports (stash_dir, imported_at, imported_count) VALUES (?, ?, ?)").run(stashDir, new Date().toISOString(), importedCount);
+}
+function insertProposalIfAbsent(db, proposal, stashDir) {
+  const v = proposalToRowValues(proposal, stashDir);
+  const result = db.prepare(`
+      INSERT OR IGNORE INTO proposals
+        (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
+  const changes = result.changes ?? 0;
+  return Number(changes) > 0;
+}
+function withImmediateTransaction(db, fn) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (err) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw err;
+  }
+}
+function upsertTaskHistory(db, row) {
+  db.prepare(`
+    INSERT OR IGNORE INTO task_history
+      (task_id, status, started_at, completed_at, failed_at, log_path,
+       target_kind, target_ref, metadata_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(row.task_id, row.status, row.started_at, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json);
+}
+function getTaskHistory(db, taskId) {
+  return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
+              target_kind, target_ref, metadata_json
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT 1`).get(taskId);
+}
+function getTaskHistoryRuns(db, taskId, limit = 50) {
+  return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
+              target_kind, target_ref, metadata_json
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT ?`).all(taskId, limit);
+}
+function queryTaskHistory(db, options = {}) {
+  const conditions = [];
+  const params = [];
+  if (options.since) {
+    conditions.push("started_at >= ?");
+    params.push(options.since);
+  }
+  if (options.until) {
+    conditions.push("started_at <= ?");
+    params.push(options.until);
+  }
+  if (options.status) {
+    conditions.push("status = ?");
+    params.push(options.status);
+  }
+  if (options.targetKind) {
+    conditions.push("target_kind = ?");
+    params.push(options.targetKind);
+  }
+  if (options.targetRef) {
+    conditions.push("target_ref = ?");
+    params.push(options.targetRef);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db.prepare(`SELECT task_id, status, started_at, completed_at, failed_at, log_path,
+              target_kind, target_ref, metadata_json
+       FROM task_history ${where} ORDER BY started_at DESC`).all(...params);
+}
+function queryCompletedTaskIntervals(db, since, until) {
+  const sql = until ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL ORDER BY started_at" : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";
+  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
+}
+function listExistingTableNames(db, names) {
+  if (names.length === 0)
+    return [];
+  const placeholders = names.map(() => "?").join(", ");
+  return db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${placeholders}) ORDER BY name`).all(...names);
+}
+async function importEventsJsonl(db, jsonlPath) {
+  const { readFileSync, existsSync } = await import("fs");
+  if (!existsSync(jsonlPath)) {
+    return { imported: 0, maxId: 0, skipped: 0 };
+  }
+  const text = readFileSync(jsonlPath, "utf8");
+  const lines = text.split(`
+`).filter((l) => l.trim().length > 0);
+  let imported = 0;
+  let maxId = 0;
+  let skipped = 0;
+  const insertStmt = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
+     VALUES (?, ?, ?, ?)
+     RETURNING id`);
+  const existsStmt = db.prepare(`SELECT 1 FROM events
+     WHERE event_type = ?
+       AND ts = ?
+       AND ref IS ?
+       AND metadata_json = ?
+     LIMIT 1`);
+  db.transaction(() => {
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const eventType = typeof parsed.eventType === "string" ? parsed.eventType : "unknown";
+      const ts = typeof parsed.ts === "string" ? parsed.ts : new Date().toISOString();
+      const ref = typeof parsed.ref === "string" ? parsed.ref : null;
+      const metadata = parsed.metadata !== undefined && typeof parsed.metadata === "object" ? JSON.stringify(parsed.metadata) : "{}";
+      const duplicate = existsStmt.get(eventType, ts, ref, metadata);
+      if (duplicate) {
+        skipped++;
+        continue;
+      }
+      const result = insertStmt.get(eventType, ts, ref, metadata);
+      if (result) {
+        imported++;
+        if (result.id > maxId)
+          maxId = result.id;
+      }
+    }
+  })();
+  return { imported, maxId, skipped };
+}
+function computeImproveRunMetrics(result) {
+  const plannedCount = Array.isArray(result.plannedRefs) ? result.plannedRefs.length : 0;
+  const actions = Array.isArray(result.actions) ? result.actions : [];
+  const actionsCount = actions.length;
+  let acceptedCount = 0;
+  let rejectedCount = 0;
+  let autoAcceptedCount = 0;
+  let errorCount = 0;
+  for (const action of actions) {
+    switch (classifyImproveAction(action.mode)) {
+      case "accepted":
+        acceptedCount++;
+        break;
+      case "rejected":
+        rejectedCount++;
+        break;
+      case "error":
+        errorCount++;
+        break;
+      case "noop":
+        break;
+    }
+    const r = action.result;
+    if (r && r.autoAccepted === true)
+      autoAcceptedCount++;
+  }
+  autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
+  return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
+}
+function recordImproveRun(db, input) {
+  const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);
+  db.prepare(`
+    INSERT INTO improve_runs
+      (id, started_at, completed_at, stash_dir, dry_run, profile,
+       scope_mode, scope_value, guidance, ok, result_json, metrics_json, metadata_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.id, input.startedAt, input.completedAt, input.stashDir, input.dryRun ? 1 : 0, input.profile, input.scopeMode, input.scopeValue, input.guidance, input.ok ? 1 : 0, JSON.stringify(input.result), JSON.stringify(metricsObj), JSON.stringify(input.metadata ?? {}));
+}
+function queryImproveRuns(db, since, until) {
+  const sql = until ? "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND started_at < ? AND dry_run = 0 ORDER BY started_at DESC" : "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND dry_run = 0 ORDER BY started_at DESC";
+  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
+}
+function purgeOldImproveRuns(db, retentionDays = 90) {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+    return 0;
+  const cutoff = new Date(Date.now() - retentionDays * 86400000).toISOString();
+  const result = db.prepare("DELETE FROM improve_runs WHERE started_at < ?").run(cutoff);
+  const changes = result.changes ?? 0;
+  return typeof changes === "bigint" ? Number(changes) : changes;
+}
+function upsertExtractedSession(db, input) {
+  const endedAtIso = typeof input.sessionEndedAt === "number" && Number.isFinite(input.sessionEndedAt) ? new Date(input.sessionEndedAt).toISOString() : null;
+  db.prepare(`
+    INSERT OR REPLACE INTO extract_sessions_seen
+      (harness, session_id, processed_at, session_ended_at, outcome,
+       candidate_count, proposal_count, rationale, source_run, metadata_json,
+       content_hash)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.harness, input.sessionId, input.processedAt, endedAtIso, input.outcome, input.candidateCount, input.proposalCount, input.rationale ?? null, input.sourceRun ?? null, JSON.stringify(input.metadata ?? {}), input.contentHash);
+}
+function getExtractedSession(db, harness, sessionId) {
+  const row = db.prepare("SELECT * FROM extract_sessions_seen WHERE harness = ? AND session_id = ?").get(harness, sessionId);
+  return row ?? undefined;
+}
+function getExtractedSessionsMap(db, harness, sessionIds) {
+  const out = new Map;
+  if (sessionIds.length === 0)
+    return out;
+  const CHUNK = 500;
+  for (let i = 0;i < sessionIds.length; i += CHUNK) {
+    const chunk = sessionIds.slice(i, i + CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT * FROM extract_sessions_seen
+         WHERE harness = ? AND session_id IN (${placeholders})`).all(harness, ...chunk);
+    for (const row of rows)
+      out.set(row.session_id, row);
+  }
+  return out;
+}
+function getLastExtractRunAt(db, harness) {
+  const row = db.prepare("SELECT MAX(processed_at) AS last FROM extract_sessions_seen WHERE harness = ?").get(harness);
+  if (!row?.last)
+    return null;
+  const ms = Date.parse(row.last);
+  return Number.isFinite(ms) ? ms : null;
+}
+function shouldSkipAlreadyExtractedSession(prior, currentContentHash) {
+  if (!prior)
+    return false;
+  if (prior.content_hash == null)
+    return false;
+  return prior.content_hash === currentContentHash;
+}
+function getConsolidationJudgedMap(db, entryKeys) {
+  const out = new Map;
+  if (entryKeys.length === 0)
+    return out;
+  const CHUNK = 500;
+  for (let i = 0;i < entryKeys.length; i += CHUNK) {
+    const chunk = entryKeys.slice(i, i + CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT * FROM consolidation_judged WHERE entry_key IN (${placeholders})`).all(...chunk);
+    for (const row of rows)
+      out.set(row.entry_key, row);
+  }
+  return out;
+}
+function upsertConsolidationJudged(db, input) {
+  db.prepare(`
+    INSERT OR REPLACE INTO consolidation_judged
+      (entry_key, content_hash, judged_at, outcome)
+    VALUES (?, ?, ?, ?)
+  `).run(input.entryKey, input.contentHash, input.judgedAt, input.outcome);
+}
+function recordRecombineInduction(db, input) {
+  const row = db.prepare(`
+      INSERT INTO recombine_hypotheses
+        (hypothesis_ref, signature, member_key, consecutive_count, first_seen_at, last_seen_at, last_run)
+      VALUES (?, ?, ?, 1, ?, ?, ?)
+      ON CONFLICT(hypothesis_ref) DO UPDATE SET
+        consecutive_count = consecutive_count + (CASE WHEN last_run IS excluded.last_run THEN 0 ELSE 1 END),
+        last_seen_at = excluded.last_seen_at,
+        last_run = excluded.last_run,
+        signature = excluded.signature,
+        member_key = excluded.member_key
+      RETURNING consecutive_count
+    `).get(input.hypothesisRef, input.signature, input.memberKey, input.seenAt, input.seenAt, input.run);
+  return row?.consecutive_count ?? 0;
+}
+function findMatchingRecombineHypothesis(db, input) {
+  const candidateMembers = new Set(input.memberKey.split("|").filter((m) => m.length > 0));
+  if (candidateMembers.size === 0)
+    return;
+  const rows = db.prepare("SELECT * FROM recombine_hypotheses WHERE signature = ? AND promoted_at IS NULL ORDER BY last_seen_at DESC").all(input.signature);
+  let best;
+  let bestOverlap = -1;
+  for (const row of rows) {
+    const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
+    if (rowMembers.length === 0)
+      continue;
+    let intersection = 0;
+    for (const m of rowMembers) {
+      if (candidateMembers.has(m))
+        intersection += 1;
+    }
+    const union = candidateMembers.size + rowMembers.length - intersection;
+    const overlap = union === 0 ? 0 : intersection / union;
+    if (overlap >= input.minOverlap && overlap > bestOverlap) {
+      best = row;
+      bestOverlap = overlap;
     }
-  ];
+  }
+  return best;
+}
+function getRecombineHypothesis(db, hypothesisRef) {
+  const row = db.prepare("SELECT * FROM recombine_hypotheses WHERE hypothesis_ref = ?").get(hypothesisRef);
+  return row ?? undefined;
+}
+function markRecombineHypothesisPromoted(db, hypothesisRef, promotedAt) {
+  db.prepare("UPDATE recombine_hypotheses SET promoted_at = ?, consecutive_count = 0 WHERE hypothesis_ref = ?").run(promotedAt, hypothesisRef);
+}
+function hypothesisMatchesAnyPresentCluster(row, presentClusters, minOverlap) {
+  const rowMembers = row.member_key.split("|").filter((m) => m.length > 0);
+  if (rowMembers.length === 0)
+    return false;
+  const rowSet = new Set(rowMembers);
+  for (const cluster of presentClusters) {
+    if (cluster.signature !== row.signature)
+      continue;
+    const clusterMembers = cluster.memberKey.split("|").filter((m) => m.length > 0);
+    if (clusterMembers.length === 0)
+      continue;
+    let intersection = 0;
+    for (const m of clusterMembers) {
+      if (rowSet.has(m))
+        intersection += 1;
+    }
+    const union = rowSet.size + clusterMembers.length - intersection;
+    const overlap = union === 0 ? 0 : intersection / union;
+    if (overlap >= minOverlap)
+      return true;
+  }
+  return false;
+}
+function decayUnseenRecombineHypotheses(db, currentRun, seenRefs, opts) {
+  let effectiveSeen = seenRefs;
+  if (opts && opts.presentClusters.length > 0) {
+    const candidates = db.prepare("SELECT hypothesis_ref, signature, member_key FROM recombine_hypotheses WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").all(currentRun);
+    const seenSet = new Set(seenRefs);
+    for (const row of candidates) {
+      if (seenSet.has(row.hypothesis_ref))
+        continue;
+      if (hypothesisMatchesAnyPresentCluster(row, opts.presentClusters, opts.minOverlap)) {
+        seenSet.add(row.hypothesis_ref);
+      }
+    }
+    effectiveSeen = [...seenSet];
+  }
+  return decayUnseenRecombineHypothesesInner(db, currentRun, effectiveSeen);
+}
+function decayUnseenRecombineHypothesesInner(db, currentRun, seenRefs) {
+  if (seenRefs.length === 0) {
+    const res2 = db.prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").run(currentRun);
+    return Number(res2.changes);
+  }
+  if (seenRefs.length > 900) {
+    const res2 = db.prepare("UPDATE recombine_hypotheses SET consecutive_count = 0 WHERE promoted_at IS NULL AND (last_run IS NULL OR last_run != ?) AND consecutive_count != 0").run(currentRun);
+    return Number(res2.changes);
+  }
+  const placeholders = seenRefs.map(() => "?").join(",");
+  const res = db.prepare(`UPDATE recombine_hypotheses SET consecutive_count = 0
+       WHERE promoted_at IS NULL
+         AND (last_run IS NULL OR last_run != ?)
+         AND consecutive_count != 0
+         AND hypothesis_ref NOT IN (${placeholders})`).run(currentRun, ...seenRefs);
+  return Number(res.changes);
+}
+function embeddingToBlob(vec) {
+  const f32 = new Float32Array(vec);
+  return new Uint8Array(f32.buffer);
+}
+function blobToEmbedding(blob) {
+  const f32 = new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+  return Array.from(f32);
+}
+function getBodyEmbeddings(db, contentHashes, expectedModelId) {
+  const out = new Map;
+  if (contentHashes.length === 0)
+    return out;
+  const firstRow = db.prepare("SELECT model_id FROM body_embeddings LIMIT 1").get();
+  if (firstRow && firstRow.model_id !== expectedModelId) {
+    db.exec("DELETE FROM body_embeddings");
+    return out;
+  }
+  const CHUNK = 500;
+  for (let i = 0;i < contentHashes.length; i += CHUNK) {
+    const chunk = contentHashes.slice(i, i + CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(`SELECT content_hash, embedding FROM body_embeddings WHERE content_hash IN (${placeholders})`).all(...chunk);
+    for (const row of rows) {
+      out.set(row.content_hash, blobToEmbedding(row.embedding));
+    }
+  }
+  return out;
+}
+function upsertBodyEmbeddings(db, entries) {
+  if (entries.length === 0)
+    return;
+  const now = Date.now();
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO body_embeddings (content_hash, embedding, model_id, created_at)
+    VALUES (?, ?, ?, ?)
+  `);
+  db.transaction(() => {
+    for (const { contentHash, embedding, modelId } of entries) {
+      stmt.run(contentHash, embeddingToBlob(embedding), modelId, now);
+    }
+  })();
+}
+var init_state_db = __esm(() => {
+  init_managed_db();
+  init_improve_types();
+  init_paths();
+  init_warn();
+  init_migrations();
+  init_migrations();
 });
 
 // src/core/best-effort.ts
@@ -10134,260 +10190,11 @@ function ensureUsageEventsSchema(db) {
   `);
 }
 
-// src/indexer/db/db-backup.ts
-import fs6 from "fs";
-import path6 from "path";
-function resolveRetention(env = process.env) {
-  const raw = env.AKM_DB_BACKUP_RETAIN?.trim();
-  if (!raw)
-    return DEFAULT_RETAIN;
-  const parsed = Number.parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed < 1) {
-    warn("[akm] AKM_DB_BACKUP_RETAIN=%s is not a positive integer; falling back to %d", raw, DEFAULT_RETAIN);
-    return DEFAULT_RETAIN;
-  }
-  return parsed;
-}
-function isBackupDisabled(env = process.env) {
-  const raw = env.AKM_DB_BACKUP?.trim().toLowerCase();
-  if (!raw)
-    return false;
-  return raw === "0" || raw === "false" || raw === "no" || raw === "off";
-}
-function measureDataDirSize(dirPath) {
-  if (!fs6.existsSync(dirPath))
-    return 0;
-  let total = 0;
-  const stack = [dirPath];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === undefined)
-      break;
-    let entries;
-    try {
-      entries = fs6.readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const full = path6.join(current, entry.name);
-      if (current === dirPath && entry.name === BACKUPS_DIR_NAME && entry.isDirectory())
-        continue;
-      if (entry.isDirectory()) {
-        stack.push(full);
-      } else if (entry.isFile()) {
-        bestEffort(() => {
-          total += fs6.statSync(full).size;
-        }, "file vanished between readdir and stat");
-      }
-    }
-  }
-  return total;
-}
-function getFreeSpace(dirPath) {
-  try {
-    const stats = fs6.statfsSync;
-    if (!stats)
-      return null;
-    const res = stats(dirPath);
-    return Number(res.bavail * res.bsize);
-  } catch {
-    return null;
-  }
-}
-function formatTimestamp(d) {
-  return d.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "").replace(/-\d{3}$/, "");
-}
-function listBackups(dataDir) {
-  const backupsRoot = path6.join(dataDir, BACKUPS_DIR_NAME);
-  if (!fs6.existsSync(backupsRoot))
-    return [];
-  const entries = fs6.readdirSync(backupsRoot, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const full = path6.join(backupsRoot, entry.name);
-    const metaPath = path6.join(full, BACKUP_METADATA_FILE);
-    let createdAt;
-    let sourceVersion = null;
-    let sizeBytes;
-    let reason = DEFAULT_BACKUP_REASON;
-    if (fs6.existsSync(metaPath)) {
-      bestEffort(() => {
-        const raw = fs6.readFileSync(metaPath, "utf8");
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.createdAt === "string")
-          createdAt = parsed.createdAt;
-        if (typeof parsed.sourceVersion === "number")
-          sourceVersion = parsed.sourceVersion;
-        else if (parsed.sourceVersion === null)
-          sourceVersion = null;
-        if (typeof parsed.sizeBytes === "number")
-          sizeBytes = parsed.sizeBytes;
-        if (typeof parsed.reason === "string" && parsed.reason.length > 0)
-          reason = parsed.reason;
-      }, "malformed backup metadata \u2014 fall back to filesystem-derived values");
-    }
-    if (!createdAt) {
-      try {
-        createdAt = fs6.statSync(full).mtime.toISOString();
-      } catch {
-        createdAt = new Date(0).toISOString();
-      }
-    }
-    if (sizeBytes === undefined) {
-      sizeBytes = measureDataDirSize(full);
-    }
-    results.push({
-      path: full,
-      name: entry.name,
-      createdAt,
-      sizeBytes,
-      sourceVersion,
-      reason
-    });
-  }
-  results.sort((a, b) => a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0);
-  return results;
-}
-function pruneOldBackups(dataDir, retain) {
-  const existing = listBackups(dataDir);
-  if (existing.length <= retain)
-    return;
-  const toRemove = existing.slice(retain);
-  for (const entry of toRemove) {
-    try {
-      fs6.rmSync(entry.path, { recursive: true, force: true });
-    } catch (err) {
-      warn("[akm] failed to prune old backup %s \u2014 %s", entry.path, err instanceof Error ? err.message : String(err));
-    }
-  }
-}
-function backupDataDir(opts) {
-  const env = opts.env ?? process.env;
-  if (isBackupDisabled(env))
-    return null;
-  const { dataDir, sourceVersion, targetVersion } = opts;
-  const reason = opts.reason && opts.reason.length > 0 ? opts.reason : DEFAULT_BACKUP_REASON;
-  if (!fs6.existsSync(dataDir)) {
-    return null;
-  }
-  const dataDirStat = fs6.statSync(dataDir);
-  if (!dataDirStat.isDirectory()) {
-    warn("[akm] data dir backup skipped \u2014 %s is not a directory", dataDir);
-    return null;
-  }
-  const sourceSize = measureDataDirSize(dataDir);
-  if (sourceSize === 0)
-    return null;
-  const backupsRoot = path6.join(dataDir, BACKUPS_DIR_NAME);
-  try {
-    fs6.mkdirSync(backupsRoot, { recursive: true });
-  } catch (err) {
-    warn("[akm] data dir backup skipped \u2014 could not create %s: %s", backupsRoot, err instanceof Error ? err.message : String(err));
-    return null;
-  }
-  const free = getFreeSpace(backupsRoot);
-  if (free !== null && free < sourceSize * FREE_SPACE_MULTIPLIER) {
-    warn("[akm] data dir backup skipped \u2014 free space %d bytes is less than 1.1\xD7 source size %d bytes (need %d)", free, sourceSize, Math.ceil(sourceSize * FREE_SPACE_MULTIPLIER));
-    return null;
-  }
-  const now = (opts.now ?? (() => new Date))();
-  const stamp = formatTimestamp(now);
-  const dirSuffix = reason === DEFAULT_BACKUP_REASON ? `pre-v${targetVersion}` : reason;
-  const dirName = `${stamp}-${dirSuffix}`;
-  const destPath = path6.join(backupsRoot, dirName);
-  let finalDest = destPath;
-  let suffix = 1;
-  while (fs6.existsSync(finalDest)) {
-    finalDest = `${destPath}-${suffix}`;
-    suffix += 1;
-  }
-  try {
-    copyDataDirExcludingBackups(dataDir, finalDest);
-  } catch (err) {
-    warn("[akm] data dir backup failed \u2014 %s; upgrade will proceed without a snapshot", err instanceof Error ? err.message : String(err));
-    bestEffort(() => fs6.rmSync(finalDest, { recursive: true, force: true }), "cleanup partial backup copy");
-    return null;
-  }
-  const createdAt = now.toISOString();
-  const metadata = {
-    schemaVersion: 1,
-    createdAt,
-    sourceVersion,
-    targetVersion,
-    sizeBytes: sourceSize,
-    reason,
-    hostname: tryHostname(),
-    notes: reason === DEFAULT_BACKUP_REASON ? "Created by AKM before a destructive DB version upgrade. Restore manually by stopping akm and copying the contents back over the live data dir." : `Created by AKM before a destructive ${reason} operation. Restore manually by stopping akm and copying the contents back over the live data dir.`
-  };
-  try {
-    fs6.writeFileSync(path6.join(finalDest, BACKUP_METADATA_FILE), JSON.stringify(metadata, null, 2));
-  } catch (err) {
-    warn("[akm] data dir backup created at %s but metadata write failed \u2014 %s", finalDest, err instanceof Error ? err.message : String(err));
-  }
-  const retain = resolveRetention(env);
-  pruneOldBackups(dataDir, retain);
-  return {
-    path: finalDest,
-    name: path6.basename(finalDest),
-    createdAt,
-    sizeBytes: sourceSize,
-    sourceVersion,
-    targetVersion,
-    reason
-  };
-}
-function copyDataDirExcludingBackups(srcRoot, destRoot) {
-  fs6.mkdirSync(destRoot, { recursive: true });
-  const stack = [{ src: srcRoot, dest: destRoot }];
-  while (stack.length > 0) {
-    const frame = stack.pop();
-    if (frame === undefined)
-      break;
-    const { src, dest } = frame;
-    const entries = fs6.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      if (src === srcRoot) {
-        if (entry.name === BACKUPS_DIR_NAME && entry.isDirectory())
-          continue;
-        if (entry.name === "akm.lock" || entry.name === "akm.lock.lck")
-          continue;
-      }
-      const srcPath = path6.join(src, entry.name);
-      const destPath = path6.join(dest, entry.name);
-      if (entry.isDirectory()) {
-        fs6.mkdirSync(destPath, { recursive: true });
-        stack.push({ src: srcPath, dest: destPath });
-      } else if (entry.isFile()) {
-        fs6.copyFileSync(srcPath, destPath);
-      } else if (entry.isSymbolicLink()) {
-        const target = fs6.readlinkSync(srcPath);
-        bestEffort(() => fs6.symlinkSync(target, destPath), "symlink creation can fail on Windows without admin");
-      }
-    }
-  }
-}
-function tryHostname() {
-  try {
-    const os = __require("os");
-    return os.hostname();
-  } catch {
-    return;
-  }
-}
-var DEFAULT_BACKUP_REASON = "version-upgrade", EMBEDDING_DIM_CHANGE_REASON = "embedding-dim-change", BACKUPS_DIR_NAME = "backups", BACKUP_METADATA_FILE = "backup.meta.json", DEFAULT_RETAIN = 5, FREE_SPACE_MULTIPLIER = 1.1;
-var init_db_backup = __esm(() => {
-  init_best_effort();
-  init_warn();
-});
-
 // src/core/file-lock.ts
-import fs7 from "fs";
+import fs6 from "fs";
 function tryAcquireLockSync(lockPath, payload) {
   try {
-    fs7.writeFileSync(lockPath, payload, { flag: "wx" });
+    fs6.writeFileSync(lockPath, payload, { flag: "wx" });
     return true;
   } catch (err) {
     if (err.code === "EEXIST")
@@ -10399,14 +10206,14 @@ function probeLock(lockPath, opts) {
   let rawContent;
   let ageMs;
   try {
-    rawContent = fs7.readFileSync(lockPath, "utf8");
+    rawContent = fs6.readFileSync(lockPath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT")
       return { state: "absent" };
     return { state: "stale", reason: "unreadable" };
   }
   try {
-    const stat = fs7.statSync(lockPath);
+    const stat = fs6.statSync(lockPath);
     ageMs = Date.now() - stat.mtimeMs;
   } catch {
     return { state: "stale", reason: "unreadable", rawContent };
@@ -10425,7 +10232,7 @@ function probeLock(lockPath, opts) {
 }
 function releaseLock(lockPath) {
   try {
-    fs7.unlinkSync(lockPath);
+    fs6.unlinkSync(lockPath);
   } catch {}
 }
 function extractHolderPid(content) {
@@ -10449,7 +10256,7 @@ var init_file_lock = __esm(() => {
 });
 
 // src/core/config/config-io.ts
-import fs8 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 function parseConfigText(text, sourcePath) {
   const stripped = stripJsonComments(text);
@@ -10484,22 +10291,22 @@ function writeConfigAtomic(configPath, config) {
 `);
 }
 function backupExistingConfig(configPath) {
-  if (!fs8.existsSync(configPath))
+  if (!fs7.existsSync(configPath))
     return;
   const backupDir = path7.join(getCacheDir(), "config-backups");
-  fs8.mkdirSync(backupDir, { recursive: true });
+  fs7.mkdirSync(backupDir, { recursive: true });
   const timestamp = new Date().toISOString().replace(/[.:]/g, "-");
   const timestamped = path7.join(backupDir, `config-${timestamp}.json`);
   const latest = path7.join(backupDir, "config.latest.json");
-  fs8.copyFileSync(configPath, timestamped);
-  fs8.copyFileSync(configPath, latest);
-  pruneOldBackups2(backupDir);
+  fs7.copyFileSync(configPath, timestamped);
+  fs7.copyFileSync(configPath, latest);
+  pruneOldBackups(backupDir);
   return { timestamped, latest };
 }
-function pruneOldBackups2(backupDir) {
+function pruneOldBackups(backupDir) {
   let entries;
   try {
-    entries = fs8.readdirSync(backupDir);
+    entries = fs7.readdirSync(backupDir);
   } catch {
     return;
   }
@@ -10507,13 +10314,13 @@ function pruneOldBackups2(backupDir) {
     const full = path7.join(backupDir, name);
     let mtime = 0;
     try {
-      mtime = fs8.statSync(full).mtimeMs;
+      mtime = fs7.statSync(full).mtimeMs;
     } catch {}
     return { path: full, mtime };
   }).sort((a, b) => b.mtime - a.mtime);
   for (const stale of timestamped.slice(MAX_CONFIG_BACKUPS)) {
     try {
-      fs8.unlinkSync(stale.path);
+      fs7.unlinkSync(stale.path);
     } catch {}
   }
 }
@@ -10526,7 +10333,7 @@ function sleepSyncMs(ms) {
 function acquireConfigLock() {
   const lockPath = getConfigLockPath();
   try {
-    fs8.mkdirSync(path7.dirname(lockPath), { recursive: true });
+    fs7.mkdirSync(path7.dirname(lockPath), { recursive: true });
   } catch {}
   for (let attempt = 0;attempt < CONFIG_LOCK_MAX_RETRIES; attempt++) {
     try {
@@ -10685,7 +10492,7 @@ var init_inline_refs = __esm(() => {
 });
 
 // src/integrations/harnesses/claude/session-log.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import os from "os";
 import path8 from "path";
 function claudeProjectsDir() {
@@ -10747,19 +10554,19 @@ function parseClaudeEvent(entry, sessionId, filePath, fallbackTsMs) {
 class ClaudeCodeProvider {
   name = "claude-code";
   isAvailable() {
-    return fs9.existsSync(claudeProjectsDir());
+    return fs8.existsSync(claudeProjectsDir());
   }
   watchRoots() {
     const dir = claudeProjectsDir();
-    return fs9.existsSync(dir) ? [dir] : [];
+    return fs8.existsSync(dir) ? [dir] : [];
   }
   *readEvents(input) {
     try {
       for (const jsonlPath of this.#walkJsonl(claudeProjectsDir())) {
-        const stat = fs9.statSync(jsonlPath);
+        const stat = fs8.statSync(jsonlPath);
         if (stat.mtimeMs < input.sinceMs)
           continue;
-        const lines = fs9.readFileSync(jsonlPath, "utf8").split(`
+        const lines = fs8.readFileSync(jsonlPath, "utf8").split(`
 `).filter(Boolean);
         for (const line of lines) {
           try {
@@ -10790,7 +10597,7 @@ class ClaudeCodeProvider {
       for (const jsonlPath of this.#walkJsonl(root)) {
         let stat;
         try {
-          stat = fs9.statSync(jsonlPath);
+          stat = fs8.statSync(jsonlPath);
         } catch {
           continue;
         }
@@ -10813,8 +10620,8 @@ class ClaudeCodeProvider {
     return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
   }
   readSession(ref) {
-    const stat = fs9.statSync(ref.filePath);
-    const lines = fs9.readFileSync(ref.filePath, "utf8").split(`
+    const stat = fs8.statSync(ref.filePath);
+    const lines = fs8.readFileSync(ref.filePath, "utf8").split(`
 `).filter(Boolean);
     const events = [];
     const inlineRefs = [];
@@ -10862,12 +10669,12 @@ class ClaudeCodeProvider {
   #peekJsonl(filePath) {
     const result = {};
     try {
-      const fd = fs9.openSync(filePath, "r");
+      const fd = fs8.openSync(filePath, "r");
       try {
-        const stat = fs9.fstatSync(fd);
+        const stat = fs8.fstatSync(fd);
         const headSize = Math.min(stat.size, 4096);
         const head = Buffer.alloc(headSize);
-        fs9.readSync(fd, head, 0, headSize, 0);
+        fs8.readSync(fd, head, 0, headSize, 0);
         const headLines = head.toString("utf8").split(`
 `).filter(Boolean);
         for (const line of headLines) {
@@ -10889,7 +10696,7 @@ class ClaudeCodeProvider {
         if (stat.size > 4096) {
           const tailSize = Math.min(stat.size, 4096);
           const tail = Buffer.alloc(tailSize);
-          fs9.readSync(fd, tail, 0, tailSize, stat.size - tailSize);
+          fs8.readSync(fd, tail, 0, tailSize, stat.size - tailSize);
           const tailLines = tail.toString("utf8").split(`
 `).filter(Boolean);
           for (let i = tailLines.length - 1;i >= 0; i--) {
@@ -10906,14 +10713,14 @@ class ClaudeCodeProvider {
           }
         }
       } finally {
-        fs9.closeSync(fd);
+        fs8.closeSync(fd);
       }
     } catch {}
     return result;
   }
   *#walkJsonl(dir) {
     try {
-      for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
         const full = path8.join(dir, entry.name);
         if (entry.isDirectory())
           yield* this.#walkJsonl(full);
@@ -10971,7 +10778,7 @@ var init_agent_builder2 = __esm(() => {
 var init_config_import2 = () => {};
 
 // src/integrations/harnesses/opencode/session-log.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import os2 from "os";
 import path9 from "path";
 function getOpenCodeBaseDir() {
@@ -10985,31 +10792,31 @@ class OpenCodeProvider {
   name = "opencode";
   #baseDir = getOpenCodeBaseDir();
   isAvailable() {
-    return fs10.existsSync(this.#baseDir);
+    return fs9.existsSync(this.#baseDir);
   }
   #dbPath(base) {
     return path9.join(base, OPENCODE_DB_FILENAME);
   }
   watchRoots() {
     const roots = [];
-    if (fs10.existsSync(this.#dbPath(this.#baseDir)))
+    if (fs9.existsSync(this.#dbPath(this.#baseDir)))
       roots.push(this.#baseDir);
     const sessionRoot = path9.join(this.#baseDir, "storage", "session");
-    if (fs10.existsSync(sessionRoot))
+    if (fs9.existsSync(sessionRoot))
       roots.push(sessionRoot);
     return roots;
   }
   *readEvents(input) {
     const candidates = [this.#baseDir, path9.join(this.#baseDir, "log")];
     for (const dir of candidates) {
-      if (!fs10.existsSync(dir))
+      if (!fs9.existsSync(dir))
         continue;
       try {
-        for (const file of fs10.readdirSync(dir)) {
+        for (const file of fs9.readdirSync(dir)) {
           const full = path9.join(dir, file);
           let stat;
           try {
-            stat = fs10.statSync(full);
+            stat = fs9.statSync(full);
           } catch {
             continue;
           }
@@ -11019,7 +10826,7 @@ class OpenCodeProvider {
             continue;
           if (!file.endsWith(".json") && !file.endsWith(".jsonl") && !file.endsWith(".log"))
             continue;
-          const content = fs10.readFileSync(full, "utf8");
+          const content = fs9.readFileSync(full, "utf8");
           const lines = content.includes(`
 `) ? content.split(`
 `) : [content];
@@ -11047,30 +10854,30 @@ class OpenCodeProvider {
     const base = input.location ?? this.#baseDir;
     const sinceMs = input.sinceMs ?? 0;
     const dbPath = this.#dbPath(base);
-    if (fs10.existsSync(dbPath))
+    if (fs9.existsSync(dbPath))
       return this.#listSessionsFromDb(dbPath, sinceMs);
     const sessionRoot = path9.join(base, "storage", "session");
-    if (!fs10.existsSync(sessionRoot))
+    if (!fs9.existsSync(sessionRoot))
       return [];
     const summaries = [];
     try {
-      for (const projectId of fs10.readdirSync(sessionRoot)) {
+      for (const projectId of fs9.readdirSync(sessionRoot)) {
         const projectDir = path9.join(sessionRoot, projectId);
         let pstat;
         try {
-          pstat = fs10.statSync(projectDir);
+          pstat = fs9.statSync(projectDir);
         } catch {
           continue;
         }
         if (!pstat.isDirectory())
           continue;
-        for (const file of fs10.readdirSync(projectDir)) {
+        for (const file of fs9.readdirSync(projectDir)) {
           if (!file.endsWith(".json"))
             continue;
           const filePath = path9.join(projectDir, file);
           let stat;
           try {
-            stat = fs10.statSync(filePath);
+            stat = fs9.statSync(filePath);
           } catch {
             continue;
           }
@@ -11078,7 +10885,7 @@ class OpenCodeProvider {
             continue;
           let meta;
           try {
-            meta = JSON.parse(fs10.readFileSync(filePath, "utf8"));
+            meta = JSON.parse(fs9.readFileSync(filePath, "utf8"));
           } catch {
             continue;
           }
@@ -11107,7 +10914,7 @@ class OpenCodeProvider {
       return this.#readSessionFromDb(ref);
     let meta = {};
     try {
-      meta = JSON.parse(fs10.readFileSync(ref.filePath, "utf8"));
+      meta = JSON.parse(fs9.readFileSync(ref.filePath, "utf8"));
     } catch {}
     const time = meta.time ?? undefined;
     const startedAt = typeof time?.created === "number" ? time.created : undefined;
@@ -11118,14 +10925,14 @@ class OpenCodeProvider {
     const inlineRefs = [];
     const inferredBase = this.#inferBaseFromSessionPath(ref.filePath) ?? this.#baseDir;
     const msgDir = path9.join(inferredBase, "storage", "message", ref.sessionId);
-    if (fs10.existsSync(msgDir)) {
+    if (fs9.existsSync(msgDir)) {
       try {
-        const files = fs10.readdirSync(msgDir).filter((f) => f.endsWith(".json"));
+        const files = fs9.readdirSync(msgDir).filter((f) => f.endsWith(".json"));
         for (const file of files) {
           const full = path9.join(msgDir, file);
           let msg;
           try {
-            msg = JSON.parse(fs10.readFileSync(full, "utf8"));
+            msg = JSON.parse(fs9.readFileSync(full, "utf8"));
           } catch {
             continue;
           }
@@ -16530,7 +16337,7 @@ __export(exports_config, {
   DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE: () => DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG
 });
-import fs11 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 function resolveBatchSize(configured, contextLength) {
   const base = configured && configured > 0 ? configured : DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE;
@@ -16546,7 +16353,7 @@ function loadUserConfig() {
   const configPath = getConfigPath();
   let stat;
   try {
-    stat = fs11.statSync(configPath);
+    stat = fs10.statSync(configPath);
   } catch {
     cachedConfig = undefined;
     return applyRuntimeEnvApiKeys({ ...DEFAULT_CONFIG });
@@ -16556,7 +16363,7 @@ function loadUserConfig() {
   }
   let text;
   try {
-    text = fs11.readFileSync(configPath, "utf8");
+    text = fs10.readFileSync(configPath, "utf8");
   } catch {
     cachedConfig = undefined;
     return applyRuntimeEnvApiKeys({ ...DEFAULT_CONFIG });
@@ -16565,7 +16372,7 @@ function loadUserConfig() {
   const finalConfig = applyRuntimeEnvApiKeys(parseAndValidate(text, configPath));
   let finalStat = stat;
   try {
-    finalStat = fs11.statSync(configPath);
+    finalStat = fs10.statSync(configPath);
   } catch {}
   cachedConfig = {
     config: finalConfig,
@@ -16625,7 +16432,9 @@ function maybeAutoMigrateConfigFile(configPath, text) {
   } catch {
     return text;
   }
-  if (compareConfigVersion(obj.configVersion, CURRENT_CONFIG_VERSION) === 1) {
+  const onDiskVersion = obj.configVersion;
+  const versionOrder = compareConfigVersion(onDiskVersion, CURRENT_CONFIG_VERSION);
+  if (versionOrder === 1 || onDiskVersion !== undefined && versionOrder === undefined) {
     return text;
   }
   const { changed, result } = migrateConfigShape(obj);
@@ -16669,7 +16478,7 @@ function saveConfig(config) {
   cachedConfig = undefined;
   const configPath = getConfigPath();
   const dir = path10.dirname(configPath);
-  fs11.mkdirSync(dir, { recursive: true });
+  fs10.mkdirSync(dir, { recursive: true });
   const sanitized = sanitizeConfigForWrite(config);
   const parseResult = AkmConfigSchema.safeParse(sanitized);
   if (!parseResult.success) {
@@ -16793,7 +16602,7 @@ function applyRuntimeEnvApiKeys(config) {
     if (envKey)
       next.embedding = { ...next.embedding, apiKey: envKey };
   }
-  const defaultProfile = next.defaults?.llm;
+  const defaultProfile = resolveDefaultLlmProfileName(next);
   if (next.profiles?.llm) {
     const updated = { ...next.profiles.llm };
     let changed = false;
@@ -16829,7 +16638,7 @@ function warnIfProjectConfigPresent(startDir) {
 }
 function isFile(filePath) {
   try {
-    return fs11.statSync(filePath).isFile();
+    return fs10.statSync(filePath).isFile();
   } catch {
     return false;
   }
@@ -16885,8 +16694,9 @@ __export(exports_db, {
   sanitizeFtsQuery: () => sanitizeFtsQuery,
   relinkUsageEvents: () => relinkUsageEvents,
   rebuildFts: () => rebuildFts,
+  purgeEmbeddings: () => purgeEmbeddings,
+  openIndexDatabase: () => openIndexDatabase,
   openExistingDatabase: () => openExistingDatabase,
-  openDatabase: () => openDatabase2,
   isVecAvailable: () => isVecAvailable,
   getZeroResultSearches: () => getZeroResultSearches,
   getUtilityScoresByIds: () => getUtilityScoresByIds,
@@ -16932,20 +16742,20 @@ __export(exports_db, {
   EMBEDDING_DIM: () => EMBEDDING_DIM,
   DB_VERSION: () => DB_VERSION
 });
-import fs12 from "fs";
+import fs11 from "fs";
 import { createRequire as createRequire3 } from "module";
 import path11 from "path";
-function openDatabase2(dbPath, options) {
+function openIndexDatabase(dbPath, options) {
   const resolvedPath = dbPath ?? getDbPath();
   const dir = path11.dirname(resolvedPath);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
   const db = openDatabase(resolvedPath);
   applyStandardPragmas(db, { dataDir: dir });
   loadVecExtension(db);
   const resolvedDim = options?.embeddingDim ?? resolveConfiguredEmbeddingDim();
-  ensureSchema(db, resolvedDim, { dataDir: dir });
+  ensureSchema(db, resolvedDim);
   warnIfVecMissing(db, { once: true });
   return db;
 }
@@ -17001,34 +16811,13 @@ function warnIfVecMissing(db, { once } = { once: false }) {
     }
   }, "embeddings table may not exist yet during init");
 }
-function ensureSchema(db, embeddingDim, options) {
+function ensureSchema(db, embeddingDim) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS index_meta (
       key   TEXT PRIMARY KEY,
       value TEXT NOT NULL
     );
   `);
-  if (options?.dataDir) {
-    const storedVersionRaw = getMeta(db, "version");
-    const storedVersion = storedVersionRaw !== undefined && storedVersionRaw !== "" ? Number.parseInt(storedVersionRaw, 10) : null;
-    const willUpgrade = storedVersionRaw !== undefined && storedVersionRaw !== "" && storedVersionRaw !== String(DB_VERSION);
-    if (willUpgrade) {
-      try {
-        const result = backupDataDir({
-          dataDir: options.dataDir,
-          sourceVersion: storedVersion !== null && !Number.isNaN(storedVersion) ? storedVersion : null,
-          targetVersion: DB_VERSION,
-          env: process.env
-        });
-        if (result) {
-          warn("[akm] data directory backed up to %s before v%s\u2192v%d upgrade", result.path, storedVersionRaw, DB_VERSION);
-        }
-      } catch (err) {
-        warn("[akm] pre-upgrade data dir backup raised an unexpected error \u2014 %s; upgrade will proceed without a snapshot", err instanceof Error ? err.message : String(err));
-      }
-    }
-  }
-  const usageBackup = handleVersionUpgrade(db);
   db.exec(`
     CREATE TABLE IF NOT EXISTS entries (
       id          INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -17231,10 +17020,7 @@ function ensureSchema(db, embeddingDim, options) {
     if (dimExplicit) {
       const storedDim = getMeta(db, "embeddingDim");
       if (storedDim && storedDim !== String(embeddingDim)) {
-        backupBeforeEmbeddingDimChange(options?.dataDir, storedDim, String(embeddingDim));
-        bestEffort(() => db.exec("DROP TABLE IF EXISTS entries_vec"), "drop entries_vec on dim change");
-        bestEffort(() => db.exec("DELETE FROM embeddings"), "delete stale embeddings on dim change");
-        setMeta(db, "hasEmbeddings", "0");
+        purgeEmbeddings(db, { dropVecTable: true });
       }
     }
     const vecExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'").get();
@@ -17256,109 +17042,20 @@ function ensureSchema(db, embeddingDim, options) {
     if (dimExplicit) {
       const storedDim = getMeta(db, "embeddingDim");
       if (storedDim && storedDim !== String(embeddingDim)) {
-        backupBeforeEmbeddingDimChange(options?.dataDir, storedDim, String(embeddingDim));
-        bestEffort(() => db.exec("DELETE FROM embeddings"), "delete embeddings on explicit dim change");
-        setMeta(db, "hasEmbeddings", "0");
+        purgeEmbeddings(db);
       }
       setMeta(db, "embeddingDim", String(embeddingDim));
     }
   }
   ensureUsageEventsSchema(db);
   db.exec(REGISTRY_INDEX_CACHE_DDL);
-  restoreUsageEventsBackup(db, usageBackup);
-}
-function handleVersionUpgrade(db) {
-  const storedVersion = getMeta(db, "version");
-  if (storedVersion === undefined || storedVersion === "" || storedVersion === String(DB_VERSION))
-    return [];
-  let usageBackup = [];
-  bestEffort(() => {
-    usageBackup = db.prepare("SELECT * FROM usage_events").all();
-  }, "usage_events table may not exist in older versions");
-  db.exec("DROP TABLE IF EXISTS utility_scores");
-  db.exec("DROP TABLE IF EXISTS utility_scores_scoped");
-  db.exec("DROP INDEX IF EXISTS idx_utility_scores_scoped_entry_id");
-  db.exec("DROP TABLE IF EXISTS usage_events");
-  db.exec("DROP TABLE IF EXISTS embeddings");
-  db.exec("DROP TABLE IF EXISTS entries_vec");
-  db.exec("DROP TABLE IF EXISTS entries_fts");
-  db.exec("DROP TABLE IF EXISTS index_dir_state");
-  db.exec("DROP TABLE IF EXISTS llm_enrichment_cache");
-  db.exec("DROP INDEX IF EXISTS idx_llm_cache_updated");
-  db.exec("DROP TABLE IF EXISTS graph_extraction_queue");
-  db.exec("DROP TABLE IF EXISTS graph_file_relations");
-  db.exec("DROP TABLE IF EXISTS graph_file_entities");
-  db.exec("DROP TABLE IF EXISTS graph_files");
-  db.exec("DROP TABLE IF EXISTS graph_meta");
-  db.exec("DROP TABLE IF EXISTS graph_relations");
-  db.exec("DROP TABLE IF EXISTS graph_entities");
-  db.exec("DROP TABLE IF EXISTS graph_nodes");
-  db.exec("DROP TABLE IF EXISTS graph_stashes");
-  db.exec("DROP INDEX IF EXISTS idx_entries_dir");
-  db.exec("DROP INDEX IF EXISTS idx_entries_type");
-  db.exec("DROP TABLE IF EXISTS entries");
-  db.exec("DELETE FROM index_meta");
-  warn("[akm] Index rebuilt due to version upgrade. Run 'akm index' to repopulate.");
-  return usageBackup;
-}
-function backupBeforeEmbeddingDimChange(dataDir, fromDim, toDim) {
-  if (!dataDir)
-    return;
-  try {
-    const result = backupDataDir({
-      dataDir,
-      sourceVersion: DB_VERSION,
-      targetVersion: DB_VERSION,
-      reason: EMBEDDING_DIM_CHANGE_REASON,
-      env: process.env
-    });
-    if (result) {
-      warn("[akm] embedding dimension changed %s\u2192%s; data directory backed up to %s; embeddings will be regenerated", fromDim, toDim, result.path);
-    }
-  } catch (err) {
-    warn("[akm] pre-embedding-dim-change data dir backup raised an unexpected error \u2014 %s; embeddings will be regenerated without a snapshot", err instanceof Error ? err.message : String(err));
-  }
 }
-function restoreUsageEventsBackup(db, backup) {
-  if (backup.length === 0)
-    return;
-  try {
-    const targetCols = db.prepare("PRAGMA table_info(usage_events)").all().map((c) => c.name);
-    if (targetCols.length === 0) {
-      warn("[db] restoreUsageEventsBackup: usage_events table missing \u2014 discarding %d backup row(s)", backup.length);
-      return;
-    }
-    const targetSet = new Set(targetCols);
-    const backupCols = Object.keys(backup[0] ?? {});
-    const projectedCols = backupCols.filter((c) => targetSet.has(c));
-    const droppedCols = backupCols.filter((c) => !targetSet.has(c));
-    if (projectedCols.length === 0) {
-      warn("[db] restoreUsageEventsBackup: no overlapping columns between backup and current schema \u2014 discarding %d row(s); dropped: %s", backup.length, droppedCols.join(", ") || "(none)");
-      return;
-    }
-    if (droppedCols.length > 0) {
-      warn("[db] restoreUsageEventsBackup: dropping columns no longer in usage_events schema: %s", droppedCols.join(", "));
-    }
-    let restored = 0;
-    let failed = 0;
-    db.transaction(() => {
-      const placeholders = projectedCols.map(() => "?").join(", ");
-      const insert = db.prepare(`INSERT INTO usage_events (${projectedCols.join(", ")}) VALUES (${placeholders})`);
-      for (const row of backup) {
-        try {
-          insert.run(...projectedCols.map((c) => row[c]));
-          restored++;
-        } catch {
-          failed++;
-        }
-      }
-    })();
-    if (failed > 0) {
-      warn("[db] restoreUsageEventsBackup: restored %d row(s); skipped %d incompatible row(s)", restored, failed);
-    }
-  } catch (err) {
-    warn("[db] restoreUsageEventsBackup: discarded %d backup row(s) \u2014 %s", backup.length, err instanceof Error ? err.message : String(err));
+function purgeEmbeddings(db, opts) {
+  bestEffort(() => db.exec("DELETE FROM embeddings"), "purge embeddings");
+  if (isVecAvailable(db)) {
+    bestEffort(() => db.exec(opts?.dropVecTable ? "DROP TABLE IF EXISTS entries_vec" : "DELETE FROM entries_vec"), "purge entries_vec");
   }
+  setMeta(db, "hasEmbeddings", "0");
 }
 function getMeta(db, key) {
   const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
@@ -18282,18 +17979,27 @@ function collectTagSetFromEntries(db, entryType) {
   }
   return tags;
 }
-var DB_VERSION = 17, EMBEDDING_DIM = 384, GRAPH_SCHEMA_VERSION = 4, vecStatus, VEC_DOCS_URL = "https://github.com/itlackey/akm/blob/main/docs/configuration.md#sqlite-vec-extension", VEC_FALLBACK_THRESHOLD = 1e4, vecInitWarnedDbs, SQLITE_CHUNK_SIZE = 500, upsertStmtsByDb, FEEDBACK_LR = 0.1, FEEDBACK_REWARD_POSITIVE = 1, FEEDBACK_REWARD_NEGATIVE = 0, MAX_NEG_DELTA_PER_CALL = 0.15, UTILITY_REVIEW_THRESHOLD = 0.5, HIGH_UTILITY_THRESHOLD = 0.5;
+var DB_VERSION = 17, EMBEDDING_DIM = 384, GRAPH_SCHEMA_VERSION = 4, vecStatus, VEC_DOCS_URL = "https://github.com/itlackey/akm/blob/main/docs/configuration.md#sqlite-vec-extension", VEC_FALLBACK_THRESHOLD = 1e4, vecInitWarnedDbs, REGISTRY_INDEX_CACHE_DDL = `
+  CREATE TABLE IF NOT EXISTS registry_index_cache (
+    registry_url  TEXT    PRIMARY KEY,
+    fetched_at    TEXT    NOT NULL,
+    etag          TEXT,
+    last_modified TEXT,
+    index_json    TEXT    NOT NULL DEFAULT '{}'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_registry_cache_fetched
+    ON registry_index_cache(fetched_at);
+`, SQLITE_CHUNK_SIZE = 500, upsertStmtsByDb, FEEDBACK_LR = 0.1, FEEDBACK_REWARD_POSITIVE = 1, FEEDBACK_REWARD_NEGATIVE = 0, MAX_NEG_DELTA_PER_CALL = 0.15, UTILITY_REVIEW_THRESHOLD = 0.5, HIGH_UTILITY_THRESHOLD = 0.5;
 var init_db = __esm(() => {
   init_asset_ref();
   init_best_effort();
   init_paths();
-  init_state_db();
   init_warn();
   init_types();
   init_runtime();
   init_database();
   init_sqlite_pragmas();
-  init_db_backup();
   vecStatus = new WeakMap;
   vecInitWarnedDbs = new WeakSet;
   upsertStmtsByDb = new WeakMap;
@@ -18313,12 +18019,12 @@ __export(exports_graph_db, {
   drainExtractionQueue: () => drainExtractionQueue,
   deleteStoredGraph: () => deleteStoredGraph
 });
-import fs13 from "fs";
+import fs12 from "fs";
 function withReadableGraphDb(db, fn) {
   if (db)
     return fn(db);
   const dbPath = getDbPath();
-  if (!fs13.existsSync(dbPath))
+  if (!fs12.existsSync(dbPath))
     throw new Error("GRAPH_DB_MISSING");
   const opened = openExistingDatabase(dbPath);
   try {
@@ -18662,7 +18368,7 @@ var init_graph_db = __esm(() => {
 
 // scripts/migrate-storage.ts
 init_paths();
-import fs14 from "fs";
+import fs13 from "fs";
 import os3 from "os";
 import path12 from "path";
 import readline from "readline";
@@ -18705,14 +18411,14 @@ var PATHS = {
 };
 var versionReports = [];
 function ensureDir(dir) {
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
   }
 }
 function copyAndVerify(src, dest) {
-  fs14.copyFileSync(src, dest);
-  const srcStat = fs14.statSync(src);
-  const destStat = fs14.statSync(dest);
+  fs13.copyFileSync(src, dest);
+  const srcStat = fs13.statSync(src);
+  const destStat = fs13.statSync(dest);
   return destStat.size === srcStat.size;
 }
 function copyTree(src, dest, opts) {
@@ -18720,7 +18426,7 @@ function copyTree(src, dest, opts) {
   let skipped = 0;
   let failed = 0;
   ensureDir(dest);
-  for (const entry of fs14.readdirSync(src, { withFileTypes: true })) {
+  for (const entry of fs13.readdirSync(src, { withFileTypes: true })) {
     const srcEntry = path12.join(src, entry.name);
     const destEntry = path12.join(dest, entry.name);
     if (entry.isDirectory()) {
@@ -18730,7 +18436,7 @@ function copyTree(src, dest, opts) {
       failed += sub.failed;
       continue;
     }
-    if (!opts.clobber && fs14.existsSync(destEntry)) {
+    if (!opts.clobber && fs13.existsSync(destEntry)) {
       skipped++;
       continue;
     }
@@ -18748,7 +18454,7 @@ function copyTree(src, dest, opts) {
 }
 function countFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
       count += countFilesRecursive(path12.join(dir, entry.name));
     } else {
@@ -18765,10 +18471,10 @@ async function runSteps(steps, ctx) {
 function migrateDb(ctx, filename) {
   const src = path12.join(ctx.paths.cacheDir, filename);
   const dest = path12.join(ctx.paths.dataDir, filename);
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: filename, status: "skipped", detail: "source not found" };
   }
-  if (fs14.existsSync(dest)) {
+  if (fs13.existsSync(dest)) {
     return { name: filename, status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -18787,7 +18493,7 @@ function migrateDb(ctx, filename) {
 }
 async function migrateEventsJsonl(ctx) {
   const src = path12.join(ctx.paths.cacheDir, "events.jsonl");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "events.jsonl \u2192 state.db", status: "skipped", detail: "source not found" };
   }
   if (ctx.dryRun) {
@@ -18833,11 +18539,11 @@ async function migrateEventsJsonl(ctx) {
 function migrateTaskHistory(ctx) {
   const src = path12.join(ctx.paths.cacheDir, "tasks", "history");
   const dest = path12.join(ctx.paths.stateDir, "tasks", "history");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "tasks/history/", status: "skipped", detail: "source directory not found" };
   }
   try {
-    const files = fs14.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+    const files = fs13.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
     if (files.length === 0) {
       return { name: "tasks/history/", status: "skipped", detail: "no *.jsonl files found in source directory" };
     }
@@ -18884,10 +18590,10 @@ function migrateTaskHistory(ctx) {
 function migrateLockfile(ctx) {
   const src = path12.join(ctx.paths.configDir, "akm.lock");
   const dest = path12.join(ctx.paths.dataDir, "akm.lock");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "akm.lock", status: "skipped", detail: "source not found" };
   }
-  if (fs14.existsSync(dest)) {
+  if (fs13.existsSync(dest)) {
     return { name: "akm.lock", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -18909,10 +18615,10 @@ function migrateLockfile(ctx) {
 function migrateConfigBackups(ctx) {
   const src = path12.join(ctx.paths.cacheDir, "config-backups");
   const dest = path12.join(ctx.paths.dataDir, "config-backups");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "config-backups/", status: "skipped", detail: "source directory not found" };
   }
-  if (fs14.existsSync(dest)) {
+  if (fs13.existsSync(dest)) {
     return { name: "config-backups/", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -18929,7 +18635,7 @@ function migrateConfigBackups(ctx) {
   try {
     const srcCount = countFilesRecursive(src);
     const { copied, failed } = copyTree(src, dest, { clobber: true });
-    const destCount = fs14.existsSync(dest) ? countFilesRecursive(dest) : 0;
+    const destCount = fs13.existsSync(dest) ? countFilesRecursive(dest) : 0;
     if (failed === 0 && destCount === srcCount) {
       return {
         name: "config-backups/",
@@ -18949,10 +18655,10 @@ function migrateConfigBackups(ctx) {
 }
 async function migrateTaskHistoryToDb(ctx) {
   const src = path12.join(ctx.paths.cacheDir, "tasks", "history");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "tasks/history/ \u2192 state.db", status: "skipped", detail: "source directory not found" };
   }
-  const files = fs14.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+  const files = fs13.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
   if (files.length === 0) {
     return {
       name: "tasks/history/ \u2192 state.db",
@@ -18976,7 +18682,7 @@ async function migrateTaskHistoryToDb(ctx) {
     try {
       for (const file of files) {
         const filePath = path12.join(src, file);
-        const text = fs14.readFileSync(filePath, "utf8");
+        const text = fs13.readFileSync(filePath, "utf8");
         const lines = text.split(`
 `).filter((l) => l.trim().length > 0);
         db.exec("BEGIN");
@@ -19036,10 +18742,10 @@ async function migrateTaskHistoryToDb(ctx) {
 }
 function noteRegistryIndexCache(ctx) {
   const src = path12.join(ctx.paths.cacheDir, "registry-index");
-  if (!fs14.existsSync(src)) {
+  if (!fs13.existsSync(src)) {
     return { name: "registry-index/ (note)", status: "skipped", detail: "no old $CACHE/registry-index/ directory found" };
   }
-  const legacyFiles = fs14.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
+  const legacyFiles = fs13.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
   if (legacyFiles.length === 0) {
     return { name: "registry-index/ (note)", status: "skipped", detail: "no old *.json cache files found" };
   }
@@ -19071,7 +18777,7 @@ var v07To08Migration = {
       path12.join(paths.cacheDir, "config-backups"),
       path12.join(paths.cacheDir, "registry-index")
     ];
-    return candidates.some((p) => fs14.existsSync(p));
+    return candidates.some((p) => fs13.existsSync(p));
   },
   steps: [
     { id: "index-db", title: "index.db", run: (ctx) => migrateDb(ctx, "index.db") },
@@ -19093,13 +18799,13 @@ function legacyGraphCandidatePaths(ctx) {
 }
 function findLegacyGraphFile(ctx) {
   for (const candidate of legacyGraphCandidatePaths(ctx)) {
-    if (fs14.existsSync(candidate) && fs14.statSync(candidate).isFile())
+    if (fs13.existsSync(candidate) && fs13.statSync(candidate).isFile())
       return candidate;
   }
   const graphDir = path12.join(ctx.paths.cacheDir, "graph");
-  if (fs14.existsSync(graphDir) && fs14.statSync(graphDir).isDirectory()) {
+  if (fs13.existsSync(graphDir) && fs13.statSync(graphDir).isDirectory()) {
     try {
-      const json = fs14.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path12.join(graphDir, f));
+      const json = fs13.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path12.join(graphDir, f));
       if (json.length > 0)
         return json[0];
     } catch {}
@@ -19135,7 +18841,7 @@ async function migrateGraphFileToDb(ctx) {
   if (!legacyFile) {
     return { name, status: "skipped", detail: "no legacy graph file found" };
   }
-  if (!fs14.existsSync(ctx.paths.indexDbPath)) {
+  if (!fs13.existsSync(ctx.paths.indexDbPath)) {
     return {
       name,
       status: "skipped",
@@ -19150,7 +18856,7 @@ async function migrateGraphFileToDb(ctx) {
     };
   }
   try {
-    const raw = fs14.readFileSync(legacyFile, "utf8");
+    const raw = fs13.readFileSync(legacyFile, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -19227,7 +18933,7 @@ async function migrateGraphFileToDb(ctx) {
       }
       const renamed = `${legacyFile}.migrated`;
       try {
-        fs14.renameSync(legacyFile, renamed);
+        fs13.renameSync(legacyFile, renamed);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
@@ -19252,8 +18958,8 @@ async function migrateGraphFileToDb(ctx) {
 function resolvePrimaryStashDir(configDirPath) {
   try {
     const cfgPath = path12.join(configDirPath, "config.json");
-    if (fs14.existsSync(cfgPath)) {
-      const cfg = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+    if (fs13.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs13.readFileSync(cfgPath, "utf8"));
       if (typeof cfg.stashDir === "string" && cfg.stashDir.length > 0)
         return cfg.stashDir;
     }
@@ -19262,7 +18968,7 @@ function resolvePrimaryStashDir(configDirPath) {
 }
 function countEnvFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13.readdirSync(dir, { withFileTypes: true })) {
     const full = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       count += countEnvFilesRecursive(full);
@@ -19275,12 +18981,12 @@ function countEnvFilesRecursive(dir) {
 function chmodTreeSecure(dir) {
   const isWin = process.platform === "win32";
   try {
-    fs14.chmodSync(dir, 448);
+    fs13.chmodSync(dir, 448);
   } catch (err) {
     if (!isWin)
       return { ok: false, detail: `chmod 0700 ${dir} failed: ${err instanceof Error ? err.message : err}` };
   }
-  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs13.readdirSync(dir, { withFileTypes: true })) {
     const full = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       const sub = chmodTreeSecure(full);
@@ -19289,8 +18995,8 @@ function chmodTreeSecure(dir) {
       continue;
     }
     try {
-      fs14.chmodSync(full, 384);
-      if (!isWin && (fs14.statSync(full).mode & 511) !== 384) {
+      fs13.chmodSync(full, 384);
+      if (!isWin && (fs13.statSync(full).mode & 511) !== 384) {
         return { ok: false, detail: `mode verification failed for ${full}` };
       }
     } catch (err) {
@@ -19306,10 +19012,10 @@ async function migrateVaultsToEnv(ctx) {
   const vaultsDir = path12.join(stashDir, "vaults");
   const envDir = path12.join(stashDir, "env");
   const marker = path12.join(vaultsDir, MIGRATED_MARKER);
-  if (!fs14.existsSync(vaultsDir)) {
+  if (!fs13.existsSync(vaultsDir)) {
     return { name, status: "skipped", detail: `no vaults/ directory under ${stashDir}` };
   }
-  if (fs14.existsSync(marker)) {
+  if (fs13.existsSync(marker)) {
     return { name, status: "skipped", detail: "already migrated (.migrated marker present)" };
   }
   const vaultEnvCount = countEnvFilesRecursive(vaultsDir);
@@ -19340,7 +19046,7 @@ async function migrateVaultsToEnv(ctx) {
         detail: `post-copy count ${envEnvCount} < source ${vaultEnvCount}; no marker written`
       };
     }
-    fs14.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
+    fs13.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
 `, { mode: 384 });
     return {
       name,