akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/scripts/migrate-storage.js

@@ -1,3816 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/core/errors.ts
-function isTestIsolationError(err) {
-  return err instanceof ConfigError && err.code === "TEST_ISOLATION_MISSING";
-}
-function rethrowIfTestIsolationError(err) {
-  if (isTestIsolationError(err)) {
-    throw err;
-  }
-}
-var CONFIG_HINTS, AkmError, ConfigError;
-var init_errors = __esm(() => {
-  CONFIG_HINTS = {
-    STASH_DIR_NOT_FOUND: "Run `akm setup` to create and configure your stash, or set stashDir in your config.",
-    STASH_DIR_NOT_A_DIRECTORY: "The configured stashDir exists but isn't a directory. Update stashDir to point at a folder.",
-    STASH_DIR_UNREADABLE: "Check the path exists and your user has read permission, or update stashDir.",
-    EMBEDDING_NOT_CONFIGURED: 'Run `akm config set embedding \'{"endpoint":"...","model":"..."}\'` to enable embeddings.',
-    LLM_NOT_CONFIGURED: 'Run `akm setup` or configure an `engines` entry with `kind: "llm"`, then select it with `defaults.llmEngine`.',
-    TEST_ISOLATION_MISSING: "Under bun test, when AKM_STASH_DIR is set you MUST also set XDG_DATA_HOME (or AKM_DATA_DIR) and XDG_STATE_HOME (or AKM_STATE_DIR) to temp directories so the test does not touch the developer's real ~/.local/share/akm or ~/.local/state/akm.",
-    SETUP_TMP_STASH_REFUSED: "Use a persistent directory, or set AKM_FORCE_SETUP_TMP_STASH=1 to opt in to a sandboxed setup (setup also pre-sets AKM_STASH_DIR so config and cache writes auto-isolate into $stashDir/.akm/ — host config is preserved).",
-    UNSAFE_STASH_DIR: "Choose a path inside your home directory (e.g. ~/akm) or another empty workspace. The stash directory cannot be the filesystem root, your home directory itself, or a sensitive system path like /etc, /var, ~/.config, or ~/.ssh.",
-    UNKNOWN_IMPROVE_STRATEGY: "Pass one of the listed strategy names to `--strategy`, or define it under `improve.strategies`. Names are case-sensitive."
-  };
-  AkmError = class AkmError extends Error {
-  };
-  ConfigError = class ConfigError extends AkmError {
-    kind = "config";
-    code;
-    _hint;
-    constructor(msg, code = "INVALID_CONFIG_FILE", hint) {
-      super(msg);
-      this.name = "ConfigError";
-      this.code = code;
-      this._hint = hint;
-      Object.setPrototypeOf(this, new.target.prototype);
-    }
-    hint() {
-      return this._hint ?? CONFIG_HINTS[this.code];
-    }
-  };
-});
-
-// src/core/platform.ts
-var IS_WINDOWS;
-var init_platform = __esm(() => {
-  IS_WINDOWS = process.platform === "win32";
-});
-
-// src/core/warn.ts
-import fs from "node:fs";
-function isVerbose() {
-  const env = process.env.AKM_VERBOSE?.trim().toLowerCase();
-  if (env === "1" || env === "true" || env === "yes" || env === "on")
-    return true;
-  if (env === "0" || env === "false" || env === "no" || env === "off")
-    return false;
-  return verbose;
-}
-function appendToLogFile(level, args) {
-  if (!logFilePath)
-    return;
-  const ts = new Date().toISOString();
-  const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-  try {
-    fs.appendFileSync(logFilePath, `[${ts}] [${level}] ${msg}
-`);
-  } catch (e) {
-    process.stderr.write(`[akm:warn] log-file write failed (${logFilePath}): ${e}
-`);
-    process.stderr.write(`[${ts}] [${level}] ${msg}
-`);
-  }
-}
-function warn(...args) {
-  if (sinkOverride) {
-    sinkOverride("warn", args);
-    return;
-  }
-  appendToLogFile("WARN", args);
-  if (!quiet) {
-    console.warn(...args);
-  }
-}
-function error(...args) {
-  if (sinkOverride) {
-    sinkOverride("error", args);
-    return;
-  }
-  appendToLogFile("ERROR", args);
-  if (!quiet) {
-    console.error(...args);
-  }
-}
-function warnVerbose(...args) {
-  if (sinkOverride) {
-    sinkOverride("warnVerbose", args);
-    return;
-  }
-  if (isVerbose()) {
-    warn(...args);
-  }
-}
-var quiet = false, verbose = false, logFilePath, sinkOverride;
-var init_warn = () => {};
-
-// src/storage/database.ts
-import { createRequire as createRequire2 } from "node:module";
-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 provider;
-}
-function openDatabase(path2, opts) {
-  return selectProvider().open(path2, opts);
-}
-function openBunDatabase(path2, opts) {
-  const { Database: BunDatabase } = loadBunSqlite();
-  const db = opts ? new BunDatabase(path2, bunOptions(opts)) : new BunDatabase(path2);
-  return db;
-}
-function bunOptions(opts) {
-  const out = {};
-  if (opts.readonly !== undefined)
-    out.readonly = opts.readonly;
-  if (opts.create !== undefined)
-    out.create = opts.create;
-  return out;
-}
-function loadBunSqlite() {
-  if (!bunSqliteModule) {
-    bunSqliteModule = nodeRequire("bun:sqlite");
-  }
-  return bunSqliteModule;
-}
-function loadBetterSqlite3() {
-  if (!betterSqlite3Ctor) {
-    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.
-` + `  • 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 — Node loads it from akm's own node_modules).
-` + `  • 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;
-}
-function openNodeDatabase(path2, opts) {
-  const BetterSqlite3 = loadBetterSqlite3();
-  const options = {};
-  if (opts?.readonly !== undefined)
-    options.readonly = opts.readonly;
-  if (opts?.create === false)
-    options.fileMustExist = true;
-  const db = opts ? new BetterSqlite3(path2, options) : new BetterSqlite3(path2);
-  return {
-    prepare: db.prepare.bind(db),
-    exec: db.exec.bind(db),
-    run: (sql, ...params) => db.prepare(sql).run(...params),
-    transaction: db.transaction.bind(db),
-    get inTransaction() {
-      return db.inTransaction;
-    },
-    close: db.close.bind(db)
-  };
-}
-var isBun, nodeRequire, bunSqliteProvider, nodeSqliteProvider, PROVIDERS, bunSqliteModule, betterSqlite3Ctor;
-var init_database = __esm(() => {
-  isBun = !!process.versions?.bun;
-  nodeRequire = createRequire2(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
-import crypto from "node:crypto";
-function migrationChecksum(migration) {
-  return crypto.createHash("sha256").update(migration.id).update("\x00").update(migration.up).digest("hex");
-}
-function migrationsTableExists(db) {
-  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
-}
-function ledgerHasChecksum(db) {
-  return db.prepare("PRAGMA table_info(schema_migrations)").all().some((column) => column.name === "checksum");
-}
-function inspectLedgerAgainst(db, expected) {
-  const registryIds = expected.map((entry) => entry.id);
-  if (new Set(registryIds).size !== registryIds.length) {
-    return {
-      status: "inconsistent",
-      migrationIds: [],
-      checksums: [],
-      detail: "migration registry contains duplicate IDs"
-    };
-  }
-  if (!migrationsTableExists(db))
-    return { status: registryIds.length === 0 ? "current" : "old", migrationIds: [], checksums: [] };
-  const hasChecksum = ledgerHasChecksum(db);
-  const rows = db.prepare(`SELECT id${hasChecksum ? ", checksum" : ""} FROM schema_migrations ORDER BY rowid`).all();
-  const migrationIds = rows.map((row) => row.id);
-  const checksums = rows.map((row) => row.checksum ?? null);
-  for (let index = 0;index < rows.length; index += 1) {
-    const entry = expected[index];
-    const row = rows[index];
-    if (!entry) {
-      return { status: "newer", migrationIds, checksums, detail: `unknown migration ID ${row.id}` };
-    }
-    if (row.id !== entry.id) {
-      const knownLater = registryIds.includes(row.id);
-      return {
-        status: knownLater ? "inconsistent" : "newer",
-        migrationIds,
-        checksums,
-        detail: knownLater ? `migration ledger is not an exact ordered prefix at position ${index + 1}` : `unknown migration ID ${row.id}`
-      };
-    }
-    if (row.checksum && row.checksum !== entry.checksum) {
-      return {
-        status: "inconsistent",
-        migrationIds,
-        checksums,
-        detail: `migration ${row.id} checksum does not match the released migration body`
-      };
-    }
-  }
-  const missingChecksum = checksums.indexOf(null);
-  if (missingChecksum >= 0) {
-    return {
-      status: "old",
-      migrationIds,
-      checksums,
-      detail: `migration ${migrationIds[missingChecksum]} has not been sealed with a checksum`
-    };
-  }
-  return {
-    status: rows.length === expected.length ? "current" : "old",
-    migrationIds,
-    checksums
-  };
-}
-function inspectMigrationLedger(db, migrations) {
-  return inspectLedgerAgainst(db, migrations.map((migration) => ({ id: migration.id, checksum: migrationChecksum(migration) })));
-}
-function assertMigrationLedger(db, migrations) {
-  const state = inspectMigrationLedger(db, migrations);
-  if (state.status === "newer") {
-    throw new Error(`Refusing to open a database with a newer migration ledger: ${state.detail}.`);
-  }
-  if (state.status === "inconsistent") {
-    throw new Error(`Refusing a database whose migrations are not an exact ordered prefix: ${state.detail}.`);
-  }
-  return state;
-}
-function assertCurrentMigrationLedger(db, migrations) {
-  const state = assertMigrationLedger(db, migrations);
-  if (state.status !== "current") {
-    throw new Error(`Refusing to open an obsolete writable schema; run \`akm migrate apply\`: ${state.detail ?? "pending migrations"}.`);
-  }
-  return state;
-}
-function ensureMigrationsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      id         TEXT    PRIMARY KEY,
-      applied_at TEXT    NOT NULL DEFAULT (datetime('now')),
-      checksum   TEXT
-    );
-  `);
-  if (!ledgerHasChecksum(db))
-    db.exec("ALTER TABLE schema_migrations ADD COLUMN checksum TEXT");
-}
-function runMigrations(db, migrations, opts) {
-  if (opts?.applyPending === false) {
-    assertMigrationLedger(db, migrations);
-    return;
-  }
-  if (migrationsTableExists(db))
-    assertMigrationLedger(db, migrations);
-  ensureMigrationsTable(db);
-  opts?.bootstrap?.(db);
-  const ledger = assertMigrationLedger(db, migrations);
-  db.transaction(() => {
-    const update = db.prepare("UPDATE schema_migrations SET checksum = ? WHERE id = ? AND checksum IS NULL");
-    for (let index = 0;index < ledger.migrationIds.length; index += 1) {
-      update.run(migrationChecksum(migrations[index]), ledger.migrationIds[index]);
-    }
-    if (opts?.generationMarker) {
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS akm_migration_generation (
-          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-          operation_id TEXT NOT NULL,
-          phase TEXT NOT NULL
-        )
-      `);
-      db.prepare("INSERT INTO akm_migration_generation(singleton, operation_id, phase) VALUES (1, ?, ?) ON CONFLICT(singleton) DO UPDATE SET operation_id=excluded.operation_id, phase=excluded.phase").run(opts.generationMarker.operationId, opts.generationMarker.phase);
-    }
-  })();
-  const appliedRows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
-  const applied = new Set(appliedRows.map((r) => r.id));
-  for (const migration of migrations) {
-    if (applied.has(migration.id))
-      continue;
-    opts?.beforeMigration?.(migration);
-    db.transaction(() => {
-      db.exec(migration.up);
-      db.prepare("INSERT INTO schema_migrations (id, checksum) VALUES (?, ?)").run(migration.id, migrationChecksum(migration));
-    })();
-  }
-}
-var init_sqlite_migrations = () => {};
-
-// src/core/paths.ts
-import path2 from "node:path";
-function isUnderBunTest(env) {
-  return env.BUN_TEST === "1" || env.NODE_ENV === "test";
-}
-function isTransientStashPath2(p) {
-  return p.startsWith("/tmp/") || p === "/tmp" || p.startsWith("/var/tmp/") || p === "/var/tmp" || p.startsWith("/private/tmp/") || p.startsWith("/private/var/folders/") || p.startsWith("/var/folders/");
-}
-function testIsolationError() {
-  return new ConfigError("Refusing to resolve data directory under bun test: neither XDG_DATA_HOME nor AKM_DATA_DIR is set. " + "This guards against tests writing into the developer's real ~/.local/share/akm. " + "Set XDG_DATA_HOME (or AKM_DATA_DIR) to a mktemp-d directory in this test's env block.", "TEST_ISOLATION_MISSING");
-}
-function getConfigDir2(env = process.env, platform = process.platform) {
-  const override = env.AKM_CONFIG_DIR?.trim();
-  if (override)
-    return override;
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path2.join(appData, "akm");
-  } else {
-    const xdgConfigHome2 = env.XDG_CONFIG_HOME?.trim();
-    if (xdgConfigHome2)
-      return path2.join(xdgConfigHome2, "akm");
-  }
-  const stashOverride = env.AKM_STASH_DIR?.trim();
-  if (stashOverride && isTransientStashPath2(stashOverride)) {
-    return path2.join(stashOverride, ".akm");
-  }
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path2.join(appData, "akm");
-    const userProfile = env.USERPROFILE?.trim();
-    if (!userProfile) {
-      throw new ConfigError("Unable to determine config directory. Set APPDATA or USERPROFILE.", "CONFIG_DIR_UNRESOLVABLE");
-    }
-    return path2.join(userProfile, "AppData", "Roaming", "akm");
-  }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
-  if (xdgConfigHome)
-    return path2.join(xdgConfigHome, "akm");
-  const home = env.HOME?.trim();
-  if (!home) {
-    throw new ConfigError("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.", "CONFIG_DIR_UNRESOLVABLE");
-  }
-  return path2.join(home, ".config", "akm");
-}
-function getConfigPath(env = process.env) {
-  return path2.join(getConfigDir2(env), "config.json");
-}
-function getDataDir(env = process.env, platform = process.platform) {
-  const override = env.AKM_DATA_DIR?.trim();
-  if (override)
-    return override;
-  if (isUnderBunTest(env) && !env.XDG_DATA_HOME?.trim()) {
-    throw testIsolationError();
-  }
-  if (platform === "win32") {
-    const localAppData = env.LOCALAPPDATA?.trim();
-    if (localAppData)
-      return path2.join(localAppData, "akm", "data");
-    const userProfile = env.USERPROFILE?.trim();
-    if (userProfile)
-      return path2.join(userProfile, "AppData", "Local", "akm", "data");
-    const appData = env.APPDATA?.trim();
-    if (!appData) {
-      throw new ConfigError("Unable to determine data directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
-    }
-    return path2.join(appData, "..", "Local", "akm", "data");
-  }
-  const xdgDataHome = env.XDG_DATA_HOME?.trim();
-  if (xdgDataHome)
-    return path2.join(xdgDataHome, "akm");
-  const home = env.HOME?.trim();
-  if (!home)
-    return path2.join("/tmp", "akm-data");
-  return path2.join(home, ".local", "share", "akm");
-}
-function getDbPath(env = process.env) {
-  return path2.join(getDataDir(env), "index.db");
-}
-function getMaintenanceBarrierPath() {
-  return path2.join(getDataDir(), "maintenance.barrier.lock");
-}
-var init_paths = __esm(() => {
-  init_errors();
-  init_platform();
-});
-
-// src/core/common.ts
-import fs2 from "node:fs";
-function readTextFileDescriptorWithLimit(fd, maxBytes, label = "File", displayPath = "(open file)") {
-  const stat = fs2.fstatSync(fd);
-  if (!stat.isFile())
-    throw new ConfigError(`${label} is not a regular file: ${displayPath}.`, "INVALID_CONFIG_FILE");
-  if (stat.size > maxBytes) {
-    throw new ConfigError(`${label} exceeds the ${maxBytes}-byte limit: ${displayPath}.`, "INVALID_CONFIG_FILE");
-  }
-  const buffer = Buffer.allocUnsafe(maxBytes + 1);
-  let total = 0;
-  while (total <= maxBytes) {
-    const bytesRead = fs2.readSync(fd, buffer, total, maxBytes + 1 - total, null);
-    if (bytesRead === 0)
-      break;
-    total += bytesRead;
-  }
-  if (total > maxBytes) {
-    throw new ConfigError(`${label} exceeds the ${maxBytes}-byte limit: ${displayPath}.`, "INVALID_CONFIG_FILE");
-  }
-  return buffer.subarray(0, total).toString("utf8");
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var MAX_CONFIG_FILE_BYTES, MAX_LOCAL_METADATA_BYTES, MAX_LOCK_METADATA_BYTES, DEFAULT_RESPONSE_BYTE_CAP;
-var init_common = __esm(() => {
-  init_errors();
-  init_paths();
-  init_platform();
-  MAX_CONFIG_FILE_BYTES = 1024 * 1024;
-  MAX_LOCAL_METADATA_BYTES = 1024 * 1024;
-  MAX_LOCK_METADATA_BYTES = 64 * 1024;
-  DEFAULT_RESPONSE_BYTE_CAP = 10 * 1024 * 1024;
-});
-
-// src/runtime.ts
-import { createWriteStream, statfsSync } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-function statfsType(path3) {
-  try {
-    return statfsSync(path3).type;
-  } catch {
-    return;
-  }
-}
-function bunGlobal() {
-  return globalThis.Bun;
-}
-var isBun2, nodeRequire2, MAX_STREAMED_DOWNLOAD_BYTES, STREAMED_DOWNLOAD_BODY_TIMEOUT_MS, mainPath;
-var init_runtime = __esm(() => {
-  init_common();
-  isBun2 = !!process.versions?.bun;
-  nodeRequire2 = createRequire3(import.meta.url);
-  MAX_STREAMED_DOWNLOAD_BYTES = 1024 * 1024 * 1024;
-  STREAMED_DOWNLOAD_BODY_TIMEOUT_MS = 5 * 60000;
-  mainPath = isBun2 ? bunGlobal().main : process.argv[1];
-});
-
-// src/storage/sqlite-pragmas.ts
-function resolveJournalMode(raw) {
-  if (raw === undefined)
-    return "WAL";
-  const normalized = raw.trim().toUpperCase();
-  if (normalized === "")
-    return "WAL";
-  if (VALID_MODES.has(normalized)) {
-    return normalized;
-  }
-  warnInvalidJournalModeOnce(raw);
-  return "WAL";
-}
-function resolveConfiguredJournalMode(env = process.env) {
-  return resolveJournalMode(env.AKM_SQLITE_JOURNAL_MODE);
-}
-function warnInvalidJournalModeOnce(raw) {
-  if (warnedInvalid)
-    return;
-  warnedInvalid = true;
-  warn(`[akm] invalid AKM_SQLITE_JOURNAL_MODE=${JSON.stringify(raw)} — using WAL (valid: WAL, DELETE, TRUNCATE)`);
-}
-function isNetworkFilesystem(fsType) {
-  if (fsType === undefined)
-    return false;
-  return NETWORK_FS_MAGICS.has(fsType);
-}
-function applyStandardPragmas(db, opts = {}) {
-  let mode = resolveConfiguredJournalMode(opts.env);
-  if (mode === "WAL" && opts.dataDir) {
-    const probe = opts.fsTypeProbe ?? statfsType;
-    if (isNetworkFilesystem(probe(opts.dataDir))) {
-      mode = "DELETE";
-      warnNetworkFallbackOnce(opts.dataDir);
-    }
-  }
-  db.exec("PRAGMA busy_timeout = 30000");
-  db.exec(`PRAGMA journal_mode = ${mode}`);
-  if (opts.foreignKeys !== false) {
-    db.exec("PRAGMA foreign_keys = ON");
-  }
-  if (mode !== "WAL") {
-    db.exec("PRAGMA synchronous = FULL");
-  }
-  return mode;
-}
-function warnNetworkFallbackOnce(dataDir) {
-  if (warnedNetworkFallback)
-    return;
-  warnedNetworkFallback = true;
-  warn(`[akm] network filesystem detected at ${dataDir} — WAL unsupported, using DELETE journal mode`);
-}
-var VALID_MODES, warnedInvalid = false, warnedNetworkFallback = false, FS_MAGIC_NFS = 26985, FS_MAGIC_SMB = 20859, FS_MAGIC_CIFS = 4283649346, FS_MAGIC_SMB2 = 4266872130, FS_MAGIC_FUSE = 1702057286, NETWORK_FS_MAGICS;
-var init_sqlite_pragmas = __esm(() => {
-  init_warn();
-  init_runtime();
-  VALID_MODES = new Set(["WAL", "DELETE", "TRUNCATE"]);
-  NETWORK_FS_MAGICS = new Set([
-    FS_MAGIC_NFS,
-    FS_MAGIC_SMB,
-    FS_MAGIC_CIFS,
-    FS_MAGIC_SMB2,
-    FS_MAGIC_FUSE
-  ]);
-});
-
-// src/storage/managed-db.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-function openManagedDatabase(spec) {
-  const dir = path3.dirname(spec.path);
-  if (!fs3.existsSync(dir)) {
-    fs3.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/file-lock.ts
-import { randomUUID } from "node:crypto";
-import fs4 from "node:fs";
-import path4 from "node:path";
-function readLockSnapshot(lockPath) {
-  let fd;
-  try {
-    fd = fs4.openSync(lockPath, "r");
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return;
-    throw err;
-  }
-  try {
-    const rawContent = readTextFileDescriptorWithLimit(fd, MAX_LOCK_METADATA_BYTES, "Lock metadata", lockPath);
-    const stat = fs4.fstatSync(fd);
-    return {
-      rawContent,
-      identity: { dev: stat.dev, ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs }
-    };
-  } finally {
-    fs4.closeSync(fd);
-  }
-}
-function sameIdentity(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs;
-}
-function operationMutexPath(lockPath) {
-  return path4.join(path4.dirname(lockPath), `.${path4.basename(lockPath)}.operations.sensitive`);
-}
-function withLockOperationMutex(lockPath, run) {
-  const db = openDatabase(operationMutexPath(lockPath));
-  let began = false;
-  try {
-    db.exec("PRAGMA busy_timeout = 30000");
-    for (let attempt = 0;attempt < 5 && !began; attempt += 1) {
-      db.exec("BEGIN IMMEDIATE");
-      began = db.inTransaction;
-      if (!began)
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2 ** attempt);
-    }
-    if (!began)
-      throw new Error(`Could not acquire lock operation mutex for ${lockPath}.`);
-    const result = run();
-    db.exec("COMMIT");
-    began = false;
-    return result;
-  } catch (error2) {
-    if (began && db.inTransaction) {
-      try {
-        db.exec("ROLLBACK");
-      } catch {}
-    }
-    throw error2;
-  } finally {
-    db.close();
-  }
-}
-function tryAcquireLockRaw(lockPath, payload) {
-  try {
-    fs4.writeFileSync(lockPath, payload, { flag: "wx" });
-  } catch (err) {
-    if (err.code === "EEXIST")
-      return;
-    throw err;
-  }
-  let snapshot;
-  try {
-    snapshot = readLockSnapshot(lockPath);
-  } catch (error2) {
-    releaseLockRaw(lockPath);
-    throw error2;
-  }
-  if (!snapshot) {
-    releaseLockRaw(lockPath);
-    throw new Error(`Could not read newly acquired lock at ${lockPath}.`);
-  }
-  return { lockPath, ...snapshot };
-}
-function releaseLockRaw(lockPath) {
-  try {
-    fs4.unlinkSync(lockPath);
-  } catch {}
-}
-function tryAcquireLockSync(lockPath, payload) {
-  return withLockOperationMutex(lockPath, () => tryAcquireLockRaw(lockPath, payload));
-}
-function createLockPayload(metadata = {}) {
-  return JSON.stringify({ ...metadata, pid: process.pid, lockId: randomUUID() });
-}
-function probeLock(lockPath, opts) {
-  let snapshot;
-  try {
-    snapshot = readLockSnapshot(lockPath);
-  } catch {
-    return { state: "stale", reason: "unreadable" };
-  }
-  if (!snapshot)
-    return { state: "absent" };
-  const { rawContent, identity } = snapshot;
-  const ageMs = Date.now() - identity.mtimeMs;
-  const holderPid = extractHolderPid(rawContent);
-  if (holderPid === undefined) {
-    return { state: "stale", reason: "invalid_pid", ageMs, rawContent, identity };
-  }
-  if (!isProcessAlive(holderPid)) {
-    return { state: "stale", reason: "pid_dead", holderPid, ageMs, rawContent, identity };
-  }
-  if (opts?.staleAfterMs !== undefined && ageMs > opts.staleAfterMs) {
-    return { state: "stale", reason: "age_exceeded", holderPid, ageMs, rawContent, identity };
-  }
-  return { state: "held", holderPid, ageMs, rawContent, identity };
-}
-function reclaimStaleLock(lockPath, probe, options) {
-  if (probe.rawContent === undefined || probe.identity === undefined)
-    return false;
-  const expectedContent = probe.rawContent;
-  const expectedIdentity = probe.identity;
-  return withLockOperationMutex(lockPath, () => {
-    let current;
-    try {
-      current = readLockSnapshot(lockPath);
-    } catch {
-      return false;
-    }
-    if (!current || current.rawContent !== expectedContent || !sameIdentity(current.identity, expectedIdentity)) {
-      return false;
-    }
-    const quarantinePath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
-    try {
-      fs4.renameSync(lockPath, quarantinePath);
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return false;
-      throw err;
-    }
-    let quarantined;
-    try {
-      quarantined = readLockSnapshot(quarantinePath);
-    } catch {
-      quarantined = undefined;
-    }
-    if (!quarantined || quarantined.rawContent !== expectedContent || !sameIdentity(quarantined.identity, expectedIdentity)) {
-      try {
-        fs4.linkSync(quarantinePath, lockPath);
-      } catch (err) {
-        if (err.code !== "EEXIST")
-          throw err;
-      }
-      releaseLockRaw(quarantinePath);
-      return false;
-    }
-    options?.afterQuarantineVerified?.();
-    try {
-      fs4.unlinkSync(quarantinePath);
-      return true;
-    } catch (err) {
-      if (err.code === "ENOENT")
-        return false;
-      throw err;
-    }
-  });
-}
-function releaseLock(ownership) {
-  const { lockPath } = ownership;
-  if (!fs4.existsSync(lockPath) && !fs4.existsSync(operationMutexPath(lockPath)))
-    return;
-  withLockOperationMutex(lockPath, () => {
-    let current;
-    try {
-      current = readLockSnapshot(lockPath);
-    } catch {
-      return;
-    }
-    if (current && current.rawContent === ownership.rawContent && sameIdentity(current.identity, ownership.identity)) {
-      releaseLockRaw(lockPath);
-    }
-  });
-}
-function extractHolderPid(content) {
-  const trimmed = content.trim();
-  if (!trimmed)
-    return;
-  if (trimmed.startsWith("{")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      const pid2 = typeof parsed.pid === "number" ? parsed.pid : Number.NaN;
-      return Number.isInteger(pid2) && pid2 > 0 ? pid2 : undefined;
-    } catch {
-      return;
-    }
-  }
-  const pid = Number.parseInt(trimmed, 10);
-  return Number.isInteger(pid) && pid > 0 ? pid : undefined;
-}
-var init_file_lock = __esm(() => {
-  init_database();
-  init_common();
-});
-
-// src/core/maintenance-barrier.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import fs5 from "node:fs";
-import path5 from "node:path";
-function tryAcquireMaintenanceBarrier() {
-  const lockPath = getMaintenanceBarrierPath();
-  fs5.mkdirSync(path5.dirname(lockPath), { recursive: true });
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: "maintenance-start" }));
-    if (ownership) {
-      return () => releaseLock(ownership);
-    }
-    const probe = probeLock(lockPath);
-    if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
-      return;
-  }
-  return;
-}
-function acquireMaintenanceBarrier() {
-  const release = tryAcquireMaintenanceBarrier();
-  if (release)
-    return release;
-  throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes.`, "INVALID_CONFIG_FILE");
-}
-function withMaintenanceStartBarrierSyncWait(run) {
-  if (heldBarrierContext.getStore()?.active)
-    return run();
-  const deadline = Date.now() + 5000;
-  let release = tryAcquireMaintenanceBarrier();
-  while (!release && Date.now() < deadline) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
-    release = tryAcquireMaintenanceBarrier();
-  }
-  if (!release)
-    release = acquireMaintenanceBarrier();
-  const ownership = { active: true };
-  try {
-    return heldBarrierContext.run(ownership, run);
-  } finally {
-    ownership.active = false;
-    release();
-  }
-}
-function acquireMaintenanceActivitySync(name) {
-  return withMaintenanceStartBarrierSyncWait(() => {
-    const directory = path5.join(path5.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
-    fs5.mkdirSync(directory, { recursive: true, mode: 448 });
-    const lockPath = path5.join(directory, `${name}-${process.pid}-${randomUUID2()}.lock`);
-    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
-    if (!ownership) {
-      throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
-    }
-    return () => releaseLock(ownership);
-  });
-}
-var heldBarrierContext;
-var init_maintenance_barrier = __esm(() => {
-  init_errors();
-  init_file_lock();
-  init_paths();
-  heldBarrierContext = new AsyncLocalStorage;
-});
-
-// src/core/migration-operation.ts
-import crypto2 from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
-function installationId() {
-  return crypto2.createHash("sha256").update(path6.resolve(path6.dirname(getConfigPath()))).update("\x00").update(path6.resolve(getDataDir())).digest("hex").slice(0, 24);
-}
-function getMigrationOperationRoot() {
-  return path6.join(getDataDir(), "backups", "migrations", installationId());
-}
-function getMigrationRestoreJournalPath() {
-  return path6.join(getMigrationOperationRoot(), "restore-active.json");
-}
-function getMigrationApplyJournalPath() {
-  return path6.join(getMigrationOperationRoot(), "apply-active.json");
-}
-function assertNoPendingMigrationOperation() {
-  for (const [kind, journalPath] of [
-    ["restore", getMigrationRestoreJournalPath()],
-    ["migration apply", getMigrationApplyJournalPath()]
-  ]) {
-    if (fs6.existsSync(journalPath)) {
-      throw new ConfigError(`AKM ${kind} recovery is pending at ${journalPath}; refusing canonical config/database access until recovery completes.`, "INVALID_CONFIG_FILE");
-    }
-  }
-  const hook = afterPendingCheckHook;
-  afterPendingCheckHook = undefined;
-  hook?.();
-}
-var afterPendingCheckHook;
-var init_migration_operation = __esm(() => {
-  init_errors();
-  init_paths();
-});
-
-// src/core/state/migrations.ts
-function runMigrations2(db, options) {
-  runMigrations(db, STATE_MIGRATIONS, {
-    applyPending: options?.applyPending,
-    generationMarker: options?.generationMarker
-  });
-}
-var STATE_MIGRATIONS;
-var init_migrations = __esm(() => {
-  init_sqlite_migrations();
-  STATE_MIGRATIONS = [
-    {
-      id: "001-initial-schema",
-      up: `
-      -- ── events ──────────────────────────────────────────────────────────────
-      --
-      -- Replaces events.jsonl. Indexed (query) columns:
-      --   id          INTEGER PK — monotonic rowid; replaces byte-offset cursor.
-      --                            Callers store this as "sinceId" for resume.
-      --   event_type  TEXT        — indexed; replaces the type filter in readEvents().
-      --   ts          TEXT        — ISO-8601 UTC ms; indexed for range queries.
-      --   ref         TEXT        — nullable asset ref; indexed for ref-scoped queries.
-      --
-      -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      — JSON object storing all non-indexed payload
-      --                             fields (tags, any future structured fields).
-      --                             Maps directly to EventEnvelope.metadata.
-      --
-      -- schema_version mirrors EventEnvelope.schemaVersion — always 1 for v1
-      -- rows. Stored as a column (not in the JSON blob) so future schema
-      -- changes can be detected and migrated row-by-row if ever needed.
-      --
-      -- TTL: rows where ts < NOW() - 90 days can be deleted by a maintenance job.
-      -- No automatic deletion occurs here — callers call purgeOldEvents().
-      --
-      -- ADD COLUMN extension points (future migrations):
-      --   ALTER TABLE events ADD COLUMN stash_dir TEXT DEFAULT NULL;
-      --   ALTER TABLE events ADD COLUMN correlation_id TEXT DEFAULT NULL;
-      --   ALTER TABLE events ADD COLUMN schema_version INTEGER NOT NULL DEFAULT 1;
-      --
-      CREATE TABLE IF NOT EXISTS events (
-        id             INTEGER PRIMARY KEY AUTOINCREMENT,
-        event_type     TEXT    NOT NULL,
-        ts             TEXT    NOT NULL,
-        ref            TEXT,
-        metadata_json  TEXT    NOT NULL DEFAULT '{}'
-      );
-
-      -- Query patterns supported by these indexes:
-      --   SELECT … WHERE event_type = ?                 → idx_events_type
-      --   SELECT … WHERE ref = ?                        → idx_events_ref
-      --   SELECT … WHERE ts >= ? AND ts <= ?            → idx_events_ts
-      --   SELECT … WHERE event_type = ? AND ref = ?     → idx_events_type (prefix scan) + filter
-      --   SELECT … WHERE id > ?                         → PK (rowid) — no extra index needed
-      CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
-      CREATE INDEX IF NOT EXISTS idx_events_ref  ON events(ref);
-      CREATE INDEX IF NOT EXISTS idx_events_ts   ON events(ts);
-
-      -- ── proposals ────────────────────────────────────────────────────────────
-      --
-      -- Replaces per-uuid JSON directories under <stashDir>/.akm/proposals/.
-      --
-      -- Indexed (query) columns:
-      --   id          TEXT PK     — UUID (crypto.randomUUID()); stable directory name.
-      --   stash_dir   TEXT        — absolute stash root; multi-stash installs need
-      --                             this to partition proposal lists per stash.
-      --   ref         TEXT        — target asset ref (e.g. "lesson:alpha");
-      --                             indexed for ref-scoped queue views.
-      --   status      TEXT        — "pending" | "accepted" | "rejected"; indexed
-      --                             so pending-queue queries are fast.
-      --   source      TEXT        — human-readable origin tag (e.g. "reflect").
-      --   created_at  TEXT        — ISO-8601; used for ORDER BY created_at ASC.
-      --   updated_at  TEXT        — ISO-8601; updated on accept/reject.
-      --
-      -- Large payload columns (NOT indexed):
-      --   content     TEXT        — full markdown text; the proposal payload body.
-      --   frontmatter_json TEXT   — JSON of parsed frontmatter (may be NULL when
-      --                             the content has no frontmatter block).
-      --
-      -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      — JSON object for future proposal fields.
-      --                             Current fields stored here: sourceRun,
-      --                             review, confidence, gateDecision (#577),
-      --                             backupContent, eligibilitySource.
-      --
-      -- ADD COLUMN extension points (future migrations):
-      --   ALTER TABLE proposals ADD COLUMN source_run TEXT DEFAULT NULL;
-      --   ALTER TABLE proposals ADD COLUMN review_outcome TEXT DEFAULT NULL;
-      --   ALTER TABLE proposals ADD COLUMN review_reason TEXT DEFAULT NULL;
-      --   ALTER TABLE proposals ADD COLUMN review_decided_at TEXT DEFAULT NULL;
-      --   ALTER TABLE proposals ADD COLUMN archived INTEGER NOT NULL DEFAULT 0;
-      --
-      CREATE TABLE IF NOT EXISTS proposals (
-        id               TEXT    PRIMARY KEY,
-        stash_dir        TEXT    NOT NULL,
-        ref              TEXT    NOT NULL,
-        status           TEXT    NOT NULL DEFAULT 'pending',
-        source           TEXT    NOT NULL,
-        created_at       TEXT    NOT NULL,
-        updated_at       TEXT    NOT NULL,
-        content          TEXT    NOT NULL DEFAULT '',
-        frontmatter_json TEXT,
-        metadata_json    TEXT    NOT NULL DEFAULT '{}'
-      );
-
-      -- Query patterns:
-      --   SELECT … WHERE stash_dir = ? AND status = ?   → idx_proposals_stash_status
-      --   SELECT … WHERE ref = ? AND status = ?         → idx_proposals_ref_status
-      --   SELECT … WHERE id = ?                         → PK
-      CREATE INDEX IF NOT EXISTS idx_proposals_stash_status
-        ON proposals(stash_dir, status);
-      CREATE INDEX IF NOT EXISTS idx_proposals_ref_status
-        ON proposals(ref, status);
-
-      -- ── task_history ─────────────────────────────────────────────────────────
-      --
-      -- Replaces per-task JSONL files under <cacheDir>/tasks/history/.
-      --
-      -- Indexed (query) columns:
-      --   task_id     TEXT PK     — stable task identifier string.
-      --   status      TEXT        — terminal status (e.g. "completed", "failed",
-      --                             "cancelled"); indexed for status-scoped queries.
-      --   started_at  TEXT        — ISO-8601; indexed for time-range queries.
-      --   target_kind TEXT        — kind of the target entity (e.g. "issue",
-      --                             "workflow", "agent"); indexed for kind-scoped queries.
-      --   target_ref  TEXT        — stable ref of the target entity; indexed for
-      --                             per-target history lookups.
-      --
-      -- Non-indexed time columns:
-      --   completed_at TEXT       — ISO-8601 or NULL if still running.
-      --   failed_at    TEXT       — ISO-8601 or NULL.
-      --
-      -- Non-indexed diagnostic columns:
-      --   log_path     TEXT       — absolute path to the task log file, if any.
-      --
-      -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      — JSON object for future task fields (exit_code,
-      --                             runner, priority, parent_task_id, …).
-      --
-      -- ADD COLUMN extension points (future migrations):
-      --   ALTER TABLE task_history ADD COLUMN exit_code INTEGER DEFAULT NULL;
-      --   ALTER TABLE task_history ADD COLUMN runner TEXT DEFAULT NULL;
-      --   ALTER TABLE task_history ADD COLUMN parent_task_id TEXT DEFAULT NULL;
-      --   ALTER TABLE task_history ADD COLUMN priority INTEGER NOT NULL DEFAULT 0;
-      --
-      CREATE TABLE IF NOT EXISTS task_history (
-        task_id       TEXT    PRIMARY KEY,
-        status        TEXT    NOT NULL,
-        started_at    TEXT    NOT NULL,
-        completed_at  TEXT,
-        failed_at     TEXT,
-        log_path      TEXT,
-        target_kind   TEXT,
-        target_ref    TEXT,
-        metadata_json TEXT    NOT NULL DEFAULT '{}'
-      );
-
-      -- Query patterns:
-      --   SELECT … WHERE task_id = ?                    → PK
-      --   SELECT … WHERE started_at >= ? AND started_at <= ? → idx_task_history_started
-      --   SELECT … WHERE target_kind = ? AND target_ref = ?  → idx_task_history_target
-      --   SELECT … WHERE status = ?                     → idx_task_history_status
-      CREATE INDEX IF NOT EXISTS idx_task_history_started
-        ON task_history(started_at);
-      CREATE INDEX IF NOT EXISTS idx_task_history_target
-        ON task_history(target_kind, target_ref);
-      CREATE INDEX IF NOT EXISTS idx_task_history_status
-        ON task_history(status);
-    `
-    },
-    {
-      id: "002-task-history-per-run",
-      up: `
-      ALTER TABLE task_history RENAME TO task_history_v1;
-
-      CREATE TABLE task_history (
-        id            INTEGER PRIMARY KEY AUTOINCREMENT,
-        task_id       TEXT    NOT NULL,
-        status        TEXT    NOT NULL,
-        started_at    TEXT    NOT NULL,
-        completed_at  TEXT,
-        failed_at     TEXT,
-        log_path      TEXT,
-        target_kind   TEXT,
-        target_ref    TEXT,
-        metadata_json TEXT    NOT NULL DEFAULT '{}'
-      );
-
-      INSERT INTO task_history
-        (task_id, status, started_at, completed_at, failed_at,
-         log_path, target_kind, target_ref, metadata_json)
-      SELECT task_id, status, started_at, completed_at, failed_at,
-             log_path, target_kind, target_ref, metadata_json
-      FROM task_history_v1;
-
-      DROP TABLE task_history_v1;
-
-      -- Unique constraint: same task cannot have two runs with the same start time.
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_task_history_run
-        ON task_history(task_id, started_at);
-      CREATE INDEX IF NOT EXISTS idx_task_history_task_id
-        ON task_history(task_id);
-      CREATE INDEX IF NOT EXISTS idx_task_history_started
-        ON task_history(started_at);
-      CREATE INDEX IF NOT EXISTS idx_task_history_target
-        ON task_history(target_kind, target_ref);
-      CREATE INDEX IF NOT EXISTS idx_task_history_status
-        ON task_history(status);
-    `
-    },
-    {
-      id: "003-improve-runs",
-      up: `
-      CREATE TABLE IF NOT EXISTS improve_runs (
-        id            TEXT    PRIMARY KEY,
-        started_at    TEXT    NOT NULL,
-        completed_at  TEXT,
-        stash_dir     TEXT    NOT NULL,
-        dry_run       INTEGER NOT NULL DEFAULT 0,
-        profile       TEXT,
-        scope_mode    TEXT    NOT NULL,
-        scope_value   TEXT,
-        guidance      TEXT,
-        ok            INTEGER NOT NULL,
-        result_json   TEXT    NOT NULL,
-        metrics_json  TEXT,
-        metadata_json TEXT    NOT NULL DEFAULT '{}'
-      );
-
-      -- Query patterns supported:
-      --   SELECT … WHERE started_at >= ? AND started_at <= ?
-      --     → idx_improve_runs_started
-      --   SELECT … WHERE dry_run = 0
-      --     → idx_improve_runs_dry_run (productivity audits filter trap)
-      --   SELECT … WHERE stash_dir = ? AND scope_mode = ?
-      --     → idx_improve_runs_stash_scope
-      CREATE INDEX IF NOT EXISTS idx_improve_runs_started
-        ON improve_runs(started_at);
-      CREATE INDEX IF NOT EXISTS idx_improve_runs_dry_run
-        ON improve_runs(dry_run);
-      CREATE INDEX IF NOT EXISTS idx_improve_runs_stash_scope
-        ON improve_runs(stash_dir, scope_mode);
-    `
-    },
-    {
-      id: "004-extract-sessions-seen",
-      up: `
-      CREATE TABLE IF NOT EXISTS extract_sessions_seen (
-        harness          TEXT    NOT NULL,
-        session_id       TEXT    NOT NULL,
-        processed_at     TEXT    NOT NULL,
-        session_ended_at TEXT,
-        outcome          TEXT    NOT NULL,
-        candidate_count  INTEGER NOT NULL DEFAULT 0,
-        proposal_count   INTEGER NOT NULL DEFAULT 0,
-        rationale        TEXT,
-        source_run       TEXT,
-        metadata_json    TEXT    NOT NULL DEFAULT '{}',
-        PRIMARY KEY (harness, session_id)
-      );
-
-      -- Query patterns:
-      --   SELECT … WHERE harness = ?                       → idx_extract_sessions_harness
-      --   SELECT … WHERE processed_at >= ?                 → idx_extract_sessions_processed
-      --   SELECT … WHERE harness = ? AND session_id = ?    → PK
-      CREATE INDEX IF NOT EXISTS idx_extract_sessions_harness
-        ON extract_sessions_seen(harness);
-      CREATE INDEX IF NOT EXISTS idx_extract_sessions_processed
-        ON extract_sessions_seen(processed_at);
-    `
-    },
-    {
-      id: "005-proposal-fs-imports",
-      up: `
-      CREATE TABLE IF NOT EXISTS proposal_fs_imports (
-        stash_dir      TEXT    PRIMARY KEY,
-        imported_at    TEXT    NOT NULL,
-        imported_count INTEGER NOT NULL DEFAULT 0
-      );
-    `
-    },
-    {
-      id: "006-proposals-pending-ref-source",
-      up: `
-      CREATE INDEX IF NOT EXISTS idx_proposals_stash_status_ref_source
-        ON proposals(stash_dir, status, ref, source);
-    `
-    },
-    {
-      id: "007-consolidation-judged",
-      up: `
-      CREATE TABLE IF NOT EXISTS consolidation_judged (
-        entry_key    TEXT    PRIMARY KEY,
-        content_hash TEXT    NOT NULL,
-        judged_at    TEXT    NOT NULL,
-        outcome      TEXT    NOT NULL
-      );
-    `
-    },
-    {
-      id: "008-body-embeddings",
-      up: `
-      CREATE TABLE IF NOT EXISTS body_embeddings (
-        content_hash TEXT    PRIMARY KEY,
-        embedding    BLOB    NOT NULL,
-        model_id     TEXT    NOT NULL,
-        created_at   INTEGER NOT NULL
-      );
-    `
-    },
-    {
-      id: "009-asset-salience",
-      up: `
-      CREATE TABLE IF NOT EXISTS asset_salience (
-        asset_ref          TEXT    PRIMARY KEY,
-        encoding_salience  REAL    NOT NULL DEFAULT 0.5,
-        outcome_salience   REAL    NOT NULL DEFAULT 0.0,
-        retrieval_salience REAL    NOT NULL DEFAULT 0.0,
-        rank_score         REAL    NOT NULL DEFAULT 0.0,
-        consecutive_no_ops INTEGER NOT NULL DEFAULT 0,
-        updated_at         INTEGER NOT NULL DEFAULT 0
-      );
-
-      -- Hot path: sort / filter by rank_score for selector queries.
-      CREATE INDEX IF NOT EXISTS idx_asset_salience_rank
-        ON asset_salience(rank_score DESC);
-    `
-    },
-    {
-      id: "010-asset-outcome",
-      up: `
-      CREATE TABLE IF NOT EXISTS asset_outcome (
-        asset_ref                TEXT    PRIMARY KEY,
-        last_retrieved_at        INTEGER NOT NULL DEFAULT 0,
-        retrieval_count          INTEGER NOT NULL DEFAULT 0,
-        expected_retrieval_rate  REAL    NOT NULL DEFAULT 0.0,
-        negative_feedback_count  INTEGER NOT NULL DEFAULT 0,
-        accepted_change_count    INTEGER NOT NULL DEFAULT 0,
-        review_pressure          INTEGER NOT NULL DEFAULT 0,
-        outcome_score            REAL    NOT NULL DEFAULT 0.0,
-        updated_at               INTEGER NOT NULL DEFAULT 0
-      );
-
-      -- Hot path: sort assets by review_pressure DESC for #613 admission.
-      CREATE INDEX IF NOT EXISTS idx_asset_outcome_review_pressure
-        ON asset_outcome(review_pressure DESC);
-
-      -- Secondary: sort by outcome_score DESC for outcomeSalience reads.
-      CREATE INDEX IF NOT EXISTS idx_asset_outcome_score
-        ON asset_outcome(outcome_score DESC);
-    `
-    },
-    {
-      id: "011-asset-salience-homeostatic-demoted-at",
-      up: `
-      ALTER TABLE asset_salience ADD COLUMN homeostatic_demoted_at INTEGER DEFAULT NULL;
-    `
-    },
-    {
-      id: "012-improve-gate-thresholds",
-      up: `
-      CREATE TABLE IF NOT EXISTS improve_gate_thresholds (
-        phase       TEXT    NOT NULL PRIMARY KEY,
-        threshold   INTEGER NOT NULL,
-        updated_at  INTEGER NOT NULL
-      );
-    `
-    },
-    {
-      id: "013-extract-sessions-content-hash",
-      up: `
-      ALTER TABLE extract_sessions_seen ADD COLUMN content_hash TEXT DEFAULT NULL;
-    `
-    },
-    {
-      id: "014-recombine-hypotheses",
-      up: `
-      CREATE TABLE IF NOT EXISTS recombine_hypotheses (
-        hypothesis_ref    TEXT PRIMARY KEY,
-        signature         TEXT NOT NULL,
-        member_key        TEXT NOT NULL,
-        consecutive_count INTEGER NOT NULL DEFAULT 0,
-        first_seen_at     TEXT NOT NULL,
-        last_seen_at      TEXT NOT NULL,
-        last_run          TEXT,
-        promoted_at       TEXT,
-        metadata_json     TEXT NOT NULL DEFAULT '{}'
-      );
-      CREATE INDEX IF NOT EXISTS idx_recombine_hypotheses_last_seen
-        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: "016-collapse-churn-detector",
-      up: `
-      CREATE TABLE IF NOT EXISTS canary_queries (
-        id            INTEGER PRIMARY KEY AUTOINCREMENT,
-        canary_set_id TEXT    NOT NULL,
-        anchor_ref    TEXT    NOT NULL,
-        query         TEXT    NOT NULL,
-        source        TEXT    NOT NULL DEFAULT 'auto',
-        active        INTEGER NOT NULL DEFAULT 1,
-        created_at    TEXT    NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_canary_queries_active
-        ON canary_queries(active, canary_set_id);
-
-      CREATE TABLE IF NOT EXISTS improve_cycle_metrics (
-        id                      INTEGER PRIMARY KEY AUTOINCREMENT,
-        run_id                  TEXT    NOT NULL,
-        ts                      TEXT    NOT NULL,
-        pass                    TEXT    NOT NULL,
-        canary_set_id           TEXT    NOT NULL,
-        mean_recall             REAL    NOT NULL,
-        mean_ndcg               REAL    NOT NULL,
-        mean_mrr                REAL    NOT NULL,
-        canary_ranks_json       TEXT    NOT NULL,
-        store_total             INTEGER NOT NULL,
-        store_by_type_json      TEXT    NOT NULL,
-        distinct_content_ratio  REAL    NOT NULL,
-        mean_bigram_diversity   REAL    NOT NULL,
-        over_generation_count   INTEGER NOT NULL,
-        accepted_actions        INTEGER NOT NULL,
-        merge_floor_violations  INTEGER NOT NULL DEFAULT 0,
-        alerts_json             TEXT    NOT NULL DEFAULT '[]'
-      );
-      CREATE INDEX IF NOT EXISTS idx_improve_cycle_metrics_ts
-        ON improve_cycle_metrics(ts);
-    `
-    },
-    {
-      id: "017-improve-run-strategy",
-      up: `
-      ALTER TABLE improve_runs ADD COLUMN strategy TEXT;
-      CREATE INDEX IF NOT EXISTS idx_improve_runs_strategy_started ON improve_runs(strategy, started_at);
-    `
-    },
-    {
-      id: "018-drop-dead-lane-schema",
-      up: `
-      DROP INDEX IF EXISTS idx_recombine_hypotheses_last_seen;
-      DROP TABLE IF EXISTS recombine_hypotheses;
-
-      DROP TABLE IF EXISTS consolidation_judged;
-
-      DROP INDEX IF EXISTS idx_asset_outcome_review_pressure;
-      ALTER TABLE asset_outcome DROP COLUMN review_pressure;
-    `
-    },
-    {
-      id: "019-proposal-fingerprints",
-      up: `
-      CREATE TABLE IF NOT EXISTS proposal_fingerprints (
-        stash_dir TEXT NOT NULL,
-        fingerprint TEXT NOT NULL,
-        ref TEXT NOT NULL,
-        source TEXT NOT NULL,
-        model_id TEXT NOT NULL DEFAULT '',
-        proposal_id TEXT,
-        created_at TEXT NOT NULL,
-        PRIMARY KEY (stash_dir, fingerprint)
-      );
-      CREATE INDEX IF NOT EXISTS idx_proposal_fingerprints_ref
-        ON proposal_fingerprints(stash_dir, ref);
-    `
-    },
-    {
-      id: "020-three-db-cutover",
-      up: `
-      -- ── workflow_runs (workflows/db.ts base + migrations 001/002/003/006/010) ──
-      CREATE TABLE IF NOT EXISTS workflow_runs (
-        id                  TEXT PRIMARY KEY,
-        workflow_ref        TEXT NOT NULL,
-        workflow_entry_id   INTEGER,
-        workflow_title      TEXT NOT NULL,
-        status              TEXT NOT NULL CHECK (status IN ('active', 'completed', 'blocked', 'failed')),
-        params_json         TEXT NOT NULL DEFAULT '{}',
-        current_step_id     TEXT,
-        created_at          TEXT NOT NULL,
-        updated_at          TEXT NOT NULL,
-        completed_at        TEXT,
-        scope_key           TEXT,
-        agent_harness       TEXT,
-        agent_session_id    TEXT,
-        checkin_armed_at    TEXT,
-        plan_json           TEXT,
-        plan_hash           TEXT,
-        engine_lease_until  TEXT,
-        engine_lease_holder TEXT,
-        plan_ir_version     INTEGER
-      );
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_ref ON workflow_runs(workflow_ref);
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_scope_ref_status
-        ON workflow_runs(scope_key, workflow_ref, status);
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_agent_session
-        ON workflow_runs(agent_harness, agent_session_id);
-
-      -- ── workflow_run_steps (base + migration 003 summary) ─────────────────────
-      CREATE TABLE IF NOT EXISTS workflow_run_steps (
-        run_id          TEXT NOT NULL,
-        step_id         TEXT NOT NULL,
-        step_title      TEXT NOT NULL,
-        instructions    TEXT NOT NULL,
-        completion_json TEXT,
-        sequence_index  INTEGER NOT NULL,
-        status          TEXT NOT NULL CHECK (status IN ('pending', 'completed', 'blocked', 'failed', 'skipped')),
-        notes           TEXT,
-        evidence_json   TEXT,
-        completed_at    TEXT,
-        summary         TEXT,
-        PRIMARY KEY (run_id, step_id),
-        FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
-      );
-      CREATE INDEX IF NOT EXISTS idx_workflow_run_steps_run_sequence
-        ON workflow_run_steps(run_id, sequence_index);
-
-      -- ── workflow_run_units (migration 004 + 005/007/008/009/010 columns) ──────
-      CREATE TABLE IF NOT EXISTS workflow_run_units (
-        run_id           TEXT NOT NULL,
-        unit_id          TEXT NOT NULL,
-        step_id          TEXT,
-        node_id          TEXT NOT NULL,
-        parent_unit_id   TEXT,
-        phase            TEXT,
-        runner           TEXT,
-        model            TEXT,
-        status           TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'failed', 'skipped')),
-        input_hash       TEXT,
-        result_json      TEXT,
-        tokens           INTEGER,
-        failure_reason   TEXT,
-        worktree_path    TEXT,
-        started_at       TEXT,
-        finished_at      TEXT,
-        session_id       TEXT,
-        last_checkin_at  TEXT,
-        attempts         INTEGER NOT NULL DEFAULT 1,
-        claim_holder     TEXT,
-        claim_expires_at TEXT,
-        engine           TEXT,
-        PRIMARY KEY (run_id, unit_id),
-        FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
-      );
-      CREATE INDEX IF NOT EXISTS idx_workflow_run_units_run_step
-        ON workflow_run_units(run_id, step_id);
-
-      -- ── usage_events (index.db ensureUsageEventsSchema — the durable new home) ─
-      CREATE TABLE IF NOT EXISTS usage_events (
-        id         INTEGER PRIMARY KEY AUTOINCREMENT,
-        event_type TEXT NOT NULL,
-        query      TEXT,
-        entry_id   INTEGER,
-        entry_ref  TEXT,
-        signal     TEXT,
-        metadata   TEXT,
-        source     TEXT NOT NULL DEFAULT 'user',
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_usage_events_entry ON usage_events(entry_id);
-      CREATE INDEX IF NOT EXISTS idx_usage_events_type ON usage_events(event_type);
-      CREATE INDEX IF NOT EXISTS idx_usage_events_ref ON usage_events(entry_ref);
-      CREATE INDEX IF NOT EXISTS idx_usage_events_source ON usage_events(source);
-
-      -- ── legacy_state (ensureLegacyStateTable — the orphan quarantine archive) ──
-      CREATE TABLE IF NOT EXISTS legacy_state (
-        surface        TEXT NOT NULL,
-        old_ref        TEXT NOT NULL,
-        row_count      INTEGER NOT NULL DEFAULT 0,
-        reason         TEXT NOT NULL,
-        quarantined_at TEXT NOT NULL DEFAULT (datetime('now')),
-        PRIMARY KEY (surface, old_ref)
-      );
-    `
-    }
-  ];
-});
-
-// src/core/state-db.ts
-var exports_state_db = {};
-__export(exports_state_db, {
-  withStateDbTelemetry: () => withStateDbTelemetry,
-  withStateDbAsync: () => withStateDbAsync,
-  withStateDb: () => withStateDb,
-  withImmediateTransaction: () => withImmediateTransaction,
-  openStateDatabase: () => openStateDatabase,
-  listExistingTableNames: () => listExistingTableNames,
-  getStateDbPath: () => getStateDbPath
-});
-import fs7 from "node:fs";
-import path7 from "node:path";
-function getStateDbPath() {
-  return path7.join(getDataDir(), "state.db");
-}
-function openStateDatabase(dbPath) {
-  const canonicalPath = getStateDbPath();
-  const resolvedPath = dbPath ?? canonicalPath;
-  const isCanonical = path7.resolve(resolvedPath) === path7.resolve(canonicalPath);
-  if (isCanonical)
-    assertNoPendingMigrationOperation();
-  const releaseActivity = isCanonical ? acquireMaintenanceActivitySync("state-db") : undefined;
-  try {
-    if (isCanonical)
-      assertNoPendingMigrationOperation();
-    const existed = fs7.existsSync(resolvedPath);
-    if (existed) {
-      const preflight = openDatabase(resolvedPath, { readonly: true });
-      try {
-        preflight.exec("PRAGMA busy_timeout = 30000");
-        if (isCanonical)
-          assertCurrentMigrationLedger(preflight, STATE_MIGRATIONS);
-        else
-          assertMigrationLedger(preflight, STATE_MIGRATIONS);
-      } finally {
-        preflight.close();
-      }
-    }
-    const db = openManagedDatabase({
-      path: resolvedPath,
-      init: (db2) => runMigrations2(db2, { applyPending: !(isCanonical && existed) })
-    });
-    if (!releaseActivity)
-      return db;
-    let closed = false;
-    return {
-      prepare: db.prepare.bind(db),
-      exec: db.exec.bind(db),
-      run: db.run.bind(db),
-      transaction: db.transaction.bind(db),
-      get inTransaction() {
-        return db.inTransaction;
-      },
-      close() {
-        if (closed)
-          return;
-        closed = true;
-        try {
-          db.close();
-        } finally {
-          releaseActivity();
-        }
-      }
-    };
-  } catch (error2) {
-    releaseActivity?.();
-    throw error2;
-  }
-}
-function withStateDb(fn, opts) {
-  return withManagedDb(() => openStateDatabase(opts?.path), fn, opts);
-}
-function withStateDbAsync(fn, opts) {
-  return withManagedDbAsync(() => openStateDatabase(opts?.path), fn, opts);
-}
-function withStateDbTelemetry(fn, busyTimeoutMs = 250) {
-  if (!fs7.existsSync(getStateDbPath()))
-    return;
-  const db = openStateDatabase();
-  try {
-    db.exec(`PRAGMA busy_timeout = ${Math.max(0, Math.floor(busyTimeoutMs))}`);
-    fn(db);
-  } finally {
-    db.close();
-  }
-}
-function isRetryableBeginError(err) {
-  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
-  return msg.includes("database is locked") || msg.includes("database table is locked") || msg.includes("did not open a transaction");
-}
-function sleepSyncMs(ms) {
-  if (ms <= 0)
-    return;
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function withImmediateTransaction(db, fn) {
-  if (db.inTransaction) {
-    return fn();
-  }
-  let lastBeginErr;
-  for (let attempt = 1;attempt <= WITH_IMMEDIATE_TX_MAX_ATTEMPTS; attempt++) {
-    try {
-      db.exec("BEGIN IMMEDIATE");
-      if (!db.inTransaction) {
-        throw new Error("BEGIN IMMEDIATE did not open a transaction (phantom contention state)");
-      }
-    } catch (err) {
-      lastBeginErr = err;
-      if (isRetryableBeginError(err) && attempt < WITH_IMMEDIATE_TX_MAX_ATTEMPTS) {
-        if (db.inTransaction) {
-          try {
-            db.exec("ROLLBACK");
-          } catch {}
-        }
-        sleepSyncMs(2 ** (attempt - 1));
-        continue;
-      }
-      throw err;
-    }
-    try {
-      const result = fn();
-      if (!db.inTransaction) {
-        throw new Error("withImmediateTransaction invariant violated: transaction opened by BEGIN IMMEDIATE was no longer active after the transaction body ran; refusing to COMMIT (writes may have escaped serialization)");
-      }
-      db.exec("COMMIT");
-      return result;
-    } catch (err) {
-      if (db.inTransaction) {
-        try {
-          db.exec("ROLLBACK");
-        } catch {}
-      }
-      throw err;
-    }
-  }
-  throw lastBeginErr;
-}
-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);
-}
-var WITH_IMMEDIATE_TX_MAX_ATTEMPTS = 5;
-var init_state_db = __esm(() => {
-  init_database();
-  init_sqlite_migrations();
-  init_managed_db();
-  init_maintenance_barrier();
-  init_migration_operation();
-  init_paths();
-  init_migrations();
-});
-
-// src/storage/repositories/events-repository.ts
-var exports_events_repository = {};
-__export(exports_events_repository, {
-  readStateEvents: () => readStateEvents,
-  purgeOldEvents: () => purgeOldEvents,
-  insertEventOnce: () => insertEventOnce,
-  insertEvent: () => insertEvent,
-  importEventsJsonl: () => importEventsJsonl,
-  eventRowToEnvelope: () => eventRowToEnvelope
-});
-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 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 insertEventOnce(db, input) {
-  const rows = db.prepare("SELECT id, metadata_json FROM events WHERE event_type = ? AND ref IS ? ORDER BY id").all(input.eventType, input.ref ?? null);
-  for (const row of rows) {
-    try {
-      const metadata = JSON.parse(row.metadata_json);
-      if (metadata[input.idempotencyMetadataKey ?? "proposalTransactionId"] === input.idempotencyKey)
-        return row.id;
-    } catch {}
-  }
-  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));
-  if (!result)
-    throw new Error(`Failed to persist ${input.eventType} event.`);
-  return result.id;
-}
-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;
-}
-async function importEventsJsonl(db, jsonlPath) {
-  const { readFileSync, existsSync } = await import("node: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 };
-}
-var init_events_repository = __esm(() => {
-  init_warn();
-});
-
-// src/storage/repositories/task-history-repository.ts
-var exports_task_history_repository = {};
-__export(exports_task_history_repository, {
-  upsertTaskHistory: () => upsertTaskHistory,
-  reserveTaskHistoryAttempt: () => reserveTaskHistoryAttempt,
-  queryTaskHistory: () => queryTaskHistory,
-  queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
-  getTaskHistoryRuns: () => getTaskHistoryRuns,
-  getTaskHistory: () => getTaskHistory,
-  finalizeTaskHistoryAttempt: () => finalizeTaskHistoryAttempt,
-  decodeTaskHistoryMetadata: () => decodeTaskHistoryMetadata
-});
-function metadataError(message) {
-  throw new Error(`invalid task_history metadata_json: ${message}`);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateDetail(value) {
-  if (value === undefined || value === null)
-    return;
-  if (!isRecord(value))
-    metadataError("detail must be an object or null");
-  const allowed = new Set(["runId", "reason", "error", "exitCode"]);
-  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
-  if (unknown.length > 0)
-    metadataError(`unknown detail fields: ${unknown.sort().join(", ")}`);
-  for (const field of ["runId", "reason", "error"]) {
-    if (value[field] !== undefined && typeof value[field] !== "string")
-      metadataError(`detail.${field} must be a string`);
-  }
-  if (value.exitCode !== undefined && value.exitCode !== null && typeof value.exitCode !== "number") {
-    metadataError("detail.exitCode must be a number or null");
-  }
-}
-function decodeTaskHistoryMetadata(input) {
-  let parsed = input;
-  if (typeof input === "string") {
-    try {
-      parsed = JSON.parse(input);
-    } catch {
-      metadataError("not valid JSON");
-    }
-  }
-  if (!isRecord(parsed))
-    metadataError("root must be an object");
-  const version = parsed.metadataVersion ?? 1;
-  if (version === 1) {
-    const allowed = new Set(["metadataVersion", "durationMs", "detail", "profile"]);
-    const unknown = Object.keys(parsed).filter((key) => !allowed.has(key));
-    if (unknown.length > 0)
-      metadataError(`unknown v1 fields: ${unknown.sort().join(", ")}`);
-    if (parsed.metadataVersion !== undefined && parsed.metadataVersion !== 1)
-      metadataError("invalid v1 metadataVersion");
-    if (parsed.durationMs !== undefined && typeof parsed.durationMs !== "number")
-      metadataError("durationMs must be a number");
-    if (parsed.profile !== undefined && typeof parsed.profile !== "string")
-      metadataError("profile must be a string");
-    validateDetail(parsed.detail);
-    return {
-      metadataVersion: 1,
-      ...typeof parsed.durationMs === "number" ? { durationMs: parsed.durationMs } : {},
-      ...parsed.detail !== undefined && parsed.detail !== null ? { detail: parsed.detail } : {},
-      ...typeof parsed.profile === "string" ? { legacyProfile: parsed.profile } : {}
-    };
-  }
-  if (version === 2) {
-    const allowed = new Set(["metadataVersion", "durationMs", "detail", "engine"]);
-    const unknown = Object.keys(parsed).filter((key) => !allowed.has(key));
-    if (unknown.length > 0)
-      metadataError(`unknown v2 fields: ${unknown.sort().join(", ")}`);
-    if (typeof parsed.durationMs !== "number")
-      metadataError("durationMs must be a number");
-    if (!("detail" in parsed))
-      metadataError("detail is required in v2");
-    if (parsed.engine !== undefined && parsed.engine !== null && typeof parsed.engine !== "string") {
-      metadataError("engine must be a string or null");
-    }
-    validateDetail(parsed.detail);
-    return {
-      metadataVersion: 2,
-      durationMs: parsed.durationMs,
-      detail: parsed.detail ?? null,
-      ...parsed.engine !== undefined ? { engine: parsed.engine } : {}
-    };
-  }
-  metadataError(`unsupported metadataVersion: ${String(version)}`);
-}
-function reserveTaskHistoryAttempt(db, row) {
-  const result = 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);
-  return Number(result.changes) === 1;
-}
-function finalizeTaskHistoryAttempt(db, row) {
-  const result = db.prepare(`UPDATE task_history
-       SET status = ?, completed_at = ?, failed_at = ?, log_path = ?,
-           target_kind = ?, target_ref = ?, metadata_json = ?
-       WHERE task_id = ? AND started_at = ?
-         AND status = 'active' AND completed_at IS NULL`).run(row.status, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json, row.task_id, row.started_at);
-  return Number(result.changes) === 1;
-}
-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, id 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, id 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, id 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);
-}
-
-// src/core/best-effort.ts
-function bestEffort(fn, context) {
-  try {
-    return fn();
-  } catch (err) {
-    if (isVerbose()) {
-      warnVerbose(`[akm:best-effort] ${context ? `${context}: ` : ""}swallowed error`, err);
-    }
-    return;
-  }
-}
-var init_best_effort = __esm(() => {
-  init_warn();
-});
-
-// src/storage/repositories/index-meta-repository.ts
-function getMeta(db, key) {
-  const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
-  return row?.value;
-}
-function setMeta(db, key, value) {
-  db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value);
-}
-var init_index_meta_repository = () => {};
-
-// src/llm/embedders/types.ts
-var init_types = __esm(() => {
-  init_warn();
-});
-
-// src/storage/repositories/index-vec-repository.ts
-import { createRequire as createRequire4 } from "node:module";
-function loadVecExtension(db) {
-  try {
-    const esmRequire = createRequire4(import.meta.url);
-    const sqliteVec = esmRequire("sqlite-vec");
-    sqliteVec.load(db);
-    vecStatus.set(db, true);
-  } catch {
-    vecStatus.set(db, false);
-  }
-}
-function isVecAvailable(db) {
-  return vecStatus.get(db) ?? false;
-}
-function warnIfVecMissing(db, { once } = { once: false }) {
-  if (isVecAvailable(db))
-    return;
-  if (once && vecInitWarnedDbs.has(db))
-    return;
-  bestEffort(() => {
-    const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
-    const count = row?.cnt ?? 0;
-    if (count >= VEC_FALLBACK_THRESHOLD) {
-      warn(`Semantic search is using JS fallback for %d entries. Install sqlite-vec for faster performance.
-  See: %s`, count, VEC_DOCS_URL);
-      if (once)
-        vecInitWarnedDbs.add(db);
-    }
-  }, "embeddings table may not exist yet during init");
-}
-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");
-}
-var vecStatus, VEC_DOCS_URL = "https://github.com/itlackey/akm/blob/main/docs/reference/configuration.md#sqlite-vec-extension", VEC_FALLBACK_THRESHOLD = 1e4, vecInitWarnedDbs;
-var init_index_vec_repository = __esm(() => {
-  init_best_effort();
-  init_warn();
-  init_types();
-  init_index_meta_repository();
-  vecStatus = new WeakMap;
-  vecInitWarnedDbs = new WeakSet;
-});
-
-// src/storage/repositories/index-schema.ts
-function ensureGraphTables(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS graph_meta (
-      stash_root          TEXT PRIMARY KEY,
-      schema_version      INTEGER NOT NULL,
-      generated_at        TEXT NOT NULL,
-      considered_files    INTEGER NOT NULL DEFAULT 0,
-      extracted_files     INTEGER NOT NULL DEFAULT 0,
-      entity_count        INTEGER NOT NULL DEFAULT 0,
-      relation_count      INTEGER NOT NULL DEFAULT 0,
-      extraction_coverage REAL NOT NULL DEFAULT 0,
-      density             REAL NOT NULL DEFAULT 0,
-      extractor_id        TEXT,
-      extraction_run_id   TEXT,
-      model               TEXT,
-      prompt_version      TEXT,
-      batch_size          INTEGER,
-      cache_hits          INTEGER NOT NULL DEFAULT 0,
-      cache_misses        INTEGER NOT NULL DEFAULT 0,
-      truncation_count    INTEGER NOT NULL DEFAULT 0,
-      failure_count       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE TABLE IF NOT EXISTS graph_files (
-      stash_root        TEXT NOT NULL,
-      file_path         TEXT NOT NULL,
-      file_order        INTEGER NOT NULL,
-      file_type         TEXT NOT NULL,
-      body_hash         TEXT NOT NULL,
-      confidence        REAL,
-      status            TEXT NOT NULL DEFAULT 'extracted',
-      reason            TEXT,
-      extraction_run_id TEXT,
-      PRIMARY KEY (stash_root, file_path, body_hash)
-    );
-
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_graph_files_path
-      ON graph_files(stash_root, file_path);
-
-    CREATE INDEX IF NOT EXISTS idx_graph_files_stash_order
-      ON graph_files(stash_root, file_order);
-
-    CREATE TABLE IF NOT EXISTS graph_file_entities (
-      stash_root   TEXT NOT NULL,
-      file_path    TEXT NOT NULL,
-      body_hash    TEXT NOT NULL,
-      entity_order INTEGER NOT NULL,
-      entity_norm  TEXT NOT NULL,
-      entity       TEXT NOT NULL,
-      PRIMARY KEY (stash_root, file_path, body_hash, entity_order),
-      FOREIGN KEY (stash_root, file_path, body_hash)
-        REFERENCES graph_files(stash_root, file_path, body_hash) ON DELETE CASCADE
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_graph_file_entities_entity_norm
-      ON graph_file_entities(stash_root, entity_norm);
-
-    CREATE TABLE IF NOT EXISTS graph_file_relations (
-      stash_root     TEXT NOT NULL,
-      file_path      TEXT NOT NULL,
-      body_hash      TEXT NOT NULL,
-      relation_order INTEGER NOT NULL,
-      from_entity_norm TEXT NOT NULL,
-      from_entity    TEXT NOT NULL,
-      to_entity_norm TEXT NOT NULL,
-      to_entity      TEXT NOT NULL,
-      relation_type  TEXT,
-      confidence     REAL,
-      PRIMARY KEY (stash_root, file_path, body_hash, relation_order),
-      FOREIGN KEY (stash_root, file_path, body_hash)
-        REFERENCES graph_files(stash_root, file_path, body_hash) ON DELETE CASCADE
-    );
-
-    -- #624-P3: lazy graph-extraction queue. Standalone table (NO FK to
-    -- graph_files — a queued file by definition has no graph row yet).
-    -- Idempotent on (stash_root, file_path); drained highest-priority-first.
-    -- CREATE TABLE IF NOT EXISTS is the forward migration (no DB_VERSION bump).
-    CREATE TABLE IF NOT EXISTS graph_extraction_queue (
-      stash_root TEXT NOT NULL,
-      file_path  TEXT NOT NULL,
-      body_hash  TEXT NOT NULL,
-      queued_at  TEXT NOT NULL DEFAULT (datetime('now')),
-      priority   INTEGER NOT NULL DEFAULT 0,
-      PRIMARY KEY (stash_root, file_path)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_graph_extraction_queue_drain
-      ON graph_extraction_queue(stash_root, priority DESC, queued_at);
-  `);
-}
-function ensureSchema(db, embeddingDim) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS index_meta (
-      key   TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS entries (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      entry_key   TEXT NOT NULL UNIQUE,
-      dir_path    TEXT NOT NULL,
-      file_path   TEXT NOT NULL,
-      stash_dir   TEXT NOT NULL,
-      entry_json  TEXT NOT NULL,
-      search_text TEXT NOT NULL,
-      entry_type  TEXT NOT NULL,
-      derived_from TEXT,
-      -- Chunk-5 Step 2 / DB v18 (spec 14.4): bundle-adapter identity + provenance,
-      -- ADDITIVE alongside the legacy columns above. item_ref is the durable
-      -- <bundle>//<concept-id> spelling; nullable during the transition so a
-      -- pre-repoint reader path never trips a NOT NULL on a partially-migrated row.
-      item_ref     TEXT,
-      bundle_id    TEXT,
-      component_id TEXT,
-      concept_id   TEXT,
-      adapter_id   TEXT,
-      type         TEXT,
-      content_hash TEXT,
-      document_json TEXT
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entries_dir ON entries(dir_path);
-    CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
-    CREATE INDEX IF NOT EXISTS idx_entries_file_path ON entries(file_path);
-  `);
-  ensureBundleRefColumns(db);
-  ensureUniqueItemRefIndex(db);
-  ensureDerivedFromColumn(db);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS workflow_documents (
-      entry_id        INTEGER PRIMARY KEY REFERENCES entries(id) ON DELETE CASCADE,
-      schema_version  INTEGER NOT NULL,
-      document_json   TEXT NOT NULL,
-      source_path     TEXT NOT NULL,
-      source_hash     TEXT NOT NULL,
-      updated_at      TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_workflow_documents_source_path
-      ON workflow_documents(source_path);
-  `);
-  const versionAfterCreate = getMeta(db, "version");
-  if (!versionAfterCreate) {
-    setMeta(db, "version", String(DB_VERSION));
-  }
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS embeddings (
-      id        INTEGER PRIMARY KEY,
-      embedding BLOB NOT NULL,
-      FOREIGN KEY (id) REFERENCES entries(id)
-    );
-  `);
-  const ftsExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'").get();
-  if (!ftsExists) {
-    db.exec(`
-      CREATE VIRTUAL TABLE entries_fts USING fts5(
-        entry_id UNINDEXED,
-        name,
-        description,
-        tags,
-        hints,
-        content,
-        tokenize='porter unicode61'
-      );
-    `);
-  }
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS utility_scores (
-      entry_id     INTEGER PRIMARY KEY,
-      utility      REAL NOT NULL DEFAULT 0,
-      show_count   INTEGER NOT NULL DEFAULT 0,
-      search_count INTEGER NOT NULL DEFAULT 0,
-      select_rate  REAL NOT NULL DEFAULT 0,
-      last_used_at TEXT,
-      updated_at   TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (entry_id) REFERENCES entries(id) ON DELETE CASCADE
-    );
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS utility_scores_scoped (
-      entry_id     INTEGER NOT NULL,
-      scope_key    TEXT NOT NULL,
-      utility      REAL NOT NULL DEFAULT 0,
-      last_used_at INTEGER NOT NULL,
-      PRIMARY KEY (entry_id, scope_key)
-    );
-    CREATE INDEX IF NOT EXISTS idx_utility_scores_scoped_entry_id
-      ON utility_scores_scoped(entry_id);
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS index_dir_state (
-      dir_path          TEXT PRIMARY KEY,
-      file_set_hash     TEXT NOT NULL,
-      file_mtime_max_ms REAL NOT NULL,
-      reason            TEXT NOT NULL,
-      updated_at        TEXT NOT NULL
-    );
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS llm_enrichment_cache (
-      asset_ref     TEXT NOT NULL,
-      cache_variant TEXT NOT NULL,
-      body_hash     TEXT NOT NULL,
-      result_json   TEXT NOT NULL,
-      updated_at    INTEGER NOT NULL,
-      PRIMARY KEY (asset_ref, cache_variant)
-    );
-
-     CREATE INDEX IF NOT EXISTS idx_llm_cache_updated
-       ON llm_enrichment_cache(updated_at);
-  `);
-  migrateGraphFilesSchema(db);
-  ensureGraphTables(db);
-  migrateGraphDataFromLegacy(db);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS entries_fts_dirty (
-      entry_id INTEGER PRIMARY KEY
-    );
-  `);
-  const dimExplicit = embeddingDim !== undefined;
-  const effectiveDim = embeddingDim ?? (Number(getMeta(db, "embeddingDim")) || EMBEDDING_DIM);
-  if (isVecAvailable(db)) {
-    if (dimExplicit) {
-      const storedDim = getMeta(db, "embeddingDim");
-      if (storedDim && storedDim !== String(embeddingDim)) {
-        purgeEmbeddings(db, { dropVecTable: true });
-      }
-    }
-    const vecExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'").get();
-    if (!vecExists) {
-      if (!Number.isInteger(effectiveDim) || effectiveDim <= 0 || effectiveDim > 4096) {
-        throw new Error(`Invalid embedding dimension: ${effectiveDim}`);
-      }
-      db.exec(`
-        CREATE VIRTUAL TABLE entries_vec USING vec0(
-          id       INTEGER PRIMARY KEY,
-          embedding FLOAT[${effectiveDim}]
-        );
-      `);
-    }
-    if (dimExplicit) {
-      setMeta(db, "embeddingDim", String(embeddingDim));
-    }
-  } else {
-    if (dimExplicit) {
-      const storedDim = getMeta(db, "embeddingDim");
-      if (storedDim && storedDim !== String(embeddingDim)) {
-        purgeEmbeddings(db);
-      }
-      setMeta(db, "embeddingDim", String(embeddingDim));
-    }
-  }
-  db.exec(REGISTRY_INDEX_CACHE_DDL);
-}
-function ensureDerivedFromColumn(db) {
-  bestEffort(() => {
-    const cols = db.prepare("PRAGMA table_info(entries)").all();
-    const hasColumn = cols.some((c) => c.name === "derived_from");
-    if (!hasColumn) {
-      db.exec("ALTER TABLE entries ADD COLUMN derived_from TEXT");
-    }
-    db.exec("CREATE INDEX IF NOT EXISTS idx_entries_derived_from ON entries(derived_from)");
-  }, "entries table may not exist on a brand-new DB before CREATE — caller is responsible");
-}
-function ensureBundleRefColumns(db) {
-  bestEffort(() => {
-    const cols = db.prepare("PRAGMA table_info(entries)").all();
-    const have = new Set(cols.map((c) => c.name));
-    const additive = [
-      ["item_ref", "TEXT"],
-      ["bundle_id", "TEXT"],
-      ["component_id", "TEXT"],
-      ["concept_id", "TEXT"],
-      ["adapter_id", "TEXT"],
-      ["type", "TEXT"],
-      ["content_hash", "TEXT"],
-      ["document_json", "TEXT"]
-    ];
-    for (const [name, sqlType] of additive) {
-      if (!have.has(name))
-        db.exec(`ALTER TABLE entries ADD COLUMN ${name} ${sqlType}`);
-    }
-  }, "entries table may not exist on a brand-new DB before CREATE — caller is responsible");
-}
-function ensureUniqueItemRefIndex(db) {
-  let uniqueOk = false;
-  bestEffort(() => {
-    db.exec("DROP INDEX IF EXISTS idx_entries_item_ref");
-    db.exec("CREATE UNIQUE INDEX idx_entries_item_ref ON entries(item_ref)");
-    uniqueOk = true;
-  }, "entries.item_ref UNIQUE index — column added by ensureBundleRefColumns above");
-  if (!uniqueOk) {
-    warn("[akm] entries.item_ref UNIQUE index could not be built (duplicate item_ref on a partially-migrated index) — " + "keeping the plain lookup index; a full `akm index` rebuild restores uniqueness.");
-    bestEffort(() => db.exec("CREATE INDEX IF NOT EXISTS idx_entries_item_ref ON entries(item_ref)"), "entries.item_ref lookup index fallback");
-  }
-}
-function tableExists(db, name) {
-  const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1").get(name);
-  return row !== undefined && row !== null;
-}
-function migrateGraphFilesSchema(db) {
-  bestEffort(() => {
-    const cols = db.prepare("PRAGMA table_info(graph_files)").all();
-    const isLegacyShape = cols.some((c) => c.name === "entry_id");
-    if (!isLegacyShape)
-      return;
-    db.exec("DROP TABLE IF EXISTS graph_file_relations_legacy");
-    db.exec("DROP TABLE IF EXISTS graph_file_entities_legacy");
-    db.exec("DROP TABLE IF EXISTS graph_files_legacy");
-    db.exec("ALTER TABLE graph_files RENAME TO graph_files_legacy");
-    if (tableExists(db, "graph_file_entities")) {
-      db.exec("ALTER TABLE graph_file_entities RENAME TO graph_file_entities_legacy");
-    }
-    if (tableExists(db, "graph_file_relations")) {
-      db.exec("ALTER TABLE graph_file_relations RENAME TO graph_file_relations_legacy");
-    }
-  }, "graph_files may not exist on a brand-new DB before CREATE — caller is responsible");
-}
-function migrateGraphDataFromLegacy(db) {
-  if (!tableExists(db, "graph_files_legacy"))
-    return;
-  let migratedFiles = 0;
-  bestEffort(() => {
-    db.transaction(() => {
-      const res = db.prepare(`INSERT OR IGNORE INTO graph_files
-             (stash_root, file_path, body_hash, file_order, file_type, confidence, status, reason, extraction_run_id)
-           SELECT stash_root, file_path, body_hash, file_order, file_type, confidence, status, reason, extraction_run_id
-             FROM graph_files_legacy
-            WHERE body_hash IS NOT NULL AND body_hash != ''`).run();
-      migratedFiles = Number(res.changes);
-      if (tableExists(db, "graph_file_entities_legacy")) {
-        db.exec(`INSERT OR IGNORE INTO graph_file_entities
-             (stash_root, file_path, body_hash, entity_order, entity_norm, entity)
-           SELECT gf.stash_root, gf.file_path, gf.body_hash, e.entity_order, e.entity_norm, e.entity
-             FROM graph_file_entities_legacy e
-             JOIN graph_files_legacy gf ON gf.entry_id = e.entry_id
-            WHERE gf.body_hash IS NOT NULL AND gf.body_hash != ''`);
-      }
-      if (tableExists(db, "graph_file_relations_legacy")) {
-        db.exec(`INSERT OR IGNORE INTO graph_file_relations
-             (stash_root, file_path, body_hash, relation_order, from_entity_norm, from_entity, to_entity_norm, to_entity, relation_type, confidence)
-           SELECT gf.stash_root, gf.file_path, gf.body_hash, r.relation_order, r.from_entity_norm, r.from_entity, r.to_entity_norm, r.to_entity, r.relation_type, r.confidence
-             FROM graph_file_relations_legacy r
-             JOIN graph_files_legacy gf ON gf.entry_id = r.entry_id
-            WHERE gf.body_hash IS NOT NULL AND gf.body_hash != ''`);
-      }
-    })();
-  }, "graph data migration is best-effort; legacy tables are dropped regardless below");
-  bestEffort(() => {
-    db.exec("DROP TABLE IF EXISTS graph_file_relations_legacy");
-    db.exec("DROP TABLE IF EXISTS graph_file_entities_legacy");
-    db.exec("DROP TABLE IF EXISTS graph_files_legacy");
-  }, "drop legacy graph tables after migration");
-  if (migratedFiles > 0) {
-    warn(`[akm] graph index re-keyed (#624): migrated ${migratedFiles} extracted file(s) to the new schema — no re-extraction needed. Index + embeddings untouched.`);
-  }
-}
-var DB_VERSION = 20, EMBEDDING_DIM = 384, 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_index_schema = __esm(() => {
-  init_best_effort();
-  init_warn();
-  init_index_meta_repository();
-  init_index_vec_repository();
-});
-
-// src/storage/repositories/index-connection.ts
-var exports_index_connection = {};
-__export(exports_index_connection, {
-  openReadonlyExistingDatabase: () => openReadonlyExistingDatabase,
-  openIndexDatabase: () => openIndexDatabase,
-  openExistingDatabase: () => openExistingDatabase,
-  closeDatabase: () => closeDatabase
-});
-import fs8 from "node:fs";
-import { createRequire as createRequire5 } from "node:module";
-function openIndexDatabase(dbPath, options) {
-  return openManagedDatabase({
-    path: dbPath ?? getDbPath(),
-    init: (db) => {
-      loadVecExtension(db);
-      const resolvedDim = options?.embeddingDim ?? resolveConfiguredEmbeddingDim();
-      ensureSchema(db, resolvedDim);
-      warnIfVecMissing(db, { once: true });
-    }
-  });
-}
-function resolveConfiguredEmbeddingDim() {
-  try {
-    const esmRequire = createRequire5(import.meta.url);
-    const { loadConfig } = esmRequire("../../core/config/config");
-    const dim = loadConfig().embedding?.dimension;
-    if (typeof dim === "number" && Number.isInteger(dim) && dim > 0 && dim <= 4096) {
-      return dim;
-    }
-    return;
-  } catch {
-    return;
-  }
-}
-function openExistingDatabase(dbPath) {
-  return openManagedDatabase({ path: dbPath ?? getDbPath(), init: loadVecExtension });
-}
-function openReadonlyExistingDatabase(dbPath) {
-  const resolvedPath = dbPath ?? getDbPath();
-  if (!fs8.existsSync(resolvedPath))
-    return;
-  return openDatabase(resolvedPath, { readonly: true, create: false });
-}
-function closeDatabase(db) {
-  db.close();
-}
-var init_index_connection = __esm(() => {
-  init_paths();
-  init_database();
-  init_managed_db();
-  init_index_schema();
-  init_index_vec_repository();
-});
-
-// src/storage/repositories/index-connection.ts
-function openExistingDatabase2(dbPath) {
-  return openManagedDatabase({ path: dbPath ?? getDbPath(), init: loadVecExtension });
-}
-function closeDatabase2(db) {
-  db.close();
-}
-var init_index_connection2 = __esm(() => {
-  init_paths();
-  init_database();
-  init_managed_db();
-  init_index_schema();
-  init_index_vec_repository();
-});
-
-// src/indexer/db/graph-db.ts
-var exports_graph_db = {};
-__export(exports_graph_db, {
-  replaceStoredGraph: () => replaceStoredGraph,
-  loadStoredGraphSnapshot: () => loadStoredGraphSnapshot,
-  loadStoredGraphMeta: () => loadStoredGraphMeta,
-  loadGraphMetaOnly: () => loadGraphMetaOnly,
-  loadGraphFilesOnly: () => loadGraphFilesOnly,
-  loadGraphEntitiesByPath: () => loadGraphEntitiesByPath,
-  hasGraphData: () => hasGraphData,
-  enqueueGraphExtraction: () => enqueueGraphExtraction,
-  drainExtractionQueue: () => drainExtractionQueue,
-  deleteStoredGraph: () => deleteStoredGraph
-});
-import fs9 from "node:fs";
-function withReadableGraphDb(db, fn) {
-  if (db)
-    return fn(db);
-  const dbPath = getDbPath();
-  if (!fs9.existsSync(dbPath))
-    throw new Error("GRAPH_DB_MISSING");
-  const opened = openExistingDatabase2(dbPath);
-  try {
-    return fn(opened);
-  } finally {
-    closeDatabase2(opened);
-  }
-}
-function uniqueSorted(values) {
-  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
-}
-function normalizeEntity(value) {
-  return value.trim().toLowerCase();
-}
-function replaceStoredGraph(db, graph) {
-  const upsertMeta = db.prepare(`INSERT INTO graph_meta (
-       stash_root,
-       schema_version,
-       generated_at,
-       considered_files,
-       extracted_files,
-       entity_count,
-       relation_count,
-       extraction_coverage,
-       density,
-       extractor_id,
-       extraction_run_id,
-       model,
-       prompt_version,
-       batch_size,
-       cache_hits,
-       cache_misses,
-       truncation_count,
-       failure_count
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(stash_root) DO UPDATE SET
-        schema_version = excluded.schema_version,
-        generated_at = excluded.generated_at,
-        considered_files = excluded.considered_files,
-        extracted_files = excluded.extracted_files,
-        entity_count = excluded.entity_count,
-        relation_count = excluded.relation_count,
-        extraction_coverage = excluded.extraction_coverage,
-        density = excluded.density,
-        extractor_id = excluded.extractor_id,
-        extraction_run_id = excluded.extraction_run_id,
-        model = excluded.model,
-        prompt_version = excluded.prompt_version,
-        batch_size = excluded.batch_size,
-        cache_hits = excluded.cache_hits,
-        cache_misses = excluded.cache_misses,
-        truncation_count = excluded.truncation_count,
-        failure_count = excluded.failure_count`);
-  const selectExisting = db.prepare("SELECT file_path, body_hash, file_order FROM graph_files WHERE stash_root = ?");
-  const deleteFile = db.prepare("DELETE FROM graph_files WHERE stash_root = ? AND file_path = ? AND body_hash = ?");
-  const deleteEntities = db.prepare("DELETE FROM graph_file_entities WHERE stash_root = ? AND file_path = ? AND body_hash = ?");
-  const deleteRelations = db.prepare("DELETE FROM graph_file_relations WHERE stash_root = ? AND file_path = ? AND body_hash = ?");
-  const insertFile = db.prepare(`INSERT INTO graph_files (
-       stash_root, file_path, file_order, file_type, body_hash, confidence, status, reason, extraction_run_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-  const updateFileMeta = db.prepare(`UPDATE graph_files
-       SET file_order = ?, file_type = ?, confidence = ?, status = ?, reason = ?, extraction_run_id = ?
-        WHERE stash_root = ? AND file_path = ? AND body_hash = ?`);
-  const insertEntity = db.prepare(`INSERT INTO graph_file_entities (stash_root, file_path, body_hash, entity_order, entity_norm, entity)
-     VALUES (?, ?, ?, ?, ?, ?)`);
-  const insertRelation = db.prepare(`INSERT INTO graph_file_relations (
-       stash_root, file_path, body_hash, relation_order, from_entity_norm, from_entity, to_entity_norm, to_entity, relation_type, confidence
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-  const quality = graph.quality;
-  const telemetry = graph.telemetry;
-  db.transaction(() => {
-    upsertMeta.run(graph.stashRoot, graph.schemaVersion, graph.generatedAt, quality?.consideredFiles ?? graph.files.length, quality?.extractedFiles ?? graph.files.length, quality?.entityCount ?? graph.entities?.length ?? 0, quality?.relationCount ?? graph.relations?.length ?? 0, quality?.extractionCoverage ?? 0, quality?.density ?? 0, telemetry?.extractorId ?? null, telemetry?.extractionRunId ?? null, telemetry?.model ?? null, telemetry?.promptVersion ?? null, telemetry?.batchSize ?? null, telemetry?.cacheHits ?? 0, telemetry?.cacheMisses ?? 0, telemetry?.truncationCount ?? 0, telemetry?.failureCount ?? 0);
-    const existingRows = selectExisting.all(graph.stashRoot);
-    const existingByPath = new Map;
-    for (const row of existingRows)
-      existingByPath.set(row.file_path, row);
-    const presentPaths = new Set;
-    for (const [fileOrder, node] of graph.files.entries()) {
-      const bodyHash = node.bodyHash && node.bodyHash.length > 0 ? node.bodyHash : "";
-      presentPaths.add(node.path);
-      const existing = existingByPath.get(node.path);
-      if (existing && existing.body_hash === bodyHash) {
-        updateFileMeta.run(fileOrder, node.type, node.confidence ?? null, node.status ?? (node.entities.length > 0 ? "extracted" : "empty"), node.reason ?? (node.entities.length > 0 ? "none" : "no_graph_content"), node.extractionRunId ?? telemetry?.extractionRunId ?? null, graph.stashRoot, node.path, bodyHash);
-        continue;
-      }
-      if (existing) {
-        deleteEntities.run(graph.stashRoot, existing.file_path, existing.body_hash);
-        deleteRelations.run(graph.stashRoot, existing.file_path, existing.body_hash);
-        deleteFile.run(graph.stashRoot, existing.file_path, existing.body_hash);
-      }
-      insertFile.run(graph.stashRoot, node.path, fileOrder, node.type, bodyHash, node.confidence ?? null, node.status ?? (node.entities.length > 0 ? "extracted" : "empty"), node.reason ?? (node.entities.length > 0 ? "none" : "no_graph_content"), node.extractionRunId ?? telemetry?.extractionRunId ?? null);
-      for (const [entityOrder, entity] of node.entities.entries()) {
-        insertEntity.run(graph.stashRoot, node.path, bodyHash, entityOrder, normalizeEntity(entity), entity);
-      }
-      for (const [relationOrder, relation] of node.relations.entries()) {
-        insertRelation.run(graph.stashRoot, node.path, bodyHash, relationOrder, normalizeEntity(relation.from), relation.from, normalizeEntity(relation.to), relation.to, relation.type ?? null, relation.confidence ?? null);
-      }
-    }
-    for (const row of existingRows) {
-      if (!presentPaths.has(row.file_path)) {
-        deleteEntities.run(graph.stashRoot, row.file_path, row.body_hash);
-        deleteRelations.run(graph.stashRoot, row.file_path, row.body_hash);
-        deleteFile.run(graph.stashRoot, row.file_path, row.body_hash);
-      }
-    }
-  })();
-}
-function deleteStoredGraph(db, stashPath) {
-  db.transaction(() => {
-    db.prepare("DELETE FROM graph_files WHERE stash_root = ?").run(stashPath);
-    db.prepare("DELETE FROM graph_meta WHERE stash_root = ?").run(stashPath);
-  })();
-}
-function hasGraphData(db, stashRoot, filePath) {
-  try {
-    const row = db.prepare("SELECT 1 AS present FROM graph_files WHERE stash_root = ? AND file_path = ? LIMIT 1").get(stashRoot, filePath);
-    return row !== undefined;
-  } catch {
-    return false;
-  }
-}
-function enqueueGraphExtraction(db, stashRoot, filePath, bodyHash, priority = 0) {
-  try {
-    db.prepare(`INSERT INTO graph_extraction_queue (stash_root, file_path, body_hash, priority)
-         VALUES (?, ?, ?, ?)
-       ON CONFLICT(stash_root, file_path) DO UPDATE SET
-         body_hash = excluded.body_hash,
-         priority  = MAX(graph_extraction_queue.priority, excluded.priority),
-         queued_at = datetime('now')`).run(stashRoot, filePath, bodyHash, priority);
-  } catch (err) {
-    rethrowIfTestIsolationError(err);
-  }
-}
-function drainExtractionQueue(db, stashRoot, limit) {
-  try {
-    return db.transaction(() => {
-      const rows = db.prepare(`SELECT file_path, body_hash, priority
-             FROM graph_extraction_queue
-             WHERE stash_root = ?
-             ORDER BY priority DESC, queued_at ASC
-             LIMIT ?`).all(stashRoot, limit);
-      const del = db.prepare("DELETE FROM graph_extraction_queue WHERE stash_root = ? AND file_path = ?");
-      for (const row of rows)
-        del.run(stashRoot, row.file_path);
-      return rows.map((row) => ({ filePath: row.file_path, bodyHash: row.body_hash, priority: row.priority }));
-    })();
-  } catch (err) {
-    rethrowIfTestIsolationError(err);
-    return [];
-  }
-}
-function loadGraphMetaOnly(stashPath, db) {
-  return loadStoredGraphMeta(stashPath, db);
-}
-function loadGraphFilesOnly(stashPath, db) {
-  try {
-    return withReadableGraphDb(db, (readDb) => {
-      try {
-        const rows = readDb.prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason
-                FROM graph_files
-                WHERE stash_root = ?
-                ORDER BY file_order`).all(stashPath);
-        return rows.map((row) => ({
-          path: row.file_path,
-          type: row.file_type,
-          bodyHash: row.body_hash,
-          ...typeof row.confidence === "number" ? { confidence: row.confidence } : {},
-          ...row.status ? { status: row.status } : {},
-          ...row.reason ? { reason: row.reason } : {}
-        }));
-      } catch {
-        return [];
-      }
-    });
-  } catch (err) {
-    rethrowIfTestIsolationError(err);
-    return [];
-  }
-}
-function loadGraphEntitiesByPath(db, stashRoot, filePath, bodyHash) {
-  try {
-    const rows = db.prepare(`SELECT entity FROM graph_file_entities
-          WHERE stash_root = ? AND file_path = ? AND body_hash = ?
-          ORDER BY entity_order`).all(stashRoot, filePath, bodyHash);
-    return rows.map((r) => r.entity);
-  } catch {
-    return [];
-  }
-}
-function loadStoredGraphMeta(stashPath, db) {
-  try {
-    return withReadableGraphDb(db, (readDb) => {
-      try {
-        const row = readDb.prepare(`SELECT
-               stash_root,
-               schema_version,
-               generated_at,
-               considered_files,
-               extracted_files,
-               entity_count,
-               relation_count,
-               extraction_coverage,
-               density,
-               extractor_id,
-               extraction_run_id,
-               model,
-               prompt_version,
-               batch_size,
-               cache_hits,
-               cache_misses,
-               truncation_count,
-               failure_count
-              FROM graph_meta
-              WHERE stash_root = ?`).get(stashPath);
-        if (!row)
-          return null;
-        return {
-          stashPath: row.stash_root,
-          graphPath: getDbPath(),
-          schemaVersion: row.schema_version,
-          generatedAt: row.generated_at,
-          quality: {
-            consideredFiles: row.considered_files,
-            extractedFiles: row.extracted_files,
-            entityCount: row.entity_count,
-            relationCount: row.relation_count,
-            extractionCoverage: row.extraction_coverage,
-            density: row.density
-          },
-          telemetry: {
-            ...row.extractor_id ? { extractorId: row.extractor_id } : {},
-            ...row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {},
-            ...row.model ? { model: row.model } : {},
-            ...row.prompt_version ? { promptVersion: row.prompt_version } : {},
-            ...typeof row.batch_size === "number" ? { batchSize: row.batch_size } : {},
-            cacheHits: row.cache_hits,
-            cacheMisses: row.cache_misses,
-            truncationCount: row.truncation_count,
-            failureCount: row.failure_count,
-            retryAttempts: 0
-          }
-        };
-      } catch {
-        return null;
-      }
-    });
-  } catch (err) {
-    rethrowIfTestIsolationError(err);
-    return null;
-  }
-}
-function loadStoredGraphSnapshot(stashPath, db) {
-  try {
-    return withReadableGraphDb(db, (readDb) => {
-      const meta = loadStoredGraphMeta(stashPath, readDb);
-      if (!meta)
-        return null;
-      try {
-        const fileRows = readDb.prepare(`SELECT file_path, file_type, body_hash, confidence, status, reason, extraction_run_id
-              FROM graph_files
-              WHERE stash_root = ?
-              ORDER BY file_order`).all(stashPath);
-        const entityRows = readDb.prepare(`SELECT gf.file_path AS file_path, gfe.entity AS entity
-             FROM graph_file_entities gfe
-             JOIN graph_files gf
-               ON gf.stash_root = gfe.stash_root
-              AND gf.file_path = gfe.file_path
-              AND gf.body_hash = gfe.body_hash
-             WHERE gf.stash_root = ?
-             ORDER BY gf.file_order, gfe.entity_order`).all(stashPath);
-        const relationRows = readDb.prepare(`SELECT gf.file_path AS file_path,
-                    gfr.from_entity AS from_entity,
-                    gfr.to_entity AS to_entity,
-                    gfr.relation_type AS relation_type,
-                    gfr.confidence AS confidence
-             FROM graph_file_relations gfr
-             JOIN graph_files gf
-               ON gf.stash_root = gfr.stash_root
-              AND gf.file_path = gfr.file_path
-              AND gf.body_hash = gfr.body_hash
-             WHERE gf.stash_root = ?
-             ORDER BY gf.file_order, gfr.relation_order`).all(stashPath);
-        const entitiesByPath = new Map;
-        for (const row of entityRows) {
-          const bucket = entitiesByPath.get(row.file_path);
-          if (bucket)
-            bucket.push(row.entity);
-          else
-            entitiesByPath.set(row.file_path, [row.entity]);
-        }
-        const relationsByPath = new Map;
-        for (const row of relationRows) {
-          const relation = {
-            from: row.from_entity,
-            to: row.to_entity,
-            ...row.relation_type ? { type: row.relation_type } : {},
-            ...typeof row.confidence === "number" ? { confidence: row.confidence } : {}
-          };
-          const bucket = relationsByPath.get(row.file_path);
-          if (bucket)
-            bucket.push(relation);
-          else
-            relationsByPath.set(row.file_path, [relation]);
-        }
-        const files = fileRows.map((row) => ({
-          path: row.file_path,
-          type: row.file_type,
-          ...row.body_hash ? { bodyHash: row.body_hash } : {},
-          entities: entitiesByPath.get(row.file_path) ?? [],
-          relations: relationsByPath.get(row.file_path) ?? [],
-          ...typeof row.confidence === "number" ? { confidence: row.confidence } : {},
-          ...row.status ? { status: row.status } : {},
-          ...row.reason ? { reason: row.reason } : {},
-          ...row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {}
-        }));
-        return {
-          stashPath: meta.stashPath,
-          graphPath: meta.graphPath,
-          schemaVersion: meta.schemaVersion,
-          generatedAt: meta.generatedAt,
-          ...meta.quality ? { quality: meta.quality } : {},
-          ...meta.telemetry ? { telemetry: meta.telemetry } : {},
-          files,
-          entities: uniqueSorted(files.flatMap((file) => file.entities)),
-          relations: files.flatMap((file) => file.relations)
-        };
-      } catch {
-        return null;
-      }
-    });
-  } catch (err) {
-    rethrowIfTestIsolationError(err);
-    return null;
-  }
-}
-var init_graph_db = __esm(() => {
-  init_errors();
-  init_paths();
-  init_index_connection2();
-});
-
-// scripts/migrate-storage.ts
-import fs10 from "fs";
-import os from "os";
-import path8 from "path";
-import readline from "readline";
-
-// src/core/paths.ts
-init_errors();
-init_platform();
-import path from "node:path";
-function isTransientStashPath(p) {
-  return p.startsWith("/tmp/") || p === "/tmp" || p.startsWith("/var/tmp/") || p === "/var/tmp" || p.startsWith("/private/tmp/") || p.startsWith("/private/var/folders/") || p.startsWith("/var/folders/");
-}
-function getConfigDir(env = process.env, platform = process.platform) {
-  const override = env.AKM_CONFIG_DIR?.trim();
-  if (override)
-    return override;
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path.join(appData, "akm");
-  } else {
-    const xdgConfigHome2 = env.XDG_CONFIG_HOME?.trim();
-    if (xdgConfigHome2)
-      return path.join(xdgConfigHome2, "akm");
-  }
-  const stashOverride = env.AKM_STASH_DIR?.trim();
-  if (stashOverride && isTransientStashPath(stashOverride)) {
-    return path.join(stashOverride, ".akm");
-  }
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path.join(appData, "akm");
-    const userProfile = env.USERPROFILE?.trim();
-    if (!userProfile) {
-      throw new ConfigError("Unable to determine config directory. Set APPDATA or USERPROFILE.", "CONFIG_DIR_UNRESOLVABLE");
-    }
-    return path.join(userProfile, "AppData", "Roaming", "akm");
-  }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
-  if (xdgConfigHome)
-    return path.join(xdgConfigHome, "akm");
-  const home = env.HOME?.trim();
-  if (!home) {
-    throw new ConfigError("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.", "CONFIG_DIR_UNRESOLVABLE");
-  }
-  return path.join(home, ".config", "akm");
-}
-function getCacheDir(env = process.env) {
-  const override = env.AKM_CACHE_DIR?.trim();
-  if (override)
-    return override;
-  if (IS_WINDOWS) {
-    const localAppData = env.LOCALAPPDATA?.trim();
-    if (localAppData)
-      return path.join(localAppData, "akm");
-    const userProfile = env.USERPROFILE?.trim();
-    if (userProfile)
-      return path.join(userProfile, "AppData", "Local", "akm");
-    const appData = env.APPDATA?.trim();
-    if (appData) {
-      return path.join(appData, "..", "Local", "akm");
-    }
-  } else {
-    const xdgCacheHome = env.XDG_CACHE_HOME?.trim();
-    if (xdgCacheHome)
-      return path.join(xdgCacheHome, "akm");
-  }
-  const stashOverride = env.AKM_STASH_DIR?.trim();
-  if (stashOverride && isTransientStashPath(stashOverride)) {
-    return path.join(stashOverride, ".akm", "cache");
-  }
-  if (IS_WINDOWS) {
-    throw new ConfigError("Unable to determine cache directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
-  }
-  const home = env.HOME?.trim();
-  if (!home)
-    return path.join("/tmp", "akm-cache");
-  return path.join(home, ".cache", "akm");
-}
-function getDefaultStashDir(env = process.env) {
-  const override = env.AKM_STASH_DIR?.trim();
-  if (override)
-    return override;
-  if (IS_WINDOWS) {
-    const userProfile = env.USERPROFILE?.trim();
-    if (userProfile)
-      return path.join(userProfile, "Documents", "akm");
-    return path.join("C:\\", "akm");
-  }
-  const home = env.HOME?.trim();
-  if (!home) {
-    throw new ConfigError("Unable to determine default stash directory. Set HOME.", "STASH_DIR_NOT_FOUND");
-  }
-  return path.join(home, "akm");
-}
-
-// src/indexer/usage/unmigrated-vaults-guard.ts
-init_warn();
-var MIGRATED_MARKER = ".migrated";
-var warnedStashDirs = new Set;
-
-// scripts/migrate-storage.ts
-var args = process.argv.slice(2);
-var DRY_RUN = args.includes("--dry-run");
-var YES = args.includes("--yes");
-var LIST_ONLY = args.includes("--list");
-function parseFromArg() {
-  const idx = args.indexOf("--from");
-  if (idx === -1)
-    return null;
-  const val = args[idx + 1];
-  if (!val || val.startsWith("--")) {
-    console.error("Error: --from requires a version argument (e.g. --from 0.8).");
-    process.exit(2);
-  }
-  return val;
-}
-var FROM_VERSION = parseFromArg();
-var dataDir = process.env.AKM_DATA_DIR?.trim() ?? (process.env.XDG_DATA_HOME?.trim() ? path8.join(process.env.XDG_DATA_HOME.trim(), "akm") : path8.join(os.homedir(), ".local", "share", "akm"));
-var stateDir = process.env.AKM_STATE_DIR?.trim() ?? (process.env.XDG_STATE_HOME?.trim() ? path8.join(process.env.XDG_STATE_HOME.trim(), "akm") : path8.join(os.homedir(), ".local", "state", "akm"));
-var cacheDir = getCacheDir();
-var configDir = getConfigDir();
-var stateDbPath = path8.join(dataDir, "state.db");
-var indexDbPath = path8.join(dataDir, "index.db");
-var PATHS = {
-  cacheDir,
-  configDir,
-  dataDir,
-  stateDir,
-  stateDbPath,
-  indexDbPath
-};
-var versionReports = [];
-function ensureDir(dir) {
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
-  }
-}
-function copyAndVerify(src, dest) {
-  fs10.copyFileSync(src, dest);
-  const srcStat = fs10.statSync(src);
-  const destStat = fs10.statSync(dest);
-  return destStat.size === srcStat.size;
-}
-function copyTree(src, dest, opts) {
-  let copied = 0;
-  let skipped = 0;
-  let failed = 0;
-  ensureDir(dest);
-  for (const entry of fs10.readdirSync(src, { withFileTypes: true })) {
-    const srcEntry = path8.join(src, entry.name);
-    const destEntry = path8.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const sub = copyTree(srcEntry, destEntry, opts);
-      copied += sub.copied;
-      skipped += sub.skipped;
-      failed += sub.failed;
-      continue;
-    }
-    if (!opts.clobber && fs10.existsSync(destEntry)) {
-      skipped++;
-      continue;
-    }
-    try {
-      if (copyAndVerify(srcEntry, destEntry)) {
-        copied++;
-      } else {
-        failed++;
-      }
-    } catch {
-      failed++;
-    }
-  }
-  return { copied, skipped, failed };
-}
-function countFilesRecursive(dir) {
-  let count = 0;
-  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      count += countFilesRecursive(path8.join(dir, entry.name));
-    } else {
-      count++;
-    }
-  }
-  return count;
-}
-async function runSteps(steps, ctx) {
-  for (const step of steps) {
-    ctx.recordStep(await step.run(ctx));
-  }
-}
-function migrateDb(ctx, filename) {
-  const src = path8.join(ctx.paths.cacheDir, filename);
-  const dest = path8.join(ctx.paths.dataDir, filename);
-  if (!fs10.existsSync(src)) {
-    return { name: filename, status: "skipped", detail: "source not found" };
-  }
-  if (fs10.existsSync(dest)) {
-    return { name: filename, status: "skipped", detail: "destination already exists" };
-  }
-  if (ctx.dryRun) {
-    return { name: filename, status: "success", detail: `[dry-run] would copy ${src} \u2192 ${dest}` };
-  }
-  ensureDir(ctx.paths.dataDir);
-  const ok = copyAndVerify(src, dest);
-  if (ok) {
-    return {
-      name: filename,
-      status: "success",
-      detail: `copied to ${dest} \u2014 source left at ${src} (delete manually when ready)`
-    };
-  }
-  return { name: filename, status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
-}
-async function migrateEventsJsonl(ctx) {
-  const src = path8.join(ctx.paths.cacheDir, "events.jsonl");
-  if (!fs10.existsSync(src)) {
-    return { name: "events.jsonl \u2192 state.db", status: "skipped", detail: "source not found" };
-  }
-  if (ctx.dryRun) {
-    return {
-      name: "events.jsonl \u2192 state.db",
-      status: "success",
-      detail: `[dry-run] would import ${src} into ${ctx.paths.stateDbPath}`
-    };
-  }
-  try {
-    ensureDir(ctx.paths.dataDir);
-    const { openStateDatabase: openStateDatabase2 } = await Promise.resolve().then(() => (init_state_db(), exports_state_db));
-    const { importEventsJsonl: importEventsJsonl2 } = await Promise.resolve().then(() => (init_events_repository(), exports_events_repository));
-    const db = openStateDatabase2(ctx.paths.stateDbPath);
-    try {
-      db.exec("BEGIN");
-      let imported = 0;
-      let maxId = 0;
-      let skipped = 0;
-      try {
-        const result = await importEventsJsonl2(db, src);
-        imported = result.imported;
-        maxId = result.maxId;
-        skipped = result.skipped;
-        db.exec("COMMIT");
-      } catch (err) {
-        db.exec("ROLLBACK");
-        throw err;
-      }
-      const dedupNote = skipped > 0 ? ` (${skipped} duplicate(s) skipped \u2014 re-run idempotency)` : "";
-      return {
-        name: "events.jsonl \u2192 state.db",
-        status: "success",
-        detail: `imported ${imported} events (max id: ${maxId})${dedupNote} \u2014 source left at ${src} (delete manually when ready)`
-      };
-    } finally {
-      db.close();
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { name: "events.jsonl \u2192 state.db", status: "failed", detail: msg };
-  }
-}
-function migrateTaskHistory(ctx) {
-  const src = path8.join(ctx.paths.cacheDir, "tasks", "history");
-  const dest = path8.join(ctx.paths.stateDir, "tasks", "history");
-  if (!fs10.existsSync(src)) {
-    return { name: "tasks/history/", status: "skipped", detail: "source directory not found" };
-  }
-  try {
-    const files = fs10.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" };
-    }
-    if (ctx.dryRun) {
-      return {
-        name: "tasks/history/",
-        status: "success",
-        detail: `[dry-run] would copy ${files.length} *.jsonl file(s) from ${src} \u2192 ${dest}`
-      };
-    }
-    ensureDir(dest);
-    let copied = 0;
-    let failed = 0;
-    for (const file of files) {
-      const srcFile = path8.join(src, file);
-      const destFile = path8.join(dest, file);
-      try {
-        if (copyAndVerify(srcFile, destFile)) {
-          copied++;
-        } else {
-          failed++;
-        }
-      } catch {
-        failed++;
-      }
-    }
-    if (failed === 0) {
-      return {
-        name: "tasks/history/",
-        status: "success",
-        detail: `copied ${copied} files to ${dest} \u2014 sources left in place (delete manually when ready)`
-      };
-    }
-    return {
-      name: "tasks/history/",
-      status: "failed",
-      detail: `copied ${copied}/${files.length} files; ${failed} failed`
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { name: "tasks/history/", status: "failed", detail: msg };
-  }
-}
-function migrateLockfile(ctx) {
-  const src = path8.join(ctx.paths.configDir, "akm.lock");
-  const dest = path8.join(ctx.paths.dataDir, "akm.lock");
-  if (!fs10.existsSync(src)) {
-    return { name: "akm.lock", status: "skipped", detail: "source not found" };
-  }
-  if (fs10.existsSync(dest)) {
-    return { name: "akm.lock", status: "skipped", detail: "destination already exists" };
-  }
-  if (ctx.dryRun) {
-    return { name: "akm.lock", status: "success", detail: `[dry-run] would copy ${src} \u2192 ${dest}` };
-  }
-  ensureDir(ctx.paths.dataDir);
-  const ok = copyAndVerify(src, dest);
-  if (ok) {
-    return {
-      name: "akm.lock",
-      status: "success",
-      detail: `copied to ${dest} \u2014 source left at ${src}.
-      IMPORTANT: akm now reads ONLY from $DATA/akm.lock. If this step is skipped,
-      akm will start with an empty lockfile and 'akm add' will rebuild it from scratch.`
-    };
-  }
-  return { name: "akm.lock", status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
-}
-function migrateConfigBackups(ctx) {
-  const src = path8.join(ctx.paths.cacheDir, "config-backups");
-  const dest = path8.join(ctx.paths.dataDir, "config-backups");
-  if (!fs10.existsSync(src)) {
-    return { name: "config-backups/", status: "skipped", detail: "source directory not found" };
-  }
-  if (fs10.existsSync(dest)) {
-    return { name: "config-backups/", status: "skipped", detail: "destination already exists" };
-  }
-  if (ctx.dryRun) {
-    let srcCount = 0;
-    try {
-      srcCount = countFilesRecursive(src);
-    } catch {}
-    return {
-      name: "config-backups/",
-      status: "success",
-      detail: `[dry-run] would recursively copy ${srcCount} file(s) from ${src} \u2192 ${dest}`
-    };
-  }
-  try {
-    const srcCount = countFilesRecursive(src);
-    const { copied, failed } = copyTree(src, dest, { clobber: true });
-    const destCount = fs10.existsSync(dest) ? countFilesRecursive(dest) : 0;
-    if (failed === 0 && destCount === srcCount) {
-      return {
-        name: "config-backups/",
-        status: "success",
-        detail: `copied ${copied} files to ${dest} \u2014 sources left in place (delete manually when ready)`
-      };
-    }
-    return {
-      name: "config-backups/",
-      status: "failed",
-      detail: `file count mismatch: source ${srcCount}, destination ${destCount}; ${failed} copy errors`
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { name: "config-backups/", status: "failed", detail: msg };
-  }
-}
-async function migrateTaskHistoryToDb(ctx) {
-  const src = path8.join(ctx.paths.cacheDir, "tasks", "history");
-  if (!fs10.existsSync(src)) {
-    return { name: "tasks/history/ \u2192 state.db", status: "skipped", detail: "source directory not found" };
-  }
-  const files = fs10.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
-  if (files.length === 0) {
-    return {
-      name: "tasks/history/ \u2192 state.db",
-      status: "skipped",
-      detail: "no *.jsonl files found in source directory"
-    };
-  }
-  if (ctx.dryRun) {
-    return {
-      name: "tasks/history/ \u2192 state.db",
-      status: "success",
-      detail: `[dry-run] would parse ${files.length} *.jsonl file(s) and import rows into ${ctx.paths.stateDbPath}`
-    };
-  }
-  try {
-    ensureDir(ctx.paths.dataDir);
-    const { openStateDatabase: openStateDatabase2 } = await Promise.resolve().then(() => (init_state_db(), exports_state_db));
-    const { upsertTaskHistory: upsertTaskHistory2 } = await Promise.resolve().then(() => exports_task_history_repository);
-    const db = openStateDatabase2(ctx.paths.stateDbPath);
-    let imported = 0;
-    let failed = 0;
-    try {
-      for (const file of files) {
-        const filePath = path8.join(src, file);
-        const text = fs10.readFileSync(filePath, "utf8");
-        const lines = text.split(`
-`).filter((l) => l.trim().length > 0);
-        db.exec("BEGIN");
-        let fileImported = 0;
-        try {
-          for (const line of lines) {
-            try {
-              const row = JSON.parse(line);
-              const meta = { durationMs: row.durationMs };
-              if (row.detail !== undefined)
-                meta.detail = row.detail;
-              if (row.target?.kind === "prompt" && row.target.profile !== undefined) {
-                meta.profile = row.target.profile;
-              }
-              upsertTaskHistory2(db, {
-                task_id: row.id,
-                status: row.status,
-                started_at: row.startedAt,
-                completed_at: row.status !== "failed" ? row.finishedAt : null,
-                failed_at: row.status === "failed" ? row.finishedAt : null,
-                log_path: row.log || null,
-                target_kind: row.target?.kind ?? null,
-                target_ref: row.target?.kind === "workflow" ? row.target.ref ?? null : null,
-                metadata_json: JSON.stringify(meta)
-              });
-              fileImported++;
-            } catch {
-              failed++;
-            }
-          }
-          db.exec("COMMIT");
-          imported += fileImported;
-        } catch (err) {
-          db.exec("ROLLBACK");
-          throw err;
-        }
-      }
-    } finally {
-      db.close();
-    }
-    if (failed === 0) {
-      return {
-        name: "tasks/history/ \u2192 state.db",
-        status: "success",
-        detail: `imported ${imported} task history row(s) from ${files.length} JSONL file(s) into state.db \u2014 sources left in place (delete manually when ready)`
-      };
-    }
-    return {
-      name: "tasks/history/ \u2192 state.db",
-      status: "failed",
-      detail: `imported ${imported} row(s); ${failed} line(s) could not be parsed`
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { name: "tasks/history/ \u2192 state.db", status: "failed", detail: msg };
-  }
-}
-function noteRegistryIndexCache(ctx) {
-  const src = path8.join(ctx.paths.cacheDir, "registry-index");
-  if (!fs10.existsSync(src)) {
-    return {
-      name: "registry-index/ (note)",
-      status: "skipped",
-      detail: "no old $CACHE/registry-index/ directory found"
-    };
-  }
-  const legacyFiles = fs10.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" };
-  }
-  if (!ctx.dryRun) {
-    console.log(`
-  Note: found ${legacyFiles.length} old registry-index JSON file(s) in ${src}.` + `
-        These are ignored in v0.9 \u2014 data is now stored in the registry_index_cache` + `
-        table in $DATA/index.db and will be rebuilt on next 'akm registry search'.
-        You may safely delete these files after migration:
-` + legacyFiles.map((f) => `          ${path8.join(src, f)}`).join(`
-`));
-  }
-  return {
-    name: "registry-index/ (note)",
-    status: "success",
-    detail: `${legacyFiles.length} old file(s) noted at ${src} \u2014 registry index cache will be rebuilt on next ` + `'akm registry search'. Safe to delete: ${src}/*.json`
-  };
-}
-var v07To08Migration = {
-  label: "0.7 \u2192 0.8",
-  sourceVersion: "0.7",
-  isNeeded: (paths) => {
-    const candidates = [
-      path8.join(paths.cacheDir, "index.db"),
-      path8.join(paths.cacheDir, "workflow.db"),
-      path8.join(paths.cacheDir, "events.jsonl"),
-      path8.join(paths.cacheDir, "tasks", "history"),
-      path8.join(paths.configDir, "akm.lock"),
-      path8.join(paths.cacheDir, "config-backups"),
-      path8.join(paths.cacheDir, "registry-index")
-    ];
-    return candidates.some((p) => fs10.existsSync(p));
-  },
-  steps: [
-    { id: "index-db", title: "index.db", run: (ctx) => migrateDb(ctx, "index.db") },
-    { id: "workflow-db", title: "workflow.db", run: (ctx) => migrateDb(ctx, "workflow.db") },
-    { id: "events-jsonl", title: "events.jsonl \u2192 state.db", run: migrateEventsJsonl },
-    { id: "tasks-history-files", title: "tasks/history/", run: migrateTaskHistory },
-    { id: "lockfile", title: "akm.lock", run: migrateLockfile },
-    { id: "config-backups", title: "config-backups/", run: migrateConfigBackups },
-    { id: "tasks-history-db", title: "tasks/history/ \u2192 state.db", run: migrateTaskHistoryToDb },
-    { id: "registry-index-note", title: "registry-index/ (note)", run: noteRegistryIndexCache }
-  ]
-};
-function legacyGraphCandidatePaths(ctx) {
-  return [
-    path8.join(ctx.paths.cacheDir, "graph-snapshot.json"),
-    path8.join(ctx.paths.dataDir, "graph-snapshot.json"),
-    path8.join(ctx.paths.dataDir, "graph-export.json")
-  ];
-}
-function findLegacyGraphFile(ctx) {
-  for (const candidate of legacyGraphCandidatePaths(ctx)) {
-    if (fs10.existsSync(candidate) && fs10.statSync(candidate).isFile())
-      return candidate;
-  }
-  const graphDir = path8.join(ctx.paths.cacheDir, "graph");
-  if (fs10.existsSync(graphDir) && fs10.statSync(graphDir).isDirectory()) {
-    try {
-      const json = fs10.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path8.join(graphDir, f));
-      const [first] = json;
-      if (first)
-        return first;
-    } catch {}
-  }
-  return null;
-}
-function validateGraphSnapshot(parsed) {
-  if (parsed == null || typeof parsed !== "object")
-    return { ok: false, reason: "root is not an object" };
-  const obj = parsed;
-  if (typeof obj.stashRoot !== "string" || obj.stashRoot.length === 0) {
-    return { ok: false, reason: "missing string field 'stashRoot'" };
-  }
-  if (!Array.isArray(obj.files))
-    return { ok: false, reason: "missing array field 'files'" };
-  for (const [i, f] of obj.files.entries()) {
-    if (!f || typeof f !== "object")
-      return { ok: false, reason: `files[${i}] is not an object` };
-    if (typeof f.path !== "string")
-      return { ok: false, reason: `files[${i}].path must be a string` };
-    if (typeof f.type !== "string")
-      return { ok: false, reason: `files[${i}].type must be a string` };
-    if (!Array.isArray(f.entities))
-      return { ok: false, reason: `files[${i}].entities must be an array` };
-    if (!Array.isArray(f.relations))
-      return { ok: false, reason: `files[${i}].relations must be an array` };
-  }
-  return { ok: true, data: obj };
-}
-async function migrateGraphFileToDb(ctx) {
-  const name = "Graph snapshot import";
-  const legacyFile = findLegacyGraphFile(ctx);
-  if (!legacyFile) {
-    return { name, status: "skipped", detail: "no legacy graph file found" };
-  }
-  if (!fs10.existsSync(ctx.paths.indexDbPath)) {
-    return {
-      name,
-      status: "skipped",
-      detail: `index.db not found at ${ctx.paths.indexDbPath}; run akm to initialize, then re-run this migration`
-    };
-  }
-  if (ctx.dryRun) {
-    return {
-      name,
-      status: "success",
-      detail: `[dry-run] would parse ${legacyFile} and import into ${ctx.paths.indexDbPath} graph tables`
-    };
-  }
-  try {
-    const raw = fs10.readFileSync(legacyFile, "utf8");
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { name, status: "failed", detail: `${legacyFile} is not valid JSON: ${msg}` };
-    }
-    const validation = validateGraphSnapshot(parsed);
-    if (!validation.ok) {
-      return {
-        name,
-        status: "failed",
-        detail: `${legacyFile} does not match expected GraphSnapshot shape: ${validation.reason}`
-      };
-    }
-    const snapshot = validation.data;
-    const stashRoot = snapshot.stashRoot;
-    const { openExistingDatabase: openExistingDatabase3, closeDatabase: closeDatabase3 } = await Promise.resolve().then(() => (init_index_connection(), exports_index_connection));
-    const { replaceStoredGraph: replaceStoredGraph2, loadStoredGraphMeta: loadStoredGraphMeta2 } = await Promise.resolve().then(() => (init_graph_db(), exports_graph_db));
-    const db = openExistingDatabase3(ctx.paths.indexDbPath);
-    try {
-      const graph = {
-        schemaVersion: snapshot.schemaVersion ?? 2,
-        generatedAt: snapshot.generatedAt ?? new Date().toISOString(),
-        stashRoot,
-        files: (snapshot.files ?? []).map((f) => ({
-          path: f.path,
-          type: f.type,
-          ...f.bodyHash ? { bodyHash: f.bodyHash } : {},
-          entities: f.entities ?? [],
-          relations: (f.relations ?? []).map((r) => ({
-            from: r.from,
-            to: r.to,
-            ...r.type ? { type: r.type } : {},
-            ...typeof r.confidence === "number" ? { confidence: r.confidence } : {}
-          })),
-          ...typeof f.confidence === "number" ? { confidence: f.confidence } : {}
-        })),
-        ...snapshot.entities ? { entities: snapshot.entities } : {},
-        ...snapshot.relations ? {
-          relations: snapshot.relations.map((r) => ({
-            from: r.from,
-            to: r.to,
-            ...r.type ? { type: r.type } : {},
-            ...typeof r.confidence === "number" ? { confidence: r.confidence } : {}
-          }))
-        } : {},
-        ...snapshot.quality ? {
-          quality: {
-            consideredFiles: snapshot.quality.consideredFiles ?? 0,
-            extractedFiles: snapshot.quality.extractedFiles ?? 0,
-            entityCount: snapshot.quality.entityCount ?? 0,
-            relationCount: snapshot.quality.relationCount ?? 0,
-            extractionCoverage: snapshot.quality.extractionCoverage ?? 0,
-            density: snapshot.quality.density ?? 0
-          }
-        } : {}
-      };
-      replaceStoredGraph2(db, graph);
-      const importedCount = db.prepare("SELECT COUNT(*) AS cnt FROM graph_files WHERE stash_root = ?").get(stashRoot).cnt;
-      const meta = loadStoredGraphMeta2(stashRoot, db);
-      if (!meta) {
-        return {
-          name,
-          status: "failed",
-          detail: `import did not produce a graph_meta row for stash ${snapshot.stashRoot}`
-        };
-      }
-      if (importedCount === 0) {
-        return {
-          name,
-          status: "failed",
-          detail: `import produced zero graph_files rows for stash ${snapshot.stashRoot} \u2014 ` + `the entries table has no matching paths. Run "akm index" first, then retry the migration. Source file ${legacyFile} was NOT renamed.`
-        };
-      }
-      const renamed = `${legacyFile}.migrated`;
-      try {
-        fs10.renameSync(legacyFile, renamed);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          name,
-          status: "success",
-          detail: `imported graph for ${snapshot.stashRoot} into ${ctx.paths.indexDbPath} but could not rename ${legacyFile}: ${msg}`
-        };
-      }
-      return {
-        name,
-        status: "success",
-        detail: `imported graph snapshot from ${legacyFile} into ${ctx.paths.indexDbPath} (stash ${snapshot.stashRoot}; ${importedCount} file(s) imported of ${graph.files.length} in source). Source renamed to ${renamed} \u2014 delete manually when ready.`
-      };
-    } finally {
-      closeDatabase3(db);
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { name, status: "failed", detail: msg };
-  }
-}
-function resolvePrimaryStashDir(configDirPath) {
-  try {
-    const cfgPath = path8.join(configDirPath, "config.json");
-    if (fs10.existsSync(cfgPath)) {
-      const cfg = JSON.parse(fs10.readFileSync(cfgPath, "utf8"));
-      if (typeof cfg.stashDir === "string" && cfg.stashDir.length > 0)
-        return cfg.stashDir;
-    }
-  } catch {}
-  return getDefaultStashDir();
-}
-function countEnvFilesRecursive(dir) {
-  let count = 0;
-  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
-    const full = path8.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      count += countEnvFilesRecursive(full);
-    } else if (entry.name === ".env" || entry.name.endsWith(".env")) {
-      count++;
-    }
-  }
-  return count;
-}
-function chmodTreeSecure(dir) {
-  const isWin = process.platform === "win32";
-  try {
-    fs10.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 fs10.readdirSync(dir, { withFileTypes: true })) {
-    const full = path8.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const sub = chmodTreeSecure(full);
-      if (!sub.ok)
-        return sub;
-      continue;
-    }
-    try {
-      fs10.chmodSync(full, 384);
-      if (!isWin && (fs10.statSync(full).mode & 511) !== 384) {
-        return { ok: false, detail: `mode verification failed for ${full}` };
-      }
-    } catch (err) {
-      if (!isWin)
-        return { ok: false, detail: `chmod 0600 ${full} failed: ${err instanceof Error ? err.message : err}` };
-    }
-  }
-  return { ok: true };
-}
-async function migrateVaultsToEnv(ctx) {
-  const name = "vaults/ \u2192 env/";
-  const stashDir = resolvePrimaryStashDir(ctx.paths.configDir);
-  const vaultsDir = path8.join(stashDir, "vaults");
-  const envDir = path8.join(stashDir, "env");
-  const marker = path8.join(vaultsDir, MIGRATED_MARKER);
-  if (!fs10.existsSync(vaultsDir)) {
-    return { name, status: "skipped", detail: `no vaults/ directory under ${stashDir}` };
-  }
-  if (fs10.existsSync(marker)) {
-    return { name, status: "skipped", detail: "already migrated (.migrated marker present)" };
-  }
-  const vaultEnvCount = countEnvFilesRecursive(vaultsDir);
-  if (vaultEnvCount === 0) {
-    return { name, status: "skipped", detail: "vaults/ has no .env files to migrate" };
-  }
-  if (ctx.dryRun) {
-    return {
-      name,
-      status: "success",
-      detail: `[dry-run] would copy ${vaultEnvCount} .env file(s) ${vaultsDir} \u2192 ${envDir}, chmod 0600/0700, and write ${marker}`
-    };
-  }
-  try {
-    const { copied, skipped, failed } = copyTree(vaultsDir, envDir, { clobber: false });
-    if (failed > 0) {
-      return { name, status: "failed", detail: `${failed} file(s) failed to copy; env/ left as-is, no marker written` };
-    }
-    const chmodRes = chmodTreeSecure(envDir);
-    if (!chmodRes.ok) {
-      return { name, status: "failed", detail: chmodRes.detail ?? "permission tightening failed" };
-    }
-    const envEnvCount = countEnvFilesRecursive(envDir);
-    if (envEnvCount < vaultEnvCount) {
-      return {
-        name,
-        status: "failed",
-        detail: `post-copy count ${envEnvCount} < source ${vaultEnvCount}; no marker written`
-      };
-    }
-    fs10.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
-`, { mode: 384 });
-    return {
-      name,
-      status: "success",
-      detail: `copied ${copied} file(s) (${skipped} already present in env/, preserved) ${vaultsDir} \u2192 ${envDir}; vaults/ left intact as a frozen copy. Run \`akm index\` to refresh search.`
-    };
-  } catch (err) {
-    return { name, status: "failed", detail: err instanceof Error ? err.message : String(err) };
-  }
-}
-var v08To09Migration = {
-  label: "0.8 \u2192 0.9",
-  sourceVersion: "0.8",
-  isNeeded: (_paths) => {
-    return true;
-  },
-  steps: [
-    { id: "graph-snapshot-import", title: "Graph snapshot import", run: migrateGraphFileToDb },
-    { id: "vaults-to-env", title: "vaults/ \u2192 env/", run: migrateVaultsToEnv }
-  ]
-};
-var MIGRATIONS = [v07To08Migration, v08To09Migration];
-async function confirm() {
-  if (YES)
-    return true;
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question("Proceed with migration? [y/N] ", (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
-  });
-}
-function printList() {
-  console.log("akm storage migrations (in execution order):");
-  for (const m of MIGRATIONS) {
-    console.log(`  \u2022 ${m.label}    [sourceVersion=${m.sourceVersion}]`);
-  }
-  console.log();
-  console.log("Resolved paths:");
-  console.log(`  $CACHE  = ${cacheDir}`);
-  console.log(`  $CONFIG = ${configDir}`);
-  console.log(`  $DATA   = ${dataDir}`);
-  console.log(`  $STATE  = ${stateDir}`);
-}
-function compareVersion(a, b) {
-  const parse = (v) => v.replace(/^v/, "").split(".").map((p) => Number.parseInt(p, 10)).map((n) => Number.isFinite(n) ? n : 0);
-  const aa = parse(a);
-  const bb = parse(b);
-  const len = Math.max(aa.length, bb.length);
-  for (let i = 0;i < len; i++) {
-    const diff = (aa[i] ?? 0) - (bb[i] ?? 0);
-    if (diff !== 0)
-      return diff;
-  }
-  return 0;
-}
-function filteredMigrations() {
-  if (!FROM_VERSION)
-    return MIGRATIONS;
-  return MIGRATIONS.filter((m) => compareVersion(m.sourceVersion, FROM_VERSION) >= 0);
-}
-function printGroupedSummary() {
-  console.log(`
-akm storage migration \u2014 RESULTS`);
-  console.log("================================");
-  let totalFailures = 0;
-  for (const report of versionReports) {
-    console.log(`
-=== Migration: ${report.label} ===`);
-    if (!report.ran) {
-      console.log(`  (not run \u2014 ${report.skipReason ?? "isNeeded returned false"})`);
-      continue;
-    }
-    if (report.results.length === 0) {
-      console.log("  (no steps recorded)");
-      continue;
-    }
-    for (const r of report.results) {
-      const glyph = r.status === "success" ? "\u2713" : r.status === "skipped" ? "\u2298" : "\u2717";
-      console.log(`  ${glyph} ${r.name}${r.status === "skipped" ? ` \u2014 ${r.detail}` : ""}`);
-      if (r.status !== "skipped") {
-        console.log(`      ${r.detail}`);
-      }
-      if (r.status === "failed")
-        totalFailures += 1;
-    }
-  }
-  if (totalFailures > 0) {
-    console.log(`
-${totalFailures} step(s) failed.`);
-    process.exitCode = 1;
-    console.log(`
-Migration did NOT fully complete. DO NOT delete any legacy files yet.
-Re-run \`akm-migrate-storage --yes\` after addressing the failure(s) above.
-The migration is idempotent \u2014 successful steps are skipped on re-run via
-their dedup keys (events: (event_type, ts, ref, metadata_json);
-task_history: task_id PK).
-`);
-    return;
-  }
-  console.log(`
-Migration complete. No errors.`);
-  console.log(`
-Old files at the original locations are safe to delete manually after verifying akm works:
-  ${path8.join(cacheDir, "index.db")}
-  ${path8.join(cacheDir, "workflow.db")}
-  ${path8.join(cacheDir, "events.jsonl")}
-  ${path8.join(cacheDir, "tasks", "history")}
-  ${path8.join(cacheDir, "config-backups")}
-  ${path8.join(configDir, "akm.lock")}
-
-Next step \u2014 repopulate graph data (if migrating from 0.7):
-  The 0.8.0 graph schema redesign (DB_VERSION 12 \u2192 13) rebuilds the graph
-  tables in index.db. Non-graph tables regenerate automatically on first
-  open, but graph extraction requires LLM calls. Run:
-    akm improve
-  once after migration so graph-backed features (akm graph related/entity,
-  graph-boosted search ranking) have data to work with. See
-  docs/migration/v0.7-to-v0.8.md#graph-extraction-will-re-run-after-upgrade.
-`);
-}
-async function runMigrations3(opts = { dryRun: DRY_RUN }) {
-  const paths = opts.paths ?? PATHS;
-  const reports = [];
-  const migrations = filteredMigrations();
-  for (const migration of migrations) {
-    const stepResults = [];
-    const ctx = {
-      dryRun: opts.dryRun,
-      recordStep: (r) => stepResults.push(r),
-      paths
-    };
-    let needed = false;
-    try {
-      needed = await migration.isNeeded(paths);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      reports.push({
-        label: migration.label,
-        ran: false,
-        skipReason: `isNeeded() threw: ${msg}`,
-        results: []
-      });
-      continue;
-    }
-    if (!needed) {
-      reports.push({ label: migration.label, ran: false, skipReason: "isNeeded() returned false", results: [] });
-      continue;
-    }
-    try {
-      await runSteps(migration.steps, ctx);
-      reports.push({ label: migration.label, ran: true, results: stepResults });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      stepResults.push({ name: "(migration aborted)", status: "failed", detail: msg });
-      reports.push({ label: migration.label, ran: true, results: stepResults });
-    }
-  }
-  return reports;
-}
-async function main() {
-  if (LIST_ONLY) {
-    printList();
-    return;
-  }
-  console.log("akm storage migration");
-  console.log("=====================");
-  console.log(`  $CACHE  = ${cacheDir}`);
-  console.log(`  $CONFIG = ${configDir}`);
-  console.log(`  $DATA   = ${dataDir}`);
-  console.log(`  $STATE  = ${stateDir}`);
-  console.log();
-  console.log("Planned migrations (after --from filter):");
-  for (const m of filteredMigrations()) {
-    console.log(`  \u2022 ${m.label}`);
-  }
-  if (FROM_VERSION)
-    console.log(`  (filtered: --from ${FROM_VERSION})`);
-  console.log();
-  if (!DRY_RUN) {
-    const proceed = await confirm();
-    if (!proceed) {
-      console.log("Aborted. No changes made.");
-      return;
-    }
-  } else {
-    console.log(`[dry-run] No changes will be written.
-`);
-  }
-  const reports = await runMigrations3({ dryRun: DRY_RUN, paths: PATHS });
-  versionReports.push(...reports);
-  printGroupedSummary();
-  if (DRY_RUN) {
-    console.log("Dry run complete. No changes made.");
-  }
-}
-var invokedDirectly = (() => {
-  try {
-    const entry = process.argv[1];
-    if (!entry)
-      return false;
-    const here = new URL(import.meta.url).pathname;
-    return path8.resolve(entry) === here;
-  } catch {
-    return false;
-  }
-})();
-if (invokedDirectly) {
-  await main();
-}
-export {
-  runMigrations3 as runMigrations,
-  main,
-  MIGRATIONS
-};