akm-cli 0.8.6 → 0.8.14

package/dist/scripts/migrate-storage.js

@@ -384,7 +384,73 @@ var require_main = __commonJS((exports, module) => {
   module.exports = DotenvModule;
 });
 
-// src/commands/env.ts
+// 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, USAGE_HINTS, AkmError, ConfigError, UsageError;
+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 `akm config set profiles.llm.default \'{"endpoint":"...","model":"..."}\' to configure an LLM profile.',
+    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/ \u2014 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."
+  };
+  USAGE_HINTS = {
+    INVALID_FLAG_VALUE: "Run `akm <command> --help` to see accepted values.",
+    INVALID_SOURCE_VALUE: "Pick one of: stash, registry, both.",
+    INVALID_FORMAT_VALUE: "Pick one of: json, jsonl, text, yaml.",
+    INVALID_DETAIL_VALUE: "Pick one of: brief, normal, full. For agent/summary projections use --shape.",
+    INVALID_SHAPE_VALUE: "Pick one of: human, agent, summary (summary is only valid on `akm show`).",
+    INVALID_JSON_CONFIG_VALUE: `Quote JSON values in your shell, for example: akm config set embedding '{"endpoint":"http://localhost:11434/v1/embeddings","model":"nomic-embed-text"}'.`,
+    MISSING_OR_AMBIGUOUS_TARGET: "Use `akm update --all` or pass a target like `akm update npm:@scope/pkg` (not both).",
+    TARGET_NOT_UPDATABLE: "Run `akm list` to view your sources, then retry with one of those values.",
+    MISSING_REQUIRED_ARGUMENT: "Refs use the form type:name, e.g. `akm show skill:deploy` or `akm show knowledge:guide.md`."
+  };
+  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];
+    }
+  };
+  UsageError = class UsageError extends AkmError {
+    kind = "usage";
+    code;
+    _hint;
+    constructor(msg, code = "INVALID_FLAG_VALUE", hint) {
+      super(msg);
+      this.name = "UsageError";
+      this.code = code;
+      this._hint = hint;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+    hint() {
+      return this._hint ?? USAGE_HINTS[this.code];
+    }
+  };
+});
+
+// src/commands/env/env.ts
 import fs from "fs";
 function scanKeys(text) {
   const keys = [];
@@ -420,11 +486,12 @@ function listKeys(envPath) {
 var import_dotenv, ASSIGN_RE;
 var init_env = __esm(() => {
   init_common();
+  init_errors();
   import_dotenv = __toESM(require_main(), 1);
   ASSIGN_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
 });
 
-// src/core/frontmatter.ts
+// src/core/asset/frontmatter.ts
 function parseFrontmatter(raw) {
   const parsedBlock = parseFrontmatterBlock(raw);
   if (!parsedBlock) {
@@ -572,7 +639,7 @@ function parseYamlScalar(value) {
   return value;
 }
 
-// src/core/markdown.ts
+// src/core/asset/markdown.ts
 function parseMarkdownToc(content) {
   const lines = content.split(/\r?\n/);
   const headings = [];
@@ -592,15 +659,16 @@ function parseMarkdownToc(content) {
 }
 var init_markdown = () => {};
 
-// src/indexer/file-context.ts
-var renderers;
-var init_file_context = __esm(() => {
-  init_common();
-  renderers = new Map;
-});
-
 // src/core/warn.ts
 import fs2 from "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;
@@ -628,10 +696,22 @@ function error(...args) {
     console.error(...args);
   }
 }
-var quiet = false, logFilePath;
+function warnVerbose(...args) {
+  if (isVerbose()) {
+    warn(...args);
+  }
+}
+var quiet = false, verbose = false, logFilePath;
 var init_warn = () => {};
 
-// src/indexer/metadata-contributors.ts
+// src/indexer/walk/file-context.ts
+var renderers;
+var init_file_context = __esm(() => {
+  init_common();
+  renderers = new Map;
+});
+
+// src/indexer/passes/metadata-contributors.ts
 function registerMetadataContributor(contributor) {
   contributors.push(contributor);
 }
@@ -640,7 +720,7 @@ var init_metadata_contributors = __esm(() => {
   contributors = [];
 });
 
-// src/indexer/metadata.ts
+// src/indexer/passes/metadata.ts
 import fs3 from "fs";
 function extractDescriptionFromComments(filePath) {
   let content;
@@ -692,69 +772,7 @@ var init_metadata = __esm(() => {
   WIKI_INFRA_FILES = new Set(["schema.md", "index.md", "log.md"]);
 });
 
-// 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, USAGE_HINTS, ConfigError, UsageError;
-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 `akm config set profiles.llm.default \'{"endpoint":"...","model":"..."}\' to configure an LLM profile.',
-    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/ \u2014 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."
-  };
-  USAGE_HINTS = {
-    INVALID_FLAG_VALUE: "Run `akm <command> --help` to see accepted values.",
-    INVALID_SOURCE_VALUE: "Pick one of: stash, registry, both.",
-    INVALID_FORMAT_VALUE: "Pick one of: json, jsonl, text, yaml.",
-    INVALID_DETAIL_VALUE: "Pick one of: brief, normal, full. For agent/summary projections use --shape.",
-    INVALID_SHAPE_VALUE: "Pick one of: human, agent, summary (summary is only valid on `akm show`).",
-    INVALID_JSON_CONFIG_VALUE: `Quote JSON values in your shell, for example: akm config set embedding '{"endpoint":"http://localhost:11434/v1/embeddings","model":"nomic-embed-text"}'.`,
-    MISSING_OR_AMBIGUOUS_TARGET: "Use `akm update --all` or pass a target like `akm update npm:@scope/pkg` (not both).",
-    TARGET_NOT_UPDATABLE: "Run `akm list` to view your sources, then retry with one of those values.",
-    MISSING_REQUIRED_ARGUMENT: "Refs use the form type:name, e.g. `akm show skill:deploy` or `akm show knowledge:guide.md`."
-  };
-  ConfigError = class ConfigError extends Error {
-    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];
-    }
-  };
-  UsageError = class UsageError extends Error {
-    code;
-    _hint;
-    constructor(msg, code = "INVALID_FLAG_VALUE", hint) {
-      super(msg);
-      this.name = "UsageError";
-      this.code = code;
-      this._hint = hint;
-      Object.setPrototypeOf(this, new.target.prototype);
-    }
-    hint() {
-      return this._hint ?? USAGE_HINTS[this.code];
-    }
-  };
-});
-
-// src/core/asset-ref.ts
+// src/core/asset/asset-ref.ts
 import path from "path";
 function parseAssetRef(ref) {
   const trimmed = ref.trim();
@@ -775,6 +793,9 @@ function parseAssetRef(ref) {
   }
   const rawType = body.slice(0, colon);
   const rawName = body.slice(colon + 1);
+  if (rawType === "vault") {
+    throw new UsageError("The `vault` asset type was removed in 0.9.0 \u2014 use `env:` (whole .env config) or `secret:` (a single value).", "MISSING_REQUIRED_ARGUMENT");
+  }
   const resolvedType = TYPE_ALIASES[rawType] ?? rawType;
   if (!isAssetType(resolvedType)) {
     throw new UsageError(`Invalid asset type: "${rawType}".`, "MISSING_REQUIRED_ARGUMENT");
@@ -813,15 +834,6 @@ var init_asset_ref = __esm(() => {
   };
 });
 
-// src/workflows/document-cache.ts
-function cacheWorkflowDocument(entry, doc) {
-  cache.set(entry, doc);
-}
-var cache;
-var init_document_cache = __esm(() => {
-  cache = new WeakMap;
-});
-
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {
   var ALIAS = Symbol.for("yaml.alias");
@@ -8192,6 +8204,15 @@ var init_parser = __esm(() => {
   BULLET_LINE = /^[-*]\s+(.+)$/;
 });
 
+// src/workflows/runtime/document-cache.ts
+function cacheWorkflowDocument(entry, doc) {
+  cache.set(entry, doc);
+}
+var cache;
+var init_document_cache = __esm(() => {
+  cache = new WeakMap;
+});
+
 // src/workflows/renderer.ts
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -8212,8 +8233,8 @@ var init_renderer = __esm(() => {
   init_asset_ref();
   init_errors();
   init_metadata_contributors();
-  init_document_cache();
   init_parser();
+  init_document_cache();
   registerMetadataContributor({
     name: "workflow-document-metadata",
     appliesTo: ({ rendererName }) => rendererName === "workflow-md",
@@ -8242,6 +8263,24 @@ var init_renderer = __esm(() => {
 });
 
 // src/output/renderers.ts
+function applySessionMetadata(entry, ctx) {
+  try {
+    const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
+    entry.tags = Array.from(new Set([...entry.tags ?? [], "session"]));
+    const hints = new Set(entry.searchHints ?? []);
+    const harness = asNonEmptyString(fm.harness);
+    if (harness)
+      hints.add(`harness:${harness}`);
+    const project = asNonEmptyString(fm.project);
+    if (project)
+      hints.add(`project:${project}`);
+    const logPath = asNonEmptyString(fm.log_path);
+    if (logPath)
+      hints.add(`log_path:${logPath}`);
+    if (hints.size > 0)
+      entry.searchHints = Array.from(hints).filter(Boolean);
+  } catch {}
+}
 function applyTocMetadata(entry, ctx) {
   try {
     const toc = parseMarkdownToc(ctx.content());
@@ -8313,18 +8352,6 @@ function applyScriptMetadata(entry, ctx) {
     entry.confidence = 0.7;
   }
 }
-function applyVaultMetadata(entry, ctx) {
-  const { keys, comments } = listKeys(ctx.absPath);
-  if (comments.length > 0 && !entry.description) {
-    entry.description = comments.join(" ").slice(0, 500);
-    entry.source = "comments";
-    entry.confidence = 0.7;
-  }
-  if (keys.length > 0) {
-    entry.searchHints = keys;
-  }
-  entry.tags = Array.from(new Set([...entry.tags ?? [], "vault", "secrets"]));
-}
 function applyEnvMetadata(entry, ctx) {
   const { keys, comments } = listKeys(ctx.absPath);
   if (comments.length > 0 && !entry.description) {
@@ -8360,11 +8387,11 @@ function applyTaskMetadata(entry, ctx) {
 }
 var init_renderers = __esm(() => {
   init_env();
-  init_common();
   init_markdown();
-  init_file_context();
+  init_common();
   init_metadata();
   init_metadata_contributors();
+  init_file_context();
   init_renderer();
   registerMetadataContributor({
     name: "toc-metadata",
@@ -8386,11 +8413,6 @@ var init_renderers = __esm(() => {
     appliesTo: ({ rendererName }) => rendererName === "script-source",
     contribute: (entry, ctx) => applyScriptMetadata(entry, ctx.renderContext)
   });
-  registerMetadataContributor({
-    name: "vault-secret-metadata",
-    appliesTo: ({ rendererName }) => rendererName === "vault-env",
-    contribute: (entry, ctx) => applyVaultMetadata(entry, ctx.renderContext)
-  });
   registerMetadataContributor({
     name: "env-file-metadata",
     appliesTo: ({ rendererName }) => rendererName === "env-file",
@@ -8406,20 +8428,28 @@ var init_renderers = __esm(() => {
     appliesTo: ({ rendererName }) => rendererName === "task-yaml",
     contribute: (entry, ctx) => applyTaskMetadata(entry, ctx.renderContext)
   });
+  registerMetadataContributor({
+    name: "session-md-metadata",
+    appliesTo: ({ rendererName }) => rendererName === "session-md",
+    contribute: (entry, ctx) => applySessionMetadata(entry, ctx.renderContext)
+  });
 });
 
-// src/core/asset-registry.ts
+// src/core/asset/asset-registry.ts
 var init_asset_registry = __esm(() => {
   init_renderers();
 });
 
-// src/core/asset-spec.ts
+// src/core/asset/asset-spec.ts
 import path2 from "path";
+function getAssetTypes() {
+  return Object.keys(ASSET_SPECS_INTERNAL);
+}
 var buildTaskAction = (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`, markdownSpec, SCRIPT_EXTENSIONS, scriptSpec, ASSET_SPECS_INTERNAL, TYPE_DIRS;
 var init_asset_spec = __esm(() => {
   init_renderers();
-  init_asset_registry();
   init_common();
+  init_asset_registry();
   markdownSpec = {
     isRelevantFile: (fileName) => path2.extname(fileName).toLowerCase() === ".md",
     toCanonicalName: (typeRoot, filePath) => {
@@ -8498,27 +8528,6 @@ var init_asset_spec = __esm(() => {
       rendererName: "env-file",
       actionBuilder: (ref) => `akm show ${ref} -> inspect key names; akm env run ${ref} -- <command> -> run with the whole .env injected (values never reach stdout); akm env export ${ref} --out <file> -> write a sourceable script to a file`
     },
-    vault: {
-      stashDir: "vaults",
-      isRelevantFile: (fileName) => fileName === ".env" || fileName.endsWith(".env"),
-      toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix(path2.relative(typeRoot, filePath));
-        const fileName = path2.basename(rel);
-        if (fileName === ".env") {
-          const dir = path2.dirname(rel);
-          return dir === "." || dir === "" ? "default" : `${dir}/default`;
-        }
-        const stripped = rel.endsWith(".env") ? rel.slice(0, -4) : rel;
-        return stripped;
-      },
-      toAssetPath: (typeRoot, name) => {
-        if (name === "default")
-          return path2.join(typeRoot, ".env");
-        return path2.join(typeRoot, name.endsWith(".env") ? name : `${name}.env`);
-      },
-      rendererName: "vault-env",
-      actionBuilder: (ref) => `DEPRECATED (use env): akm show ${ref} -> inspect key names; akm env run ${ref} -- <command> -> run with injected env`
-    },
     secret: {
       stashDir: "secrets",
       isRelevantFile: (fileName) => !fileName.endsWith(".lock") && !fileName.endsWith(".sensitive"),
@@ -8552,6 +8561,12 @@ var init_asset_spec = __esm(() => {
       },
       rendererName: "task-yaml",
       actionBuilder: buildTaskAction
+    },
+    session: {
+      stashDir: "sessions",
+      ...markdownSpec,
+      rendererName: "session-md",
+      actionBuilder: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``
     }
   };
   TYPE_DIRS = Object.fromEntries(Object.entries(ASSET_SPECS_INTERNAL).map(([type, spec]) => [type, spec.stashDir]));
@@ -8568,7 +8583,11 @@ function writeFileAtomic(target, content, mode) {
   const tmp = `${target}.tmp.${process.pid}.${crypto.randomBytes(8).toString("hex")}`;
   const fd = fs4.openSync(tmp, "w", mode ?? 384);
   try {
-    fs4.writeSync(fd, content);
+    if (typeof content === "string") {
+      fs4.writeSync(fd, content);
+    } else {
+      fs4.writeSync(fd, content);
+    }
     try {
       fs4.fdatasyncSync(fd);
     } catch {}
@@ -8607,20 +8626,7 @@ var init_common = __esm(() => {
   init_asset_spec();
   init_errors();
   init_paths();
-  ASSET_TYPES = [
-    "skill",
-    "command",
-    "agent",
-    "knowledge",
-    "workflow",
-    "script",
-    "memory",
-    "env",
-    "vault",
-    "secret",
-    "wiki",
-    "lesson"
-  ];
+  ASSET_TYPES = Object.freeze([...getAssetTypes()]);
   ASSET_TYPE_SET = new Set(ASSET_TYPES);
   IS_WINDOWS = process.platform === "win32";
   DEFAULT_RESPONSE_BYTE_CAP = 10 * 1024 * 1024;
@@ -8760,67 +8766,71 @@ var init_paths = __esm(() => {
   init_errors();
 });
 
-// src/core/state-db.ts
-var exports_state_db = {};
-__export(exports_state_db, {
-  upsertTaskHistory: () => upsertTaskHistory,
-  upsertProposal: () => upsertProposal,
-  upsertExtractedSession: () => upsertExtractedSession,
-  shouldSkipAlreadyExtractedSession: () => shouldSkipAlreadyExtractedSession,
-  runMigrations: () => runMigrations,
-  recordImproveRun: () => recordImproveRun,
-  readStateEvents: () => readStateEvents,
-  queryTaskHistory: () => queryTaskHistory,
-  purgeOldImproveRuns: () => purgeOldImproveRuns,
-  purgeOldEvents: () => purgeOldEvents,
-  proposalToRowValues: () => proposalToRowValues,
-  proposalRowToProposal: () => proposalRowToProposal,
-  openStateDatabase: () => openStateDatabase,
-  listStateProposals: () => listStateProposals,
-  insertEvent: () => insertEvent,
-  importEventsJsonl: () => importEventsJsonl,
-  getTaskHistoryRuns: () => getTaskHistoryRuns,
-  getTaskHistory: () => getTaskHistory,
-  getStateProposal: () => getStateProposal,
-  getStateDbPath: () => getStateDbPath,
-  getExtractedSessionsMap: () => getExtractedSessionsMap,
-  getExtractedSession: () => getExtractedSession,
-  eventRowToEnvelope: () => eventRowToEnvelope,
-  computeImproveRunMetrics: () => computeImproveRunMetrics,
-  REGISTRY_INDEX_CACHE_DDL: () => REGISTRY_INDEX_CACHE_DDL
-});
-import { Database } from "bun:sqlite";
-import fs5 from "fs";
-import path5 from "path";
-function getStateDbPath() {
-  return path5.join(getDataDir(), "state.db");
-}
-function openStateDatabase(dbPath) {
-  const resolvedPath = dbPath ?? getStateDbPath();
-  const dir = path5.dirname(resolvedPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+// src/storage/database.ts
+import { createRequire } from "module";
+function openDatabase(path5, opts) {
+  if (isBun) {
+    return openBunDatabase(path5, opts);
   }
-  const db = new Database(resolvedPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec("PRAGMA busy_timeout = 5000");
-  runMigrations(db);
+  return openNodeDatabase(path5, opts);
+}
+function openBunDatabase(path5, opts) {
+  const { Database: BunDatabase } = loadBunSqlite();
+  const db = opts ? new BunDatabase(path5, bunOptions(opts)) : new BunDatabase(path5);
   return db;
 }
-function ensureMigrationsTable(db) {
-  db.exec(`
+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) {
+    const mod = nodeRequire("better-sqlite3");
+    betterSqlite3Ctor = mod.default ?? mod;
+  }
+  return betterSqlite3Ctor;
+}
+function openNodeDatabase(path5, 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(path5, options) : new BetterSqlite3(path5);
+  return db;
+}
+var isBun, nodeRequire, bunSqliteModule, betterSqlite3Ctor;
+var init_database = __esm(() => {
+  isBun = !!process.versions?.bun;
+  nodeRequire = createRequire(import.meta.url);
+});
+
+// src/storage/engines/sqlite-migrations.ts
+function ensureMigrationsTable(db) {
+  db.exec(`
     CREATE TABLE IF NOT EXISTS schema_migrations (
       id         TEXT    PRIMARY KEY,
       applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
     );
   `);
 }
-function runMigrations(db) {
+function runMigrations(db, migrations, opts) {
   ensureMigrationsTable(db);
+  opts?.bootstrap?.(db);
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const applied = new Set(appliedRows.map((r) => r.id));
-  for (const migration of MIGRATIONS) {
+  for (const migration of migrations) {
     if (applied.has(migration.id))
       continue;
     db.transaction(() => {
@@ -8829,6 +8839,103 @@ function runMigrations(db) {
     })();
   }
 }
+
+// src/core/assert.ts
+function assertNever(x, context) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(x);
+  } catch {
+    serialized = String(x);
+  }
+  if (serialized === undefined) {
+    serialized = String(x);
+  }
+  const where = context ? ` (${context})` : "";
+  throw new Error(`Unexpected value reached assertNever${where}: ${serialized}`);
+}
+
+// src/core/improve-types.ts
+function classifyImproveAction(mode) {
+  switch (mode) {
+    case "reflect":
+    case "distill":
+    case "memory-inference":
+    case "graph-extraction":
+      return "accepted";
+    case "reflect-cooldown":
+    case "reflect-skipped":
+    case "distill-skipped":
+    case "reflect-guard-rejected":
+      return "rejected";
+    case "reflect-failed":
+    case "error":
+      return "error";
+    case "memory-prune":
+      return "noop";
+    default:
+      return assertNever(mode);
+  }
+}
+var init_improve_types = () => {};
+
+// src/core/state-db.ts
+var exports_state_db = {};
+__export(exports_state_db, {
+  upsertTaskHistory: () => upsertTaskHistory,
+  upsertProposal: () => upsertProposal,
+  upsertExtractedSession: () => upsertExtractedSession,
+  shouldSkipAlreadyExtractedSession: () => shouldSkipAlreadyExtractedSession,
+  runMigrations: () => runMigrations2,
+  recordImproveRun: () => recordImproveRun,
+  recordFsProposalsImport: () => recordFsProposalsImport,
+  readStateEvents: () => readStateEvents,
+  queryTaskHistory: () => queryTaskHistory,
+  queryImproveRuns: () => queryImproveRuns,
+  queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
+  purgeOldImproveRuns: () => purgeOldImproveRuns,
+  purgeOldEvents: () => purgeOldEvents,
+  proposalToRowValues: () => proposalToRowValues,
+  proposalRowToProposal: () => proposalRowToProposal,
+  openStateDatabase: () => openStateDatabase,
+  listStateProposals: () => listStateProposals,
+  listStateProposalIdsByPrefix: () => listStateProposalIdsByPrefix,
+  listExistingTableNames: () => listExistingTableNames,
+  insertProposalIfAbsent: () => insertProposalIfAbsent,
+  insertEvent: () => insertEvent,
+  importEventsJsonl: () => importEventsJsonl,
+  hasImportedFsProposals: () => hasImportedFsProposals,
+  getTaskHistoryRuns: () => getTaskHistoryRuns,
+  getTaskHistory: () => getTaskHistory,
+  getStateProposal: () => getStateProposal,
+  getStateDbPath: () => getStateDbPath,
+  getExtractedSessionsMap: () => getExtractedSessionsMap,
+  getExtractedSession: () => getExtractedSession,
+  eventRowToEnvelope: () => eventRowToEnvelope,
+  computeImproveRunMetrics: () => computeImproveRunMetrics,
+  REGISTRY_INDEX_CACHE_DDL: () => REGISTRY_INDEX_CACHE_DDL
+});
+import fs5 from "fs";
+import path5 from "path";
+function getStateDbPath() {
+  return path5.join(getDataDir(), "state.db");
+}
+function openStateDatabase(dbPath) {
+  const resolvedPath = dbPath ?? getStateDbPath();
+  const dir = path5.dirname(resolvedPath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  const db = openDatabase(resolvedPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA busy_timeout = 30000");
+  runMigrations2(db);
+  return db;
+}
+function runMigrations2(db) {
+  runMigrations(db, MIGRATIONS);
+}
 function eventRowToEnvelope(row) {
   let metadata;
   try {
@@ -8869,7 +8976,10 @@ function proposalRowToProposal(row) {
       content: row.content,
       ...frontmatter !== undefined ? { frontmatter } : {}
     },
-    ...meta.review !== undefined ? { review: meta.review } : {}
+    ...meta.review !== undefined ? { review: meta.review } : {},
+    ...typeof meta.confidence === "number" ? { confidence: meta.confidence } : {},
+    ...meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {},
+    ...typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {}
   };
 }
 function proposalToRowValues(proposal, stashDir) {
@@ -8878,6 +8988,12 @@ function proposalToRowValues(proposal, stashDir) {
     metaObj.sourceRun = proposal.sourceRun;
   if (proposal.review !== undefined)
     metaObj.review = proposal.review;
+  if (proposal.confidence !== undefined)
+    metaObj.confidence = proposal.confidence;
+  if (proposal.gateDecision !== undefined)
+    metaObj.gateDecision = proposal.gateDecision;
+  if (proposal.backupContent !== undefined)
+    metaObj.backupContent = proposal.backupContent;
   return {
     id: proposal.id,
     stash_dir: stashDir,
@@ -8971,15 +9087,39 @@ function listStateProposals(db, options = {}) {
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const rows = db.prepare(`SELECT id, stash_dir, ref, status, source, created_at, updated_at,
               content, frontmatter_json, metadata_json
-       FROM proposals ${where} ORDER BY created_at ASC`).all(...params);
+       FROM proposals ${where} ORDER BY created_at ASC, rowid ASC`).all(...params);
   return rows.map(proposalRowToProposal);
 }
-function getStateProposal(db, id) {
-  const row = db.prepare(`SELECT id, stash_dir, ref, status, source, created_at, updated_at,
+function getStateProposal(db, id, stashDir) {
+  const sql = `SELECT id, stash_dir, ref, status, source, created_at, updated_at,
               content, frontmatter_json, metadata_json
-       FROM proposals WHERE id = ?`).get(id);
+       FROM proposals WHERE id = ?${stashDir ? " AND stash_dir = ?" : ""}`;
+  const row = stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id);
   return row ? proposalRowToProposal(row) : undefined;
 }
+function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
+  const escaped = idPrefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+  const rows = db.prepare(`SELECT id FROM proposals
+       WHERE stash_dir = ? AND status = 'pending' AND id LIKE ? ESCAPE '\\'
+       ORDER BY id ASC`).all(stashDir, `${escaped}%`);
+  return rows.map((r) => r.id);
+}
+function hasImportedFsProposals(db, stashDir) {
+  return Boolean(db.prepare("SELECT 1 FROM proposal_fs_imports WHERE stash_dir = ?").get(stashDir));
+}
+function recordFsProposalsImport(db, stashDir, importedCount) {
+  db.prepare("INSERT OR REPLACE INTO proposal_fs_imports (stash_dir, imported_at, imported_count) VALUES (?, ?, ?)").run(stashDir, new Date().toISOString(), importedCount);
+}
+function insertProposalIfAbsent(db, proposal, stashDir) {
+  const v = proposalToRowValues(proposal, stashDir);
+  const result = db.prepare(`
+      INSERT OR IGNORE INTO proposals
+        (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
+  const changes = result.changes ?? 0;
+  return Number(changes) > 0;
+}
 function upsertTaskHistory(db, row) {
   db.prepare(`
     INSERT OR IGNORE INTO task_history
@@ -9026,6 +9166,16 @@ function queryTaskHistory(db, options = {}) {
               target_kind, target_ref, metadata_json
        FROM task_history ${where} ORDER BY started_at DESC`).all(...params);
 }
+function queryCompletedTaskIntervals(db, since, until) {
+  const sql = until ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL ORDER BY started_at" : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";
+  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
+}
+function listExistingTableNames(db, names) {
+  if (names.length === 0)
+    return [];
+  const placeholders = names.map(() => "?").join(", ");
+  return db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${placeholders}) ORDER BY name`).all(...names);
+}
 async function importEventsJsonl(db, jsonlPath) {
   const { readFileSync, existsSync } = await import("fs");
   if (!existsSync(jsonlPath)) {
@@ -9082,23 +9232,17 @@ function computeImproveRunMetrics(result) {
   let autoAcceptedCount = 0;
   let errorCount = 0;
   for (const action of actions) {
-    switch (action.mode) {
-      case "reflect":
-      case "distill":
-      case "memory-inference":
-      case "graph-extraction":
+    switch (classifyImproveAction(action.mode)) {
+      case "accepted":
         acceptedCount++;
         break;
-      case "reflect-cooldown":
-      case "reflect-skipped":
-      case "distill-skipped":
+      case "rejected":
         rejectedCount++;
         break;
-      case "reflect-failed":
       case "error":
         errorCount++;
         break;
-      case "memory-prune":
+      case "noop":
         break;
     }
     const r = action.result;
@@ -9117,6 +9261,10 @@ function recordImproveRun(db, input) {
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(input.id, input.startedAt, input.completedAt, input.stashDir, input.dryRun ? 1 : 0, input.profile, input.scopeMode, input.scopeValue, input.guidance, input.ok ? 1 : 0, JSON.stringify(input.result), JSON.stringify(metricsObj), JSON.stringify(input.metadata ?? {}));
 }
+function queryImproveRuns(db, since, until) {
+  const sql = until ? "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND started_at < ? AND dry_run = 0 ORDER BY started_at DESC" : "SELECT id, started_at, completed_at, ok, scope_mode, scope_value, result_json FROM improve_runs WHERE started_at >= ? AND dry_run = 0 ORDER BY started_at DESC";
+  return until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since);
+}
 function purgeOldImproveRuns(db, retentionDays = 90) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0)
     return 0;
@@ -9177,6 +9325,8 @@ var MIGRATIONS, REGISTRY_INDEX_CACHE_DDL = `
     ON registry_index_cache(fetched_at);
 `;
 var init_state_db = __esm(() => {
+  init_database();
+  init_improve_types();
   init_paths();
   init_warn();
   MIGRATIONS = [
@@ -9250,7 +9400,9 @@ var init_state_db = __esm(() => {
       --
       -- Extensible (metadata_json) columns:
       --   metadata_json TEXT      \u2014 JSON object for future proposal fields.
-      --                             Current fields stored here: sourceRun, review.
+      --                             Current fields stored here: sourceRun,
+      --                             review, confidence, gateDecision (#577),
+      --                             backupContent.
       --
       -- ADD COLUMN extension points (future migrations):
       --   ALTER TABLE proposals ADD COLUMN source_run TEXT DEFAULT NULL;
@@ -9437,10 +9589,35 @@ var init_state_db = __esm(() => {
       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
+      );
+    `
     }
   ];
 });
 
+// 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/llm/embedders/types.ts
 function cosineSimilarity(a, b) {
   if (a.length !== b.length) {
@@ -9465,7 +9642,98 @@ var init_types = __esm(() => {
   init_warn();
 });
 
-// src/indexer/db-backup.ts
+// src/runtime.ts
+import { createHash } from "crypto";
+import { createRequire as createRequire2 } from "module";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function sleepSync(ms) {
+  if (isBun2) {
+    bunGlobal().sleepSync(ms);
+    return;
+  }
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function bunGlobal() {
+  return globalThis.Bun;
+}
+var isBun2, nodeRequire2, mainPath;
+var init_runtime = __esm(() => {
+  isBun2 = !!process.versions?.bun;
+  nodeRequire2 = createRequire2(import.meta.url);
+  mainPath = isBun2 ? bunGlobal().main : process.argv[1];
+});
+
+// src/indexer/search/search-fields.ts
+function buildSearchFields(entry) {
+  const name = entry.name.replace(/[-_]/g, " ").toLowerCase();
+  const description = (entry.description ?? "").toLowerCase();
+  const tagParts = [];
+  if (entry.tags)
+    tagParts.push(entry.tags.join(" "));
+  if (entry.aliases)
+    tagParts.push(entry.aliases.join(" "));
+  const tags = tagParts.join(" ").toLowerCase();
+  const hintParts = [];
+  if (entry.searchHints)
+    hintParts.push(entry.searchHints.join(" "));
+  if (entry.examples)
+    hintParts.push(entry.examples.join(" "));
+  if (entry.usage)
+    hintParts.push(entry.usage.join(" "));
+  if (entry.intent) {
+    if (entry.intent.when)
+      hintParts.push(entry.intent.when);
+    if (entry.intent.input)
+      hintParts.push(entry.intent.input);
+    if (entry.intent.output)
+      hintParts.push(entry.intent.output);
+  }
+  if (entry.xrefs)
+    hintParts.push(entry.xrefs.join(" "));
+  if (entry.pageKind)
+    hintParts.push(entry.pageKind);
+  if (entry.whenToUse)
+    hintParts.push(entry.whenToUse);
+  const hints = hintParts.join(" ").toLowerCase();
+  const contentParts = [];
+  if (entry.toc) {
+    contentParts.push(entry.toc.map((h) => h.text).join(" "));
+  }
+  if (entry.parameters) {
+    for (const param of entry.parameters) {
+      contentParts.push(param.name);
+      if (param.description)
+        contentParts.push(param.description);
+    }
+  }
+  const content = contentParts.join(" ").toLowerCase();
+  return { name, description, tags, hints, content };
+}
+
+// src/indexer/usage/usage-events.ts
+function ensureUsageEventsSchema(db) {
+  db.exec(`
+    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);
+  `);
+}
+
+// src/indexer/db/db-backup.ts
 import fs6 from "fs";
 import path6 from "path";
 function resolveRetention(env = process.env) {
@@ -9507,9 +9775,9 @@ function measureDataDirSize(dirPath) {
       if (entry.isDirectory()) {
         stack.push(full);
       } else if (entry.isFile()) {
-        try {
+        bestEffort(() => {
           total += fs6.statSync(full).size;
-        } catch {}
+        }, "file vanished between readdir and stat");
       }
     }
   }
@@ -9545,7 +9813,7 @@ function listBackups(dataDir) {
     let sizeBytes;
     let reason = DEFAULT_BACKUP_REASON;
     if (fs6.existsSync(metaPath)) {
-      try {
+      bestEffort(() => {
         const raw = fs6.readFileSync(metaPath, "utf8");
         const parsed = JSON.parse(raw);
         if (typeof parsed.createdAt === "string")
@@ -9558,7 +9826,7 @@ function listBackups(dataDir) {
           sizeBytes = parsed.sizeBytes;
         if (typeof parsed.reason === "string" && parsed.reason.length > 0)
           reason = parsed.reason;
-      } catch {}
+      }, "malformed backup metadata \u2014 fall back to filesystem-derived values");
     }
     if (!createdAt) {
       try {
@@ -9639,9 +9907,7 @@ function backupDataDir(opts) {
     copyDataDirExcludingBackups(dataDir, finalDest);
   } catch (err) {
     warn("[akm] data dir backup failed \u2014 %s; upgrade will proceed without a snapshot", err instanceof Error ? err.message : String(err));
-    try {
-      fs6.rmSync(finalDest, { recursive: true, force: true });
-    } catch {}
+    bestEffort(() => fs6.rmSync(finalDest, { recursive: true, force: true }), "cleanup partial backup copy");
     return null;
   }
   const createdAt = now.toISOString();
@@ -9697,9 +9963,7 @@ function copyDataDirExcludingBackups(srcRoot, destRoot) {
         fs6.copyFileSync(srcPath, destPath);
       } else if (entry.isSymbolicLink()) {
         const target = fs6.readlinkSync(srcPath);
-        try {
-          fs6.symlinkSync(target, destPath);
-        } catch {}
+        bestEffort(() => fs6.symlinkSync(target, destPath), "symlink creation can fail on Windows without admin");
       }
     }
   }
@@ -9714,77 +9978,10 @@ function tryHostname() {
 }
 var DEFAULT_BACKUP_REASON = "version-upgrade", EMBEDDING_DIM_CHANGE_REASON = "embedding-dim-change", BACKUPS_DIR_NAME = "backups", BACKUP_METADATA_FILE = "backup.meta.json", DEFAULT_RETAIN = 5, FREE_SPACE_MULTIPLIER = 1.1;
 var init_db_backup = __esm(() => {
+  init_best_effort();
   init_warn();
 });
 
-// src/indexer/search-fields.ts
-function buildSearchFields(entry) {
-  const name = entry.name.replace(/[-_]/g, " ").toLowerCase();
-  const description = (entry.description ?? "").toLowerCase();
-  const tagParts = [];
-  if (entry.tags)
-    tagParts.push(entry.tags.join(" "));
-  if (entry.aliases)
-    tagParts.push(entry.aliases.join(" "));
-  const tags = tagParts.join(" ").toLowerCase();
-  const hintParts = [];
-  if (entry.searchHints)
-    hintParts.push(entry.searchHints.join(" "));
-  if (entry.examples)
-    hintParts.push(entry.examples.join(" "));
-  if (entry.usage)
-    hintParts.push(entry.usage.join(" "));
-  if (entry.intent) {
-    if (entry.intent.when)
-      hintParts.push(entry.intent.when);
-    if (entry.intent.input)
-      hintParts.push(entry.intent.input);
-    if (entry.intent.output)
-      hintParts.push(entry.intent.output);
-  }
-  if (entry.xrefs)
-    hintParts.push(entry.xrefs.join(" "));
-  if (entry.pageKind)
-    hintParts.push(entry.pageKind);
-  if (entry.whenToUse)
-    hintParts.push(entry.whenToUse);
-  const hints = hintParts.join(" ").toLowerCase();
-  const contentParts = [];
-  if (entry.toc) {
-    contentParts.push(entry.toc.map((h) => h.text).join(" "));
-  }
-  if (entry.parameters) {
-    for (const param of entry.parameters) {
-      contentParts.push(param.name);
-      if (param.description)
-        contentParts.push(param.description);
-    }
-  }
-  const content = contentParts.join(" ").toLowerCase();
-  return { name, description, tags, hints, content };
-}
-
-// src/indexer/usage-events.ts
-function ensureUsageEventsSchema(db) {
-  db.exec(`
-    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);
-  `);
-}
-
 // src/core/file-lock.ts
 import fs7 from "fs";
 function tryAcquireLockSync(lockPath, payload) {
@@ -9850,7 +10047,7 @@ var init_file_lock = __esm(() => {
   init_common();
 });
 
-// src/core/config-io.ts
+// src/core/config/config-io.ts
 import fs8 from "fs";
 import path7 from "path";
 function parseConfigText(text, sourcePath) {
@@ -9891,9 +10088,12 @@ function backupExistingConfig(configPath) {
   const backupDir = path7.join(getCacheDir(), "config-backups");
   fs8.mkdirSync(backupDir, { recursive: true });
   const timestamp = new Date().toISOString().replace(/[.:]/g, "-");
-  fs8.copyFileSync(configPath, path7.join(backupDir, `config-${timestamp}.json`));
-  fs8.copyFileSync(configPath, path7.join(backupDir, "config.latest.json"));
+  const timestamped = path7.join(backupDir, `config-${timestamp}.json`);
+  const latest = path7.join(backupDir, "config.latest.json");
+  fs8.copyFileSync(configPath, timestamped);
+  fs8.copyFileSync(configPath, latest);
   pruneOldBackups2(backupDir);
+  return { timestamped, latest };
 }
 function pruneOldBackups2(backupDir) {
   let entries;
@@ -9919,6 +10119,9 @@ function pruneOldBackups2(backupDir) {
 function getConfigLockPath() {
   return path7.join(getConfigDir(), "config.json.lck");
 }
+function sleepSyncMs(ms) {
+  sleepSync(ms);
+}
 function acquireConfigLock() {
   const lockPath = getConfigLockPath();
   try {
@@ -9937,8 +10140,7 @@ function acquireConfigLock() {
       continue;
     }
     if (attempt < CONFIG_LOCK_MAX_RETRIES - 1) {
-      const deadline = Date.now() + CONFIG_LOCK_RETRY_DELAY_MS;
-      while (Date.now() < deadline) {}
+      sleepSyncMs(CONFIG_LOCK_RETRY_DELAY_MS);
     }
   }
   return () => {};
@@ -9991,17 +10193,802 @@ function stripJsonComments(text) {
     result += text[i];
     i++;
   }
-  return result;
+  return result;
+}
+var MAX_CONFIG_BACKUPS = 5, CONFIG_LOCK_MAX_RETRIES = 10, CONFIG_LOCK_RETRY_DELAY_MS = 50;
+var init_config_io = __esm(() => {
+  init_runtime();
+  init_common();
+  init_errors();
+  init_file_lock();
+  init_paths();
+});
+
+// src/integrations/harnesses/types.ts
+class BaseHarness {
+  runtimeId;
+  setupDetectionDir;
+  v1ProfilePrefixes = [];
+  matchesV1ProfileName(name) {
+    if (!this.capabilities.v1Migration)
+      return false;
+    const lower = name.trim().toLowerCase();
+    if (!lower)
+      return false;
+    if (lower === this.id.toLowerCase())
+      return true;
+    for (const alias of this.aliases) {
+      if (lower === alias.toLowerCase())
+        return true;
+    }
+    for (const prefix of this.v1ProfilePrefixes) {
+      if (lower.startsWith(prefix.toLowerCase()))
+        return true;
+    }
+    return false;
+  }
+}
+
+// src/integrations/agent/builder-shared.ts
+var init_builder_shared = __esm(() => {
+  init_errors();
+});
+
+// src/integrations/agent/model-aliases.ts
+var init_model_aliases = () => {};
+
+// src/integrations/harnesses/claude/agent-builder.ts
+var init_agent_builder = __esm(() => {
+  init_builder_shared();
+  init_model_aliases();
+});
+
+// src/integrations/harnesses/claude/config-import.ts
+var init_config_import = () => {};
+
+// src/integrations/session-logs/inline-refs.ts
+function extractInlineRefMentions(text, ts) {
+  if (!text || text.length < 10)
+    return [];
+  const out = [];
+  REMEMBER_RE.lastIndex = 0;
+  for (const m of text.matchAll(REMEMBER_RE)) {
+    const body = m[1] ?? m[2] ?? "";
+    if (!body.trim())
+      continue;
+    out.push({
+      kind: "remember",
+      text: body,
+      ...ts !== undefined ? { ts } : {}
+    });
+  }
+  FEEDBACK_RE.lastIndex = 0;
+  for (const m of text.matchAll(FEEDBACK_RE)) {
+    const ref = m[1] ?? "";
+    const note = m[2] ?? m[3] ?? "";
+    if (!ref)
+      continue;
+    out.push({
+      kind: "feedback",
+      ref,
+      text: note,
+      ...ts !== undefined ? { ts } : {}
+    });
+  }
+  return out;
+}
+var REMEMBER_RE, FEEDBACK_RE;
+var init_inline_refs = __esm(() => {
+  REMEMBER_RE = /\bakm\s+remember\s+(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/g;
+  FEEDBACK_RE = /\bakm\s+feedback\s+(\S+)(?:\s+--[a-z-]+)*\s+(?:--note|-n)\s+(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/g;
+});
+
+// src/integrations/harnesses/claude/session-log.ts
+import fs9 from "fs";
+import os from "os";
+import path8 from "path";
+function claudeProjectsDir() {
+  return process.env.AKM_CLAUDE_PROJECTS_DIR ?? path8.join(os.homedir(), ".claude", "projects");
+}
+function parseClaudeEvent(entry, sessionId, filePath, fallbackTsMs) {
+  if (!entry || typeof entry !== "object")
+    return;
+  const e = entry;
+  const tsRaw = e.timestamp;
+  const ts = typeof tsRaw === "number" ? tsRaw : typeof tsRaw === "string" ? Date.parse(tsRaw) || fallbackTsMs : fallbackTsMs;
+  const message = e.message ?? undefined;
+  const role = typeof message?.role === "string" ? message.role : e.type ?? "unknown";
+  const content = message?.content;
+  let text = "";
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string")
+        parts.push(b.text);
+      else if (b.type === "thinking" && typeof b.thinking === "string")
+        parts.push(b.thinking);
+      else if (b.type === "tool_use") {
+        const toolName = typeof b.name === "string" ? b.name : "tool";
+        const inputObj = b.input;
+        let inputText = "";
+        if (inputObj && typeof inputObj === "object") {
+          const cmd = inputObj.command;
+          inputText = typeof cmd === "string" ? cmd : JSON.stringify(inputObj);
+        } else if (typeof inputObj === "string") {
+          inputText = inputObj;
+        }
+        parts.push(`[tool:${toolName}] ${inputText}`);
+      } else if (b.type === "tool_result") {
+        const out = typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? "");
+        parts.push(`[tool_result] ${out}`);
+      }
+    }
+    text = parts.join(`
+`);
+  }
+  if (!text || text.length < 1)
+    return;
+  return {
+    harness: "claude-code",
+    text,
+    ts,
+    sessionId,
+    role,
+    filePath
+  };
+}
+
+class ClaudeCodeProvider {
+  name = "claude-code";
+  isAvailable() {
+    return fs9.existsSync(claudeProjectsDir());
+  }
+  *readEvents(input) {
+    try {
+      for (const jsonlPath of this.#walkJsonl(claudeProjectsDir())) {
+        const stat = fs9.statSync(jsonlPath);
+        if (stat.mtimeMs < input.sinceMs)
+          continue;
+        const lines = fs9.readFileSync(jsonlPath, "utf8").split(`
+`).filter(Boolean);
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            const text = entry?.message?.content ?? entry?.content ?? "";
+            if (typeof text !== "string" || text.length < 10)
+              continue;
+            yield {
+              harness: this.name,
+              text,
+              ts: typeof entry?.timestamp === "number" ? entry.timestamp : stat.mtimeMs,
+              sessionId: typeof entry?.session_id === "string" ? entry.session_id : undefined,
+              role: typeof entry?.role === "string" ? entry.role : "unknown",
+              filePath: jsonlPath
+            };
+          } catch {}
+        }
+      }
+    } catch {
+      return;
+    }
+  }
+  listSessions(input = {}) {
+    const root = input.location ?? claudeProjectsDir();
+    const sinceMs = input.sinceMs ?? 0;
+    const summaries = [];
+    try {
+      for (const jsonlPath of this.#walkJsonl(root)) {
+        let stat;
+        try {
+          stat = fs9.statSync(jsonlPath);
+        } catch {
+          continue;
+        }
+        if (stat.mtimeMs < sinceMs)
+          continue;
+        const sessionId = path8.basename(jsonlPath, ".jsonl");
+        const projectHint = path8.basename(path8.dirname(jsonlPath));
+        const peek = this.#peekJsonl(jsonlPath);
+        summaries.push({
+          harness: this.name,
+          sessionId,
+          filePath: jsonlPath,
+          startedAt: peek.firstTsMs ?? stat.ctimeMs,
+          endedAt: peek.lastTsMs ?? stat.mtimeMs,
+          projectHint,
+          ...peek.title ? { title: peek.title } : {}
+        });
+      }
+    } catch {}
+    return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
+  }
+  readSession(ref) {
+    const stat = fs9.statSync(ref.filePath);
+    const lines = fs9.readFileSync(ref.filePath, "utf8").split(`
+`).filter(Boolean);
+    const events = [];
+    const inlineRefs = [];
+    let title;
+    let firstTsMs;
+    let lastTsMs;
+    const projectHint = path8.basename(path8.dirname(ref.filePath));
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!entry)
+        continue;
+      if (entry.type === "custom-title" && typeof entry.customTitle === "string") {
+        title = entry.customTitle;
+        continue;
+      }
+      const parsed = parseClaudeEvent(entry, ref.sessionId, ref.filePath, stat.mtimeMs);
+      if (!parsed)
+        continue;
+      events.push(parsed);
+      if (firstTsMs === undefined || (parsed.ts ?? 0) < firstTsMs)
+        firstTsMs = parsed.ts;
+      if (lastTsMs === undefined || (parsed.ts ?? 0) > lastTsMs)
+        lastTsMs = parsed.ts;
+      inlineRefs.push(...extractInlineRefMentions(parsed.text, parsed.ts));
+    }
+    return {
+      ref: {
+        harness: this.name,
+        sessionId: ref.sessionId,
+        filePath: ref.filePath,
+        startedAt: firstTsMs ?? stat.ctimeMs,
+        endedAt: lastTsMs ?? stat.mtimeMs,
+        projectHint,
+        ...title ? { title } : {}
+      },
+      events,
+      inlineRefs
+    };
+  }
+  #peekJsonl(filePath) {
+    const result = {};
+    try {
+      const fd = fs9.openSync(filePath, "r");
+      try {
+        const stat = fs9.fstatSync(fd);
+        const headSize = Math.min(stat.size, 4096);
+        const head = Buffer.alloc(headSize);
+        fs9.readSync(fd, head, 0, headSize, 0);
+        const headLines = head.toString("utf8").split(`
+`).filter(Boolean);
+        for (const line of headLines) {
+          try {
+            const e = JSON.parse(line);
+            if (e.type === "custom-title" && typeof e.customTitle === "string") {
+              result.title = e.customTitle;
+            }
+            if (typeof e.timestamp === "string") {
+              const t = Date.parse(e.timestamp);
+              if (!Number.isNaN(t)) {
+                if (result.firstTsMs === undefined)
+                  result.firstTsMs = t;
+                result.lastTsMs = t;
+              }
+            }
+          } catch {}
+        }
+        if (stat.size > 4096) {
+          const tailSize = Math.min(stat.size, 4096);
+          const tail = Buffer.alloc(tailSize);
+          fs9.readSync(fd, tail, 0, tailSize, stat.size - tailSize);
+          const tailLines = tail.toString("utf8").split(`
+`).filter(Boolean);
+          for (let i = tailLines.length - 1;i >= 0; i--) {
+            try {
+              const e = JSON.parse(tailLines[i] ?? "");
+              if (typeof e.timestamp === "string") {
+                const t = Date.parse(e.timestamp);
+                if (!Number.isNaN(t)) {
+                  result.lastTsMs = t;
+                  break;
+                }
+              }
+            } catch {}
+          }
+        }
+      } finally {
+        fs9.closeSync(fd);
+      }
+    } catch {}
+    return result;
+  }
+  *#walkJsonl(dir) {
+    try {
+      for (const entry of fs9.readdirSync(dir, { withFileTypes: true })) {
+        const full = path8.join(dir, entry.name);
+        if (entry.isDirectory())
+          yield* this.#walkJsonl(full);
+        else if (entry.name.endsWith(".jsonl"))
+          yield full;
+      }
+    } catch {}
+  }
+}
+var init_session_log = __esm(() => {
+  init_inline_refs();
+});
+
+// src/integrations/harnesses/claude/index.ts
+function caps(c) {
+  return {
+    sessionLogs: false,
+    agentDispatch: false,
+    detection: false,
+    configImport: false,
+    runtimeIdentity: false,
+    v1Migration: false,
+    ...c
+  };
+}
+var ClaudeHarness;
+var init_claude = __esm(() => {
+  init_agent_builder();
+  init_config_import();
+  init_session_log();
+  ClaudeHarness = class ClaudeHarness extends BaseHarness {
+    id = "claude";
+    displayName = "Claude Code";
+    aliases = ["claude-code"];
+    runtimeId = "claude-code";
+    setupDetectionDir = ".claude";
+    capabilities = caps({
+      sessionLogs: true,
+      agentDispatch: true,
+      detection: true,
+      configImport: true,
+      runtimeIdentity: true,
+      v1Migration: true
+    });
+  };
+});
+
+// src/integrations/harnesses/opencode/agent-builder.ts
+var init_agent_builder2 = __esm(() => {
+  init_builder_shared();
+  init_model_aliases();
+});
+
+// src/integrations/harnesses/opencode/config-import.ts
+var init_config_import2 = () => {};
+
+// src/integrations/harnesses/opencode/session-log.ts
+import fs10 from "fs";
+import os2 from "os";
+import path9 from "path";
+function getOpenCodeBaseDir() {
+  if (process.platform === "darwin") {
+    return path9.join(os2.homedir(), "Library", "Application Support", "opencode");
+  }
+  return path9.join(os2.homedir(), ".local", "share", "opencode");
+}
+
+class OpenCodeProvider {
+  name = "opencode";
+  #baseDir = getOpenCodeBaseDir();
+  isAvailable() {
+    return fs10.existsSync(this.#baseDir);
+  }
+  *readEvents(input) {
+    const candidates = [this.#baseDir, path9.join(this.#baseDir, "log")];
+    for (const dir of candidates) {
+      if (!fs10.existsSync(dir))
+        continue;
+      try {
+        for (const file of fs10.readdirSync(dir)) {
+          const full = path9.join(dir, file);
+          let stat;
+          try {
+            stat = fs10.statSync(full);
+          } catch {
+            continue;
+          }
+          if (!stat.isFile())
+            continue;
+          if (stat.mtimeMs < input.sinceMs)
+            continue;
+          if (!file.endsWith(".json") && !file.endsWith(".jsonl") && !file.endsWith(".log"))
+            continue;
+          const content = fs10.readFileSync(full, "utf8");
+          const lines = content.includes(`
+`) ? content.split(`
+`) : [content];
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line);
+              const text = entry?.content ?? entry?.message ?? entry?.text ?? "";
+              if (typeof text !== "string" || text.length < 10)
+                continue;
+              yield {
+                harness: this.name,
+                text,
+                ts: typeof entry?.timestamp === "number" ? entry.timestamp : stat.mtimeMs,
+                sessionId: typeof entry?.sessionId === "string" ? entry.sessionId : undefined,
+                role: typeof entry?.role === "string" ? entry.role : "unknown",
+                filePath: full
+              };
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+  }
+  listSessions(input = {}) {
+    const base = input.location ?? this.#baseDir;
+    const sinceMs = input.sinceMs ?? 0;
+    const sessionRoot = path9.join(base, "storage", "session");
+    if (!fs10.existsSync(sessionRoot))
+      return [];
+    const summaries = [];
+    try {
+      for (const projectId of fs10.readdirSync(sessionRoot)) {
+        const projectDir = path9.join(sessionRoot, projectId);
+        let pstat;
+        try {
+          pstat = fs10.statSync(projectDir);
+        } catch {
+          continue;
+        }
+        if (!pstat.isDirectory())
+          continue;
+        for (const file of fs10.readdirSync(projectDir)) {
+          if (!file.endsWith(".json"))
+            continue;
+          const filePath = path9.join(projectDir, file);
+          let stat;
+          try {
+            stat = fs10.statSync(filePath);
+          } catch {
+            continue;
+          }
+          if (stat.mtimeMs < sinceMs)
+            continue;
+          let meta;
+          try {
+            meta = JSON.parse(fs10.readFileSync(filePath, "utf8"));
+          } catch {
+            continue;
+          }
+          const sessionId = typeof meta?.id === "string" ? meta.id : path9.basename(file, ".json");
+          const time = meta?.time ?? undefined;
+          const startedAt = typeof time?.created === "number" ? time.created : stat.ctimeMs;
+          const endedAt = typeof time?.updated === "number" ? time.updated : stat.mtimeMs;
+          const title = typeof meta?.title === "string" ? meta.title : undefined;
+          const projectHint = typeof meta?.directory === "string" ? meta.directory : projectId;
+          summaries.push({
+            harness: this.name,
+            sessionId,
+            filePath,
+            startedAt,
+            endedAt,
+            projectHint,
+            ...title ? { title } : {}
+          });
+        }
+      }
+    } catch {}
+    return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
+  }
+  readSession(ref) {
+    let meta = {};
+    try {
+      meta = JSON.parse(fs10.readFileSync(ref.filePath, "utf8"));
+    } catch {}
+    const time = meta.time ?? undefined;
+    const startedAt = typeof time?.created === "number" ? time.created : undefined;
+    const endedAt = typeof time?.updated === "number" ? time.updated : undefined;
+    const title = typeof meta.title === "string" ? meta.title : undefined;
+    const projectHint = typeof meta.directory === "string" ? meta.directory : undefined;
+    const events = [];
+    const inlineRefs = [];
+    const inferredBase = this.#inferBaseFromSessionPath(ref.filePath) ?? this.#baseDir;
+    const msgDir = path9.join(inferredBase, "storage", "message", ref.sessionId);
+    if (fs10.existsSync(msgDir)) {
+      try {
+        const files = fs10.readdirSync(msgDir).filter((f) => f.endsWith(".json"));
+        for (const file of files) {
+          const full = path9.join(msgDir, file);
+          let msg;
+          try {
+            msg = JSON.parse(fs10.readFileSync(full, "utf8"));
+          } catch {
+            continue;
+          }
+          if (!msg)
+            continue;
+          const evt = this.#messageToEvent(msg, ref.sessionId, full);
+          if (evt) {
+            events.push(evt);
+            inlineRefs.push(...extractInlineRefMentions(evt.text, evt.ts));
+          }
+        }
+      } catch {}
+    }
+    events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+    return {
+      ref: {
+        harness: this.name,
+        sessionId: ref.sessionId,
+        filePath: ref.filePath,
+        ...startedAt !== undefined ? { startedAt } : {},
+        ...endedAt !== undefined ? { endedAt } : {},
+        ...projectHint ? { projectHint } : {},
+        ...title ? { title } : {}
+      },
+      events,
+      inlineRefs
+    };
+  }
+  #inferBaseFromSessionPath(filePath) {
+    const dir = path9.dirname(filePath);
+    const parts = dir.split(path9.sep);
+    if (parts.length < 3)
+      return;
+    const last = parts[parts.length - 1];
+    const sndLast = parts[parts.length - 2];
+    const thirdLast = parts[parts.length - 3];
+    if (sndLast !== "session" || thirdLast !== "storage" || !last)
+      return;
+    return parts.slice(0, parts.length - 3).join(path9.sep);
+  }
+  #messageToEvent(msg, sessionId, filePath) {
+    const time = msg.time ?? undefined;
+    const ts = typeof time?.created === "number" ? time.created : typeof msg.timestamp === "number" ? msg.timestamp : 0;
+    const role = typeof msg.role === "string" ? msg.role : "unknown";
+    const summary = msg.summary;
+    const parts = [];
+    if (typeof summary?.title === "string")
+      parts.push(summary.title);
+    if (Array.isArray(summary?.parts)) {
+      for (const p of summary.parts) {
+        if (typeof p === "string")
+          parts.push(p);
+        else if (p && typeof p === "object") {
+          const text2 = p.text;
+          if (typeof text2 === "string")
+            parts.push(text2);
+        }
+      }
+    }
+    if (typeof msg.content === "string")
+      parts.push(msg.content);
+    const text = parts.join(`
+`).trim();
+    if (text.length < 1)
+      return;
+    return {
+      harness: this.name,
+      text,
+      ts: ts || undefined,
+      sessionId,
+      role,
+      filePath
+    };
+  }
+}
+var init_session_log2 = __esm(() => {
+  init_inline_refs();
+});
+
+// src/integrations/harnesses/opencode/index.ts
+function caps2(c) {
+  return {
+    sessionLogs: false,
+    agentDispatch: false,
+    detection: false,
+    configImport: false,
+    runtimeIdentity: false,
+    v1Migration: false,
+    ...c
+  };
+}
+var OpencodeHarness;
+var init_opencode = __esm(() => {
+  init_agent_builder2();
+  init_config_import2();
+  init_session_log2();
+  OpencodeHarness = class OpencodeHarness extends BaseHarness {
+    id = "opencode";
+    displayName = "OpenCode";
+    aliases = [];
+    setupDetectionDir = ".config/opencode";
+    v1ProfilePrefixes = ["opencode"];
+    capabilities = caps2({
+      sessionLogs: true,
+      agentDispatch: true,
+      detection: true,
+      configImport: true,
+      runtimeIdentity: true,
+      v1Migration: true
+    });
+  };
+});
+
+// src/integrations/agent/profiles.ts
+var COMMON_PASSTHROUGH, BUILTINS, HEADLESS_BUILTINS, BUILTIN_AGENT_PROFILE_NAMES;
+var init_profiles = __esm(() => {
+  COMMON_PASSTHROUGH = ["HOME", "PATH", "USER", "LANG", "LC_ALL", "TERM", "TMPDIR"];
+  BUILTINS = {
+    opencode: {
+      name: "opencode",
+      bin: "opencode",
+      args: ["run"],
+      stdio: "interactive",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG"],
+      parseOutput: "text"
+    },
+    claude: {
+      name: "claude",
+      bin: "claude",
+      args: [],
+      stdio: "interactive",
+      envPassthrough: [...COMMON_PASSTHROUGH, "ANTHROPIC_API_KEY", "CLAUDE_CONFIG"],
+      parseOutput: "text"
+    },
+    codex: {
+      name: "codex",
+      bin: "codex",
+      args: [],
+      stdio: "interactive",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "CODEX_CONFIG"],
+      parseOutput: "text"
+    },
+    gemini: {
+      name: "gemini",
+      bin: "gemini",
+      args: [],
+      stdio: "interactive",
+      envPassthrough: [...COMMON_PASSTHROUGH, "GEMINI_API_KEY", "GOOGLE_API_KEY"],
+      parseOutput: "text"
+    },
+    aider: {
+      name: "aider",
+      bin: "aider",
+      args: ["--no-auto-commits"],
+      stdio: "interactive",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
+      parseOutput: "text"
+    }
+  };
+  HEADLESS_BUILTINS = {
+    "opencode-headless": {
+      name: "opencode-headless",
+      bin: "opencode",
+      args: ["run"],
+      stdio: "captured",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENCODE_API_KEY", "OPENCODE_CONFIG"],
+      parseOutput: "json"
+    },
+    "claude-headless": {
+      name: "claude-headless",
+      bin: "claude",
+      args: [],
+      stdio: "captured",
+      envPassthrough: [...COMMON_PASSTHROUGH, "ANTHROPIC_API_KEY", "CLAUDE_CONFIG"],
+      parseOutput: "json"
+    },
+    "codex-headless": {
+      name: "codex-headless",
+      bin: "codex",
+      args: [],
+      stdio: "captured",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "CODEX_CONFIG"],
+      parseOutput: "json"
+    },
+    "gemini-headless": {
+      name: "gemini-headless",
+      bin: "gemini",
+      args: [],
+      stdio: "captured",
+      envPassthrough: [...COMMON_PASSTHROUGH, "GEMINI_API_KEY", "GOOGLE_API_KEY"],
+      parseOutput: "json"
+    },
+    "aider-headless": {
+      name: "aider-headless",
+      bin: "aider",
+      args: ["--no-auto-commits"],
+      stdio: "captured",
+      envPassthrough: [...COMMON_PASSTHROUGH, "OPENAI_API_KEY", "ANTHROPIC_API_KEY"],
+      parseOutput: "json"
+    }
+  };
+  BUILTIN_AGENT_PROFILE_NAMES = Object.freeze(Object.keys(BUILTINS).sort());
+});
+
+// src/integrations/agent/config.ts
+var init_config = __esm(() => {
+  init_config2();
+  init_errors();
+  init_warn();
+  init_profiles();
+});
+
+// src/integrations/harnesses/opencode-sdk/sdk-runner.ts
+var init_sdk_runner = __esm(() => {
+  init_config2();
+  init_config();
+});
+
+// src/integrations/harnesses/opencode-sdk/index.ts
+function caps3(c) {
+  return {
+    sessionLogs: false,
+    agentDispatch: false,
+    detection: false,
+    configImport: false,
+    runtimeIdentity: false,
+    v1Migration: false,
+    ...c
+  };
+}
+var OpencodeSdkHarness;
+var init_opencode_sdk = __esm(() => {
+  init_sdk_runner();
+  OpencodeSdkHarness = class OpencodeSdkHarness extends BaseHarness {
+    id = "opencode-sdk";
+    displayName = "OpenCode SDK";
+    aliases = [];
+    v1ProfilePrefixes = ["opencode-sdk"];
+    capabilities = caps3({
+      agentDispatch: true,
+      detection: true,
+      v1Migration: true
+    });
+  };
+});
+
+// src/integrations/harnesses/index.ts
+function v1ProfilePlatform(name) {
+  for (const h of V1_RESOLUTION_ORDER) {
+    if (h.matchesV1ProfileName(name))
+      return h.id;
+  }
+  return;
 }
-var MAX_CONFIG_BACKUPS = 5, CONFIG_LOCK_MAX_RETRIES = 10, CONFIG_LOCK_RETRY_DELAY_MS = 50;
-var init_config_io = __esm(() => {
-  init_common();
-  init_errors();
-  init_file_lock();
-  init_paths();
+var HARNESS_REGISTRY, HARNESS_BY_ID, HARNESS_BY_ANY_ID, VALID_HARNESS_IDS, SESSION_LOG_HARNESSES, AGENT_DISPATCH_HARNESSES, CONFIG_IMPORTER_HARNESSES, DETECTION_HARNESSES, V1_RESOLUTION_ORDER;
+var init_harnesses = __esm(() => {
+  init_claude();
+  init_opencode();
+  init_opencode_sdk();
+  HARNESS_REGISTRY = Object.freeze([
+    new OpencodeHarness,
+    new ClaudeHarness,
+    new OpencodeSdkHarness
+  ]);
+  HARNESS_BY_ID = new Map(HARNESS_REGISTRY.map((h) => [h.id, h]));
+  HARNESS_BY_ANY_ID = (() => {
+    const m = new Map;
+    for (const h of HARNESS_REGISTRY) {
+      m.set(h.id, h);
+      if (h.runtimeId)
+        m.set(h.runtimeId, h);
+      for (const a of h.aliases)
+        m.set(a, h);
+    }
+    return m;
+  })();
+  VALID_HARNESS_IDS = Object.freeze(HARNESS_REGISTRY.map((h) => h.id));
+  SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.sessionLogs);
+  AGENT_DISPATCH_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.agentDispatch);
+  CONFIG_IMPORTER_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.configImport);
+  DETECTION_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.detection);
+  V1_RESOLUTION_ORDER = [...HARNESS_REGISTRY].sort((a, b) => b.id.length - a.id.length);
 });
 
-// src/core/config-migration.ts
+// src/core/config/config-migration.ts
 function compareConfigVersion(a, b) {
   const partsA = normalizeVersion(a);
   const partsB = normalizeVersion(b);
@@ -10450,14 +11437,7 @@ function migrateConfigShape(raw) {
   return { changed, result };
 }
 function guessAgentPlatform(name) {
-  const lower = name.toLowerCase();
-  if (lower === "claude" || lower === "claude-code")
-    return "claude";
-  if (lower.startsWith("opencode-sdk"))
-    return "opencode-sdk";
-  if (lower.startsWith("opencode"))
-    return "opencode";
-  return;
+  return v1ProfilePlatform(name);
 }
 function mapV1ProcessName(name) {
   switch (name) {
@@ -10486,6 +11466,7 @@ function mapV1ProcessName(name) {
 }
 var CURRENT_CONFIG_VERSION = "0.8.0";
 var init_config_migration = __esm(() => {
+  init_harnesses();
   init_warn();
 });
 
@@ -10536,10 +11517,10 @@ var init_util = __esm(() => {
     util2.assertEqual = (_) => {};
     function assertIs(_arg) {}
     util2.assertIs = assertIs;
-    function assertNever(_x) {
+    function assertNever2(_x) {
       throw new Error;
     }
-    util2.assertNever = assertNever;
+    util2.assertNever = assertNever2;
     util2.arrayToEnum = (items) => {
       const obj = {};
       for (const item of items) {
@@ -10933,8 +11914,8 @@ class ParseStatus {
   }
 }
 var makeIssue = (params) => {
-  const { data, path: path8, errorMaps, issueData } = params;
-  const fullPath = [...path8, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10980,11 +11961,11 @@ var init_errorUtil = __esm(() => {
 
 // node_modules/zod/v3/types.js
 class ParseInputLazyPath {
-  constructor(parent, value, path8, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path8;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -14455,10 +15436,16 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// src/core/config-schema.ts
-var positiveInt, nonNegativeNumber, nonEmptyString, httpUrl, LlmCapabilitiesSchema, LlmConnectionConfigSchema, LlmProfileConfigSchema, EmbeddingOllamaOptionsSchema, EmbeddingConnectionConfigSchema, AgentPlatformSchema, AgentProfileConfigSchema, ImproveProcessConfigSchema, ImproveProfileProcessesSchema, ImproveProfileConfigSchema, ProfilesSchema, DefaultsSchema, SourceConfigEntryOptionsSchema, SourceConfigEntrySchema, RegistryConfigEntrySchema, KitSourceSchema, InstalledStashEntrySchema, OutputConfigSchema, SearchGraphBoostSchema, SearchConfigSchema, FeedbackConfigSchema, ImproveUtilityDecaySchema, ImproveConfigSchema, GRAPH_EXTRACTION_INCLUDE_TYPES_ALLOWED, INDEX_PASS_PROVIDER_KEYS, INDEX_PASS_KNOWN_KEYS, IndexPassConfigSchema, MetadataEnhanceSchema, StalenessDetectionSchema, IndexConfigSchema, AkmConfigShape, AkmConfigBaseSchema, AkmConfigSchema;
+// src/core/config/config-types.ts
+var init_config_types = __esm(() => {
+  init_harnesses();
+});
+
+// src/core/config/config-schema.ts
+var positiveInt, nonNegativeNumber, nonEmptyString, httpUrl, LlmCapabilitiesSchema, LlmConnectionConfigSchema, LlmProfileConfigSchema, EmbeddingOllamaOptionsSchema, EmbeddingConnectionConfigSchema, AgentPlatformSchema, AgentProfileConfigSchema, ImproveProcessConfigSchema, ImproveProfileProcessesSchema, ImproveProfileConfigSchema, ProfilesSchema, DefaultsSchema, SourceConfigEntryOptionsSchema, SourceConfigEntrySchema, RegistryConfigEntrySchema, KitSourceSchema, InstalledStashEntrySchema, OutputConfigSchema, SearchGraphBoostSchema, SearchConfigSchema, FeedbackConfigSchema, ImproveUtilityDecaySchema, ImproveConfigSchema, GRAPH_EXTRACTION_INCLUDE_TYPES_ALLOWED, INDEX_PASS_PROVIDER_KEYS, INDEX_PASS_KNOWN_KEYS, IndexPassConfigSchema, MetadataEnhanceSchema, StalenessDetectionSchema, IndexConfigSchema, SetupTaskSchedulesSchema, SetupConfigSchema, AkmConfigShape, AkmConfigBaseSchema, AkmConfigSchema;
 var init_config_schema = __esm(() => {
   init_zod();
+  init_config_types();
   positiveInt = exports_external.number().int().positive();
   nonNegativeNumber = exports_external.number().finite().min(0);
   nonEmptyString = exports_external.string().min(1).refine((v) => v.trim().length > 0, { message: "expected a non-empty string" });
@@ -14502,7 +15489,7 @@ var init_config_schema = __esm(() => {
     contextLength: positiveInt.optional(),
     ollamaOptions: EmbeddingOllamaOptionsSchema.optional()
   }).strict();
-  AgentPlatformSchema = exports_external.enum(["opencode", "claude", "opencode-sdk"]);
+  AgentPlatformSchema = exports_external.enum(VALID_HARNESS_IDS);
   AgentProfileConfigSchema = exports_external.object({
     platform: AgentPlatformSchema,
     bin: exports_external.string().min(1).optional(),
@@ -14516,12 +15503,16 @@ var init_config_schema = __esm(() => {
     profile: exports_external.string().min(1).optional(),
     timeoutMs: exports_external.union([positiveInt, exports_external.null()]).optional(),
     allowedTypes: exports_external.array(exports_external.string().min(1)).optional(),
+    minPoolSize: exports_external.number().int().min(0).optional(),
     qualityGate: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional(),
     contradictionDetection: exports_external.object({ enabled: exports_external.boolean().optional() }).strict().optional(),
     defaultSince: exports_external.string().min(1).optional(),
     maxTotalChars: positiveInt.optional(),
+    minContentChars: exports_external.number().int().min(0).optional(),
     maxChunkSize: exports_external.number().int().min(1).max(50).optional(),
-    incrementalSince: exports_external.string().min(1).optional(),
+    minNewSessions: exports_external.number().int().min(0).optional(),
+    indexSessions: exports_external.boolean().optional(),
+    minSessionDuration: exports_external.number().min(0).optional(),
     applyMode: exports_external.enum(["queue", "promote"]).optional(),
     policy: exports_external.string().min(1).optional(),
     maxAcceptsPerRun: positiveInt.optional(),
@@ -14779,6 +15770,13 @@ var init_config_schema = __esm(() => {
     metadataEnhance: MetadataEnhanceSchema.optional(),
     stalenessDetection: StalenessDetectionSchema.optional()
   }).catchall(IndexPassConfigSchema));
+  SetupTaskSchedulesSchema = exports_external.object({
+    improve: exports_external.string().min(1).optional(),
+    index: exports_external.string().min(1).optional()
+  }).strict();
+  SetupConfigSchema = exports_external.object({
+    taskSchedules: SetupTaskSchedulesSchema.optional()
+  }).strict();
   AkmConfigShape = {
     configVersion: exports_external.union([exports_external.string().min(1), exports_external.number()]).optional(),
     profiles: ProfilesSchema.optional(),
@@ -14796,7 +15794,8 @@ var init_config_schema = __esm(() => {
     search: SearchConfigSchema.optional(),
     feedback: FeedbackConfigSchema.optional(),
     archiveRetentionDays: nonNegativeNumber.optional(),
-    improve: ImproveConfigSchema.optional()
+    improve: ImproveConfigSchema.optional(),
+    setup: SetupConfigSchema.optional()
   };
   AkmConfigBaseSchema = exports_external.object(AkmConfigShape).strict();
   AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) => {
@@ -14819,8 +15818,8 @@ var init_config_schema = __esm(() => {
   });
 });
 
-// src/core/config-sources.ts
-import { createHash } from "crypto";
+// src/core/config/config-sources.ts
+import { createHash as createHash2 } from "crypto";
 function deriveStashEntryName(entry) {
   if (entry.name)
     return entry.name;
@@ -14829,7 +15828,7 @@ function deriveStashEntryName(entry) {
     path: entry.path ?? null,
     url: entry.url ?? null
   });
-  const hash = createHash("sha256").update(seed).digest("hex").slice(0, 8);
+  const hash = createHash2("sha256").update(seed).digest("hex").slice(0, 8);
   return `${entry.type}-${hash}`;
 }
 function parseSourceSpec(entry) {
@@ -14898,7 +15897,7 @@ function toConfiguredSource(persisted, isPrimary) {
 }
 var init_config_sources = () => {};
 
-// src/core/config.ts
+// src/core/config/config.ts
 var exports_config = {};
 __export(exports_config, {
   updateConfig: () => updateConfig,
@@ -14916,12 +15915,13 @@ __export(exports_config, {
   getIndexPassConfig: () => getIndexPassConfig,
   getEffectiveRegistries: () => getEffectiveRegistries,
   getDefaultLlmConfig: () => getDefaultLlmConfig,
+  VALID_HARNESS_IDS: () => VALID_HARNESS_IDS,
   FEEDBACK_FAILURE_MODES: () => FEEDBACK_FAILURE_MODES,
   DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE: () => DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG
 });
-import fs9 from "fs";
-import path8 from "path";
+import fs11 from "fs";
+import path10 from "path";
 function resolveBatchSize(configured, contextLength) {
   const base = configured && configured > 0 ? configured : DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE;
   if (!contextLength || contextLength <= 0)
@@ -14936,7 +15936,7 @@ function loadUserConfig() {
   const configPath = getConfigPath();
   let stat;
   try {
-    stat = fs9.statSync(configPath);
+    stat = fs11.statSync(configPath);
   } catch {
     cachedConfig = undefined;
     return applyRuntimeEnvApiKeys({ ...DEFAULT_CONFIG });
@@ -14946,7 +15946,7 @@ function loadUserConfig() {
   }
   let text;
   try {
-    text = fs9.readFileSync(configPath, "utf8");
+    text = fs11.readFileSync(configPath, "utf8");
   } catch {
     cachedConfig = undefined;
     return applyRuntimeEnvApiKeys({ ...DEFAULT_CONFIG });
@@ -14955,7 +15955,7 @@ function loadUserConfig() {
   const finalConfig = applyRuntimeEnvApiKeys(parseAndValidate(text, configPath));
   let finalStat = stat;
   try {
-    finalStat = fs9.statSync(configPath);
+    finalStat = fs11.statSync(configPath);
   } catch {}
   cachedConfig = {
     config: finalConfig,
@@ -15058,8 +16058,8 @@ function loadConfig() {
 function saveConfig(config) {
   cachedConfig = undefined;
   const configPath = getConfigPath();
-  const dir = path8.dirname(configPath);
-  fs9.mkdirSync(dir, { recursive: true });
+  const dir = path10.dirname(configPath);
+  fs11.mkdirSync(dir, { recursive: true });
   const sanitized = sanitizeConfigForWrite(config);
   const parseResult = AkmConfigSchema.safeParse(sanitized);
   if (!parseResult.success) {
@@ -15204,14 +16204,14 @@ function applyRuntimeEnvApiKeys(config) {
   return next;
 }
 function warnIfProjectConfigPresent(startDir) {
-  let currentDir = path8.resolve(startDir);
+  let currentDir = path10.resolve(startDir);
   while (true) {
-    const configPath = path8.join(currentDir, PROJECT_CONFIG_RELATIVE_PATH);
+    const configPath = path10.join(currentDir, PROJECT_CONFIG_RELATIVE_PATH);
     if (isFile(configPath) && !PROJECT_CONFIG_DEPRECATION_WARNED.has(configPath)) {
       PROJECT_CONFIG_DEPRECATION_WARNED.add(configPath);
       warn(`[akm] DEPRECATED: project-level config file found at ${configPath}. ` + "Project-level config files are no longer merged (removed after 0.8.x deprecation). " + "Move any needed settings to ~/.config/akm/config.json; this file is ignored.");
     }
-    const parentDir = path8.dirname(currentDir);
+    const parentDir = path10.dirname(currentDir);
     if (parentDir === currentDir)
       break;
     currentDir = parentDir;
@@ -15219,20 +16219,21 @@ function warnIfProjectConfigPresent(startDir) {
 }
 function isFile(filePath) {
   try {
-    return fs9.statSync(filePath).isFile();
+    return fs11.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 var FEEDBACK_FAILURE_MODES, DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE = 4, GRAPH_EXTRACTION_CHARS_PER_BODY = 1500, DEFAULT_CONFIG, PROJECT_CONFIG_RELATIVE_PATH, cachedConfig, INDEX_RESERVED_KEYS, PROJECT_CONFIG_DEPRECATION_WARNED;
-var init_config = __esm(() => {
+var init_config2 = __esm(() => {
+  init_errors();
   init_config_io();
   init_config_migration();
   init_config_schema();
-  init_errors();
   init_config_io();
   init_paths();
   init_warn();
+  init_config_types();
   init_config_sources();
   FEEDBACK_FAILURE_MODES = [
     "incorrect",
@@ -15252,12 +16253,12 @@ var init_config = __esm(() => {
       detail: "brief"
     }
   };
-  PROJECT_CONFIG_RELATIVE_PATH = path8.join(".akm", "config.json");
+  PROJECT_CONFIG_RELATIVE_PATH = path10.join(".akm", "config.json");
   INDEX_RESERVED_KEYS = new Set(["metadataEnhance", "stalenessDetection"]);
   PROJECT_CONFIG_DEPRECATION_WARNED = new Set;
 });
 
-// src/indexer/db.ts
+// src/indexer/db/db.ts
 var exports_db = {};
 __export(exports_db, {
   warnIfVecMissing: () => warnIfVecMissing,
@@ -15275,7 +16276,7 @@ __export(exports_db, {
   relinkUsageEvents: () => relinkUsageEvents,
   rebuildFts: () => rebuildFts,
   openExistingDatabase: () => openExistingDatabase,
-  openDatabase: () => openDatabase,
+  openDatabase: () => openDatabase2,
   isVecAvailable: () => isVecAvailable,
   getZeroResultSearches: () => getZeroResultSearches,
   getUtilityScoresByIds: () => getUtilityScoresByIds,
@@ -15288,11 +16289,15 @@ __export(exports_db, {
   getLlmCacheEntry: () => getLlmCacheEntry,
   getLlmCacheEntriesByRefs: () => getLlmCacheEntriesByRefs,
   getIndexDirState: () => getIndexDirState,
+  getEntryRefRowsForStashRoot: () => getEntryRefRowsForStashRoot,
+  getEntryIdByFilePath: () => getEntryIdByFilePath,
+  getEntryFilePathById: () => getEntryFilePathById,
   getEntryCount: () => getEntryCount,
   getEntryByRef: () => getEntryByRef,
   getEntryById: () => getEntryById,
   getEntriesByDir: () => getEntriesByDir,
   getEmbeddingCount: () => getEmbeddingCount,
+  getEmbeddableEntryCount: () => getEmbeddableEntryCount,
   getDerivedForParent: () => getDerivedForParent,
   getAllEntriesForEmbedding: () => getAllEntriesForEmbedding,
   getAllEntries: () => getAllEntries,
@@ -15304,6 +16309,7 @@ __export(exports_db, {
   deleteEntriesByDir: () => deleteEntriesByDir,
   computeSourceHash: () => computeSourceHash,
   computeBodyHash: () => computeBodyHash,
+  collectTagSetFromEntries: () => collectTagSetFromEntries,
   closeDatabase: () => closeDatabase,
   clearStaleCacheEntries: () => clearStaleCacheEntries,
   bumpUtilityScoresBatch: () => bumpUtilityScoresBatch,
@@ -15314,19 +16320,18 @@ __export(exports_db, {
   EMBEDDING_DIM: () => EMBEDDING_DIM,
   DB_VERSION: () => DB_VERSION
 });
-import { Database as Database2 } from "bun:sqlite";
-import fs10 from "fs";
-import { createRequire } from "module";
-import path9 from "path";
-function openDatabase(dbPath, options) {
+import fs12 from "fs";
+import { createRequire as createRequire3 } from "module";
+import path11 from "path";
+function openDatabase2(dbPath, options) {
   const resolvedPath = dbPath ?? getDbPath();
-  const dir = path9.dirname(resolvedPath);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path11.dirname(resolvedPath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database2(resolvedPath);
+  const db = openDatabase(resolvedPath);
   db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA busy_timeout = 30000");
   db.exec("PRAGMA foreign_keys = ON");
   loadVecExtension(db);
   const resolvedDim = options?.embeddingDim ?? resolveConfiguredEmbeddingDim();
@@ -15336,7 +16341,7 @@ function openDatabase(dbPath, options) {
 }
 function resolveConfiguredEmbeddingDim() {
   try {
-    const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(exports_config));
+    const { loadConfig: loadConfig2 } = (init_config2(), __toCommonJS(exports_config));
     const dim = loadConfig2().embedding?.dimension;
     if (typeof dim === "number" && Number.isInteger(dim) && dim > 0 && dim <= 4096) {
       return dim;
@@ -15348,9 +16353,9 @@ function resolveConfiguredEmbeddingDim() {
 }
 function openExistingDatabase(dbPath) {
   const resolvedPath = dbPath ?? getDbPath();
-  const db = new Database2(resolvedPath);
+  const db = openDatabase(resolvedPath);
   db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA busy_timeout = 30000");
   db.exec("PRAGMA foreign_keys = ON");
   loadVecExtension(db);
   return db;
@@ -15360,7 +16365,7 @@ function closeDatabase(db) {
 }
 function loadVecExtension(db) {
   try {
-    const esmRequire = createRequire(import.meta.url);
+    const esmRequire = createRequire3(import.meta.url);
     const sqliteVec = esmRequire("sqlite-vec");
     sqliteVec.load(db);
     vecStatus.set(db, true);
@@ -15376,7 +16381,7 @@ function warnIfVecMissing(db, { once } = { once: false }) {
     return;
   if (once && vecInitWarnedDbs.has(db))
     return;
-  try {
+  bestEffort(() => {
     const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
     const count = row?.cnt ?? 0;
     if (count >= VEC_FALLBACK_THRESHOLD) {
@@ -15385,7 +16390,7 @@ function warnIfVecMissing(db, { once } = { once: false }) {
       if (once)
         vecInitWarnedDbs.add(db);
     }
-  } catch {}
+  }, "embeddings table may not exist yet during init");
 }
 function ensureSchema(db, embeddingDim, options) {
   db.exec(`
@@ -15591,12 +16596,8 @@ function ensureSchema(db, embeddingDim, options) {
       const storedDim = getMeta(db, "embeddingDim");
       if (storedDim && storedDim !== String(embeddingDim)) {
         backupBeforeEmbeddingDimChange(options?.dataDir, storedDim, String(embeddingDim));
-        try {
-          db.exec("DROP TABLE IF EXISTS entries_vec");
-        } catch {}
-        try {
-          db.exec("DELETE FROM embeddings");
-        } catch {}
+        bestEffort(() => db.exec("DROP TABLE IF EXISTS entries_vec"), "drop entries_vec on dim change");
+        bestEffort(() => db.exec("DELETE FROM embeddings"), "delete stale embeddings on dim change");
         setMeta(db, "hasEmbeddings", "0");
       }
     }
@@ -15620,9 +16621,7 @@ function ensureSchema(db, embeddingDim, options) {
       const storedDim = getMeta(db, "embeddingDim");
       if (storedDim && storedDim !== String(embeddingDim)) {
         backupBeforeEmbeddingDimChange(options?.dataDir, storedDim, String(embeddingDim));
-        try {
-          db.exec("DELETE FROM embeddings");
-        } catch {}
+        bestEffort(() => db.exec("DELETE FROM embeddings"), "delete embeddings on explicit dim change");
         setMeta(db, "hasEmbeddings", "0");
       }
       setMeta(db, "embeddingDim", String(embeddingDim));
@@ -15637,9 +16636,9 @@ function handleVersionUpgrade(db) {
   if (storedVersion === undefined || storedVersion === "" || storedVersion === String(DB_VERSION))
     return [];
   let usageBackup = [];
-  try {
+  bestEffort(() => {
     usageBackup = db.prepare("SELECT * FROM usage_events").all();
-  } catch {}
+  }, "usage_events table may not exist in older versions");
   db.exec("DROP TABLE IF EXISTS utility_scores");
   db.exec("DROP TABLE IF EXISTS utility_scores_scoped");
   db.exec("DROP INDEX IF EXISTS idx_utility_scores_scoped_entry_id");
@@ -15756,7 +16755,7 @@ function deleteIndexDirState(db, dirPath) {
   db.prepare("DELETE FROM index_dir_state WHERE dir_path = ?").run(dirPath);
 }
 function deleteIndexDirStatesByStashDir(db, stashDir) {
-  db.prepare("DELETE FROM index_dir_state WHERE dir_path = ? OR dir_path LIKE ?").run(stashDir, `${stashDir}${path9.sep}%`);
+  db.prepare("DELETE FROM index_dir_state WHERE dir_path = ? OR dir_path LIKE ?").run(stashDir, `${stashDir}${path11.sep}%`);
 }
 function upsertEntry(db, entryKey, dirPath, filePath, stashDir, entry, searchText) {
   const stmts = getUpsertStmts(db);
@@ -15791,14 +16790,14 @@ function getUpsertStmts(db) {
   return stmts;
 }
 function ensureDerivedFromColumn(db) {
-  try {
+  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)");
-  } catch {}
+  }, "entries table may not exist on a brand-new DB before CREATE \u2014 caller is responsible");
 }
 function getDerivedForParent(db, parentRef) {
   if (!parentRef)
@@ -15838,7 +16837,7 @@ function getPositiveFeedbackCountsByIds(db, ids) {
   for (let i = 0;i < ids.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = ids.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    try {
+    bestEffort(() => {
       const rows = db.prepare(`SELECT entry_id, COUNT(*) AS cnt
              FROM usage_events
              WHERE event_type = 'feedback'
@@ -15850,7 +16849,7 @@ function getPositiveFeedbackCountsByIds(db, ids) {
           result.set(row.entry_id, row.cnt);
         }
       }
-    } catch {}
+    }, "usage_events table may be missing on legacy DBs \u2014 treat as zero counts");
   }
   return result;
 }
@@ -15875,33 +16874,19 @@ function deleteRelatedRows(db, ids) {
   for (let i = 0;i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    try {
-      db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
-    } catch {}
-    try {
-      db.prepare(`DELETE FROM entries_fts_dirty WHERE entry_id IN (${placeholders})`).run(...chunk);
-    } catch {}
+    bestEffort(() => db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk), "fts table may not exist on a brand-new db");
+    bestEffort(() => db.prepare(`DELETE FROM entries_fts_dirty WHERE entry_id IN (${placeholders})`).run(...chunk), "fts dirty table is created lazily by upsertEntry");
   }
   for (let i = 0;i < numericIds.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = numericIds.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
-    try {
-      db.prepare(`DELETE FROM embeddings WHERE id IN (${placeholders})`).run(...chunk);
-    } catch {}
+    bestEffort(() => db.prepare(`DELETE FROM embeddings WHERE id IN (${placeholders})`).run(...chunk), "delete embeddings for entries");
     if (vecAvail) {
-      try {
-        db.prepare(`DELETE FROM entries_vec WHERE id IN (${placeholders})`).run(...chunk);
-      } catch {}
+      bestEffort(() => db.prepare(`DELETE FROM entries_vec WHERE id IN (${placeholders})`).run(...chunk), "delete entries_vec for entries");
     }
-    try {
-      db.prepare(`DELETE FROM utility_scores WHERE entry_id IN (${placeholders})`).run(...chunk);
-    } catch {}
-    try {
-      db.prepare(`DELETE FROM utility_scores_scoped WHERE entry_id IN (${placeholders})`).run(...chunk);
-    } catch {}
-    try {
-      db.prepare(`DELETE FROM usage_events WHERE entry_id IN (${placeholders})`).run(...chunk);
-    } catch {}
+    bestEffort(() => db.prepare(`DELETE FROM utility_scores WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores for entries");
+    bestEffort(() => db.prepare(`DELETE FROM utility_scores_scoped WHERE entry_id IN (${placeholders})`).run(...chunk), "delete utility_scores_scoped for entries");
+    bestEffort(() => db.prepare(`DELETE FROM usage_events WHERE entry_id IN (${placeholders})`).run(...chunk), "delete usage_events for entries");
   }
 }
 function deleteEntriesByIds(db, ids) {
@@ -15964,12 +16949,12 @@ function upsertEmbedding(db, entryId, embedding) {
   const buf = float32Buffer(embedding);
   db.prepare("INSERT OR REPLACE INTO embeddings (id, embedding) VALUES (?, ?)").run(entryId, buf);
   if (isVecAvailable(db)) {
-    try {
+    bestEffort(() => {
       db.transaction(() => {
         db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
         db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
       })();
-    } catch {}
+    }, "vec table unavailable or constraint failure");
   }
   return true;
 }
@@ -16173,6 +17158,10 @@ function getEntryCount(db) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();
   return row.cnt;
 }
+function getEmbeddableEntryCount(db) {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();
+  return row.cnt;
+}
 function getEmbeddingCount(db) {
   const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
   return row.cnt;
@@ -16194,6 +17183,17 @@ function getEntriesByDir(db, dirPath) {
   const rows = db.prepare("SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE dir_path = ?").all(dirPath);
   return parseEntryRows(rows, "getEntriesByDir");
 }
+function getEntryIdByFilePath(db, filePath) {
+  const row = db.prepare("SELECT id FROM entries WHERE file_path = ? LIMIT 1").get(filePath);
+  return row?.id;
+}
+function getEntryFilePathById(db, id) {
+  const row = db.prepare("SELECT file_path FROM entries WHERE id = ?").get(id);
+  return row?.file_path;
+}
+function getEntryRefRowsForStashRoot(db, stashRoot) {
+  return db.prepare("SELECT file_path, entry_json FROM entries WHERE stash_dir = ? OR file_path LIKE ?").all(stashRoot, `${stashRoot}%`);
+}
 function getUtilityScore(db, entryId) {
   const row = db.prepare("SELECT entry_id, utility, show_count, search_count, select_rate, last_used_at, updated_at FROM utility_scores WHERE entry_id = ?").get(entryId);
   if (!row)
@@ -16303,18 +17303,16 @@ function upsertLlmCacheEntry(db, assetRef, bodyHash, resultJson, cacheVariant =
         updated_at  = excluded.updated_at`).run(assetRef, cacheVariant, bodyHash, resultJson, Date.now());
 }
 function clearStaleCacheEntries(db) {
-  try {
+  bestEffort(() => {
     db.exec(`
       DELETE FROM llm_enrichment_cache
       WHERE asset_ref NOT IN (SELECT file_path FROM entries)
         AND asset_ref NOT IN (SELECT entry_key FROM entries)
     `);
-  } catch {}
+  }, "llm_enrichment_cache may not exist in very old DBs opened without ensureSchema");
 }
 function computeBodyHash(body) {
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(body);
-  return hasher.digest("hex");
+  return sha256Hex(body);
 }
 function getRetrievalCounts(db, refs) {
   if (refs.length === 0)
@@ -16369,7 +17367,6 @@ function getAllEntriesForEmbedding(db) {
   return db.prepare(`
       SELECT e.id, e.search_text AS searchText, e.entry_key AS entryKey, e.file_path AS filePath FROM entries e
       WHERE NOT EXISTS (SELECT 1 FROM embeddings b WHERE b.id = e.id)
-        AND e.entry_type != 'vault'
     `).all();
 }
 function upsertWorkflowDocument(db, entryId, doc, content) {
@@ -16433,7 +17430,7 @@ function applyFeedbackToUtilityScore(db, entryId, positiveCount, negativeCount)
   return { previousUtility, nextUtility, crossedReviewThreshold };
 }
 function relinkUsageEvents(db) {
-  try {
+  bestEffort(() => {
     db.exec(`
       UPDATE usage_events
       SET entry_id = NULL
@@ -16448,7 +17445,7 @@ function relinkUsageEvents(db) {
       )
       WHERE entry_id IS NULL AND entry_ref IS NOT NULL
     `);
-  } catch {}
+  }, "usage_events table may not exist yet during entry_id re-resolution");
 }
 function upsertRegistryIndexCache(db, registryUrl, indexJson, opts) {
   db.prepare(`
@@ -16471,20 +17468,44 @@ function getRegistryIndexCache(db, registryUrl, maxAgeMs = 3600000) {
     return;
   return { indexJson: row.index_json, etag: row.etag, lastModified: row.last_modified };
 }
+function collectTagSetFromEntries(db, entryType) {
+  const tags = new Set;
+  const stmt = entryType ? db.prepare("SELECT entry_json FROM entries WHERE entry_type = ?") : db.prepare("SELECT entry_json FROM entries");
+  const rows = entryType ? stmt.all(entryType) : stmt.all();
+  for (const row of rows) {
+    let parsed;
+    try {
+      parsed = JSON.parse(row.entry_json);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(parsed.tags))
+      continue;
+    for (const tag of parsed.tags) {
+      if (typeof tag === "string" && tag.trim().length > 0) {
+        tags.add(tag.trim().toLowerCase());
+      }
+    }
+  }
+  return tags;
+}
 var DB_VERSION = 17, EMBEDDING_DIM = 384, GRAPH_SCHEMA_VERSION = 3, vecStatus, VEC_DOCS_URL = "https://github.com/itlackey/akm/blob/main/docs/configuration.md#sqlite-vec-extension", VEC_FALLBACK_THRESHOLD = 1e4, vecInitWarnedDbs, SQLITE_CHUNK_SIZE = 500, upsertStmtsByDb, FEEDBACK_LR = 0.1, FEEDBACK_REWARD_POSITIVE = 1, FEEDBACK_REWARD_NEGATIVE = 0, MAX_NEG_DELTA_PER_CALL = 0.15, UTILITY_REVIEW_THRESHOLD = 0.5, HIGH_UTILITY_THRESHOLD = 0.5;
 var init_db = __esm(() => {
   init_asset_ref();
+  init_best_effort();
   init_paths();
   init_state_db();
   init_warn();
   init_types();
+  init_runtime();
+  init_database();
   init_db_backup();
   vecStatus = new WeakMap;
   vecInitWarnedDbs = new WeakSet;
   upsertStmtsByDb = new WeakMap;
 });
 
-// src/indexer/graph-db.ts
+// src/indexer/db/graph-db.ts
 var exports_graph_db = {};
 __export(exports_graph_db, {
   resolveEntryIdForPath: () => resolveEntryIdForPath,
@@ -16496,12 +17517,12 @@ __export(exports_graph_db, {
   loadGraphEntitiesByEntry: () => loadGraphEntitiesByEntry,
   deleteStoredGraph: () => deleteStoredGraph
 });
-import fs11 from "fs";
+import fs13 from "fs";
 function withReadableGraphDb(db, fn) {
   if (db)
     return fn(db);
   const dbPath = getDbPath();
-  if (!fs11.existsSync(dbPath))
+  if (!fs13.existsSync(dbPath))
     throw new Error("GRAPH_DB_MISSING");
   const opened = openExistingDatabase(dbPath);
   try {
@@ -16721,7 +17742,8 @@ function loadStoredGraphMeta(stashPath, db) {
             cacheHits: row.cache_hits,
             cacheMisses: row.cache_misses,
             truncationCount: row.truncation_count,
-            failureCount: row.failure_count
+            failureCount: row.failure_count,
+            retryAttempts: 0
           }
         };
       } catch {
@@ -16821,10 +17843,17 @@ var init_graph_db = __esm(() => {
 
 // scripts/migrate-storage.ts
 init_paths();
-import fs12 from "fs";
-import os from "os";
-import path10 from "path";
+import fs14 from "fs";
+import os3 from "os";
+import path12 from "path";
 import readline from "readline";
+
+// 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");
@@ -16841,12 +17870,12 @@ function parseFromArg() {
   return val;
 }
 var FROM_VERSION = parseFromArg();
-var dataDir = process.env.AKM_DATA_DIR?.trim() ?? (process.env.XDG_DATA_HOME?.trim() ? path10.join(process.env.XDG_DATA_HOME.trim(), "akm") : path10.join(os.homedir(), ".local", "share", "akm"));
-var stateDir = process.env.AKM_STATE_DIR?.trim() ?? (process.env.XDG_STATE_HOME?.trim() ? path10.join(process.env.XDG_STATE_HOME.trim(), "akm") : path10.join(os.homedir(), ".local", "state", "akm"));
+var dataDir = process.env.AKM_DATA_DIR?.trim() ?? (process.env.XDG_DATA_HOME?.trim() ? path12.join(process.env.XDG_DATA_HOME.trim(), "akm") : path12.join(os3.homedir(), ".local", "share", "akm"));
+var stateDir = process.env.AKM_STATE_DIR?.trim() ?? (process.env.XDG_STATE_HOME?.trim() ? path12.join(process.env.XDG_STATE_HOME.trim(), "akm") : path12.join(os3.homedir(), ".local", "state", "akm"));
 var cacheDir = getCacheDir();
 var configDir = getConfigDir();
-var stateDbPath = path10.join(dataDir, "state.db");
-var indexDbPath = path10.join(dataDir, "index.db");
+var stateDbPath = path12.join(dataDir, "state.db");
+var indexDbPath = path12.join(dataDir, "index.db");
 var PATHS = {
   cacheDir,
   configDir,
@@ -16857,92 +17886,97 @@ var PATHS = {
 };
 var versionReports = [];
 function ensureDir(dir) {
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs14.existsSync(dir)) {
+    fs14.mkdirSync(dir, { recursive: true });
   }
 }
 function copyAndVerify(src, dest) {
-  fs12.copyFileSync(src, dest);
-  const srcStat = fs12.statSync(src);
-  const destStat = fs12.statSync(dest);
+  fs14.copyFileSync(src, dest);
+  const srcStat = fs14.statSync(src);
+  const destStat = fs14.statSync(dest);
   return destStat.size === srcStat.size;
 }
-function copyDirRecursive(src, dest) {
+function copyTree(src, dest, opts) {
   let copied = 0;
+  let skipped = 0;
   let failed = 0;
   ensureDir(dest);
-  for (const entry of fs12.readdirSync(src, { withFileTypes: true })) {
-    const srcEntry = path10.join(src, entry.name);
-    const destEntry = path10.join(dest, entry.name);
+  for (const entry of fs14.readdirSync(src, { withFileTypes: true })) {
+    const srcEntry = path12.join(src, entry.name);
+    const destEntry = path12.join(dest, entry.name);
     if (entry.isDirectory()) {
-      const sub = copyDirRecursive(srcEntry, destEntry);
+      const sub = copyTree(srcEntry, destEntry, opts);
       copied += sub.copied;
+      skipped += sub.skipped;
       failed += sub.failed;
-    } else {
-      try {
-        if (copyAndVerify(srcEntry, destEntry)) {
-          copied++;
-        } else {
-          failed++;
-        }
-      } catch {
+      continue;
+    }
+    if (!opts.clobber && fs14.existsSync(destEntry)) {
+      skipped++;
+      continue;
+    }
+    try {
+      if (copyAndVerify(srcEntry, destEntry)) {
+        copied++;
+      } else {
         failed++;
       }
+    } catch {
+      failed++;
     }
   }
-  return { copied, failed };
+  return { copied, skipped, failed };
 }
 function countFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      count += countFilesRecursive(path10.join(dir, entry.name));
+      count += countFilesRecursive(path12.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 = path10.join(ctx.paths.cacheDir, filename);
-  const dest = path10.join(ctx.paths.dataDir, filename);
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: filename, status: "skipped", detail: "source not found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, filename);
+  const dest = path12.join(ctx.paths.dataDir, filename);
+  if (!fs14.existsSync(src)) {
+    return { name: filename, status: "skipped", detail: "source not found" };
   }
-  if (fs12.existsSync(dest)) {
-    ctx.recordStep({ name: filename, status: "skipped", detail: "destination already exists" });
-    return;
+  if (fs14.existsSync(dest)) {
+    return { name: filename, status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({ name: filename, status: "success", detail: `[dry-run] would copy ${src} \u2192 ${dest}` });
-    return;
+    return { name: filename, status: "success", detail: `[dry-run] would copy ${src} \u2192 ${dest}` };
   }
   ensureDir(ctx.paths.dataDir);
   const ok = copyAndVerify(src, dest);
   if (ok) {
-    ctx.recordStep({
+    return {
       name: filename,
       status: "success",
       detail: `copied to ${dest} \u2014 source left at ${src} (delete manually when ready)`
-    });
-  } else {
-    ctx.recordStep({ name: filename, status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` });
+    };
   }
+  return { name: filename, status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
 }
 async function migrateEventsJsonl(ctx) {
-  const src = path10.join(ctx.paths.cacheDir, "events.jsonl");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "events.jsonl \u2192 state.db", status: "skipped", detail: "source not found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, "events.jsonl");
+  if (!fs14.existsSync(src)) {
+    return { name: "events.jsonl \u2192 state.db", status: "skipped", detail: "source not found" };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({
+    return {
       name: "events.jsonl \u2192 state.db",
       status: "success",
       detail: `[dry-run] would import ${src} into ${ctx.paths.stateDbPath}`
-    });
-    return;
+    };
   }
   try {
     ensureDir(ctx.paths.dataDir);
@@ -16964,46 +17998,43 @@ async function migrateEventsJsonl(ctx) {
         throw err;
       }
       const dedupNote = skipped > 0 ? ` (${skipped} duplicate(s) skipped \u2014 re-run idempotency)` : "";
-      ctx.recordStep({
+      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);
-    ctx.recordStep({ name: "events.jsonl \u2192 state.db", status: "failed", detail: msg });
+    return { name: "events.jsonl \u2192 state.db", status: "failed", detail: msg };
   }
 }
 function migrateTaskHistory(ctx) {
-  const src = path10.join(ctx.paths.cacheDir, "tasks", "history");
-  const dest = path10.join(ctx.paths.stateDir, "tasks", "history");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "tasks/history/", status: "skipped", detail: "source directory not found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, "tasks", "history");
+  const dest = path12.join(ctx.paths.stateDir, "tasks", "history");
+  if (!fs14.existsSync(src)) {
+    return { name: "tasks/history/", status: "skipped", detail: "source directory not found" };
   }
   try {
-    const files = fs12.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+    const files = fs14.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
     if (files.length === 0) {
-      ctx.recordStep({ name: "tasks/history/", status: "skipped", detail: "no *.jsonl files found in source directory" });
-      return;
+      return { name: "tasks/history/", status: "skipped", detail: "no *.jsonl files found in source directory" };
     }
     if (ctx.dryRun) {
-      ctx.recordStep({
+      return {
         name: "tasks/history/",
         status: "success",
         detail: `[dry-run] would copy ${files.length} *.jsonl file(s) from ${src} \u2192 ${dest}`
-      });
-      return;
+      };
     }
     ensureDir(dest);
     let copied = 0;
     let failed = 0;
     for (const file of files) {
-      const srcFile = path10.join(src, file);
-      const destFile = path10.join(dest, file);
+      const srcFile = path12.join(src, file);
+      const destFile = path12.join(dest, file);
       try {
         if (copyAndVerify(srcFile, destFile)) {
           copied++;
@@ -17015,119 +18046,107 @@ function migrateTaskHistory(ctx) {
       }
     }
     if (failed === 0) {
-      ctx.recordStep({
+      return {
         name: "tasks/history/",
         status: "success",
         detail: `copied ${copied} files to ${dest} \u2014 sources left in place (delete manually when ready)`
-      });
-    } else {
-      ctx.recordStep({
-        name: "tasks/history/",
-        status: "failed",
-        detail: `copied ${copied}/${files.length} files; ${failed} failed`
-      });
+      };
     }
+    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);
-    ctx.recordStep({ name: "tasks/history/", status: "failed", detail: msg });
+    return { name: "tasks/history/", status: "failed", detail: msg };
   }
 }
 function migrateLockfile(ctx) {
-  const src = path10.join(ctx.paths.configDir, "akm.lock");
-  const dest = path10.join(ctx.paths.dataDir, "akm.lock");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "akm.lock", status: "skipped", detail: "source not found" });
-    return;
+  const src = path12.join(ctx.paths.configDir, "akm.lock");
+  const dest = path12.join(ctx.paths.dataDir, "akm.lock");
+  if (!fs14.existsSync(src)) {
+    return { name: "akm.lock", status: "skipped", detail: "source not found" };
   }
-  if (fs12.existsSync(dest)) {
-    ctx.recordStep({ name: "akm.lock", status: "skipped", detail: "destination already exists" });
-    return;
+  if (fs14.existsSync(dest)) {
+    return { name: "akm.lock", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({ name: "akm.lock", status: "success", detail: `[dry-run] would copy ${src} \u2192 ${dest}` });
-    return;
+    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) {
-    ctx.recordStep({
+    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.`
-    });
-  } else {
-    ctx.recordStep({ name: "akm.lock", status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` });
+    };
   }
+  return { name: "akm.lock", status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
 }
 function migrateConfigBackups(ctx) {
-  const src = path10.join(ctx.paths.cacheDir, "config-backups");
-  const dest = path10.join(ctx.paths.dataDir, "config-backups");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "config-backups/", status: "skipped", detail: "source directory not found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, "config-backups");
+  const dest = path12.join(ctx.paths.dataDir, "config-backups");
+  if (!fs14.existsSync(src)) {
+    return { name: "config-backups/", status: "skipped", detail: "source directory not found" };
   }
-  if (fs12.existsSync(dest)) {
-    ctx.recordStep({ name: "config-backups/", status: "skipped", detail: "destination already exists" });
-    return;
+  if (fs14.existsSync(dest)) {
+    return { name: "config-backups/", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
     let srcCount = 0;
     try {
       srcCount = countFilesRecursive(src);
     } catch {}
-    ctx.recordStep({
+    return {
       name: "config-backups/",
       status: "success",
       detail: `[dry-run] would recursively copy ${srcCount} file(s) from ${src} \u2192 ${dest}`
-    });
-    return;
+    };
   }
   try {
     const srcCount = countFilesRecursive(src);
-    const { copied, failed } = copyDirRecursive(src, dest);
-    const destCount = fs12.existsSync(dest) ? countFilesRecursive(dest) : 0;
+    const { copied, failed } = copyTree(src, dest, { clobber: true });
+    const destCount = fs14.existsSync(dest) ? countFilesRecursive(dest) : 0;
     if (failed === 0 && destCount === srcCount) {
-      ctx.recordStep({
+      return {
         name: "config-backups/",
         status: "success",
         detail: `copied ${copied} files to ${dest} \u2014 sources left in place (delete manually when ready)`
-      });
-    } else {
-      ctx.recordStep({
-        name: "config-backups/",
-        status: "failed",
-        detail: `file count mismatch: source ${srcCount}, destination ${destCount}; ${failed} copy errors`
-      });
+      };
     }
+    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);
-    ctx.recordStep({ name: "config-backups/", status: "failed", detail: msg });
+    return { name: "config-backups/", status: "failed", detail: msg };
   }
 }
 async function migrateTaskHistoryToDb(ctx) {
-  const src = path10.join(ctx.paths.cacheDir, "tasks", "history");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "tasks/history/ \u2192 state.db", status: "skipped", detail: "source directory not found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, "tasks", "history");
+  if (!fs14.existsSync(src)) {
+    return { name: "tasks/history/ \u2192 state.db", status: "skipped", detail: "source directory not found" };
   }
-  const files = fs12.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+  const files = fs14.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
   if (files.length === 0) {
-    ctx.recordStep({
+    return {
       name: "tasks/history/ \u2192 state.db",
       status: "skipped",
       detail: "no *.jsonl files found in source directory"
-    });
-    return;
+    };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({
+    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}`
-    });
-    return;
+    };
   }
   try {
     ensureDir(ctx.paths.dataDir);
@@ -17137,8 +18156,8 @@ async function migrateTaskHistoryToDb(ctx) {
     let failed = 0;
     try {
       for (const file of files) {
-        const filePath = path10.join(src, file);
-        const text = fs12.readFileSync(filePath, "utf8");
+        const filePath = path12.join(src, file);
+        const text = fs14.readFileSync(filePath, "utf8");
         const lines = text.split(`
 `).filter((l) => l.trim().length > 0);
         db.exec("BEGIN");
@@ -17180,33 +18199,30 @@ async function migrateTaskHistoryToDb(ctx) {
       db.close();
     }
     if (failed === 0) {
-      ctx.recordStep({
+      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)`
-      });
-    } else {
-      ctx.recordStep({
-        name: "tasks/history/ \u2192 state.db",
-        status: "failed",
-        detail: `imported ${imported} row(s); ${failed} line(s) could not be parsed`
-      });
+      };
     }
+    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);
-    ctx.recordStep({ name: "tasks/history/ \u2192 state.db", status: "failed", detail: msg });
+    return { name: "tasks/history/ \u2192 state.db", status: "failed", detail: msg };
   }
 }
 function noteRegistryIndexCache(ctx) {
-  const src = path10.join(ctx.paths.cacheDir, "registry-index");
-  if (!fs12.existsSync(src)) {
-    ctx.recordStep({ name: "registry-index/ (note)", status: "skipped", detail: "no old $CACHE/registry-index/ directory found" });
-    return;
+  const src = path12.join(ctx.paths.cacheDir, "registry-index");
+  if (!fs14.existsSync(src)) {
+    return { name: "registry-index/ (note)", status: "skipped", detail: "no old $CACHE/registry-index/ directory found" };
   }
-  const legacyFiles = fs12.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
+  const legacyFiles = fs14.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
   if (legacyFiles.length === 0) {
-    ctx.recordStep({ name: "registry-index/ (note)", status: "skipped", detail: "no old *.json cache files found" });
-    return;
+    return { name: "registry-index/ (note)", status: "skipped", detail: "no old *.json cache files found" };
   }
   if (!ctx.dryRun) {
     console.log(`
@@ -17214,57 +18230,57 @@ function noteRegistryIndexCache(ctx) {
         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) => `          ${path10.join(src, f)}`).join(`
+` + legacyFiles.map((f) => `          ${path12.join(src, f)}`).join(`
 `));
   }
-  ctx.recordStep({
+  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 = [
-      path10.join(paths.cacheDir, "index.db"),
-      path10.join(paths.cacheDir, "workflow.db"),
-      path10.join(paths.cacheDir, "events.jsonl"),
-      path10.join(paths.cacheDir, "tasks", "history"),
-      path10.join(paths.configDir, "akm.lock"),
-      path10.join(paths.cacheDir, "config-backups"),
-      path10.join(paths.cacheDir, "registry-index")
+      path12.join(paths.cacheDir, "index.db"),
+      path12.join(paths.cacheDir, "workflow.db"),
+      path12.join(paths.cacheDir, "events.jsonl"),
+      path12.join(paths.cacheDir, "tasks", "history"),
+      path12.join(paths.configDir, "akm.lock"),
+      path12.join(paths.cacheDir, "config-backups"),
+      path12.join(paths.cacheDir, "registry-index")
     ];
-    return candidates.some((p) => fs12.existsSync(p));
+    return candidates.some((p) => fs14.existsSync(p));
   },
-  run: async (ctx) => {
-    migrateDb(ctx, "index.db");
-    migrateDb(ctx, "workflow.db");
-    await migrateEventsJsonl(ctx);
-    migrateTaskHistory(ctx);
-    migrateLockfile(ctx);
-    migrateConfigBackups(ctx);
-    await migrateTaskHistoryToDb(ctx);
-    noteRegistryIndexCache(ctx);
-  }
+  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 [
-    path10.join(ctx.paths.cacheDir, "graph-snapshot.json"),
-    path10.join(ctx.paths.dataDir, "graph-snapshot.json"),
-    path10.join(ctx.paths.dataDir, "graph-export.json")
+    path12.join(ctx.paths.cacheDir, "graph-snapshot.json"),
+    path12.join(ctx.paths.dataDir, "graph-snapshot.json"),
+    path12.join(ctx.paths.dataDir, "graph-export.json")
   ];
 }
 function findLegacyGraphFile(ctx) {
   for (const candidate of legacyGraphCandidatePaths(ctx)) {
-    if (fs12.existsSync(candidate) && fs12.statSync(candidate).isFile())
+    if (fs14.existsSync(candidate) && fs14.statSync(candidate).isFile())
       return candidate;
   }
-  const graphDir = path10.join(ctx.paths.cacheDir, "graph");
-  if (fs12.existsSync(graphDir) && fs12.statSync(graphDir).isDirectory()) {
+  const graphDir = path12.join(ctx.paths.cacheDir, "graph");
+  if (fs14.existsSync(graphDir) && fs14.statSync(graphDir).isDirectory()) {
     try {
-      const json = fs12.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path10.join(graphDir, f));
+      const json = fs14.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path12.join(graphDir, f));
       if (json.length > 0)
         return json[0];
     } catch {}
@@ -17298,43 +18314,38 @@ async function migrateGraphFileToDb(ctx) {
   const name = "Graph snapshot import";
   const legacyFile = findLegacyGraphFile(ctx);
   if (!legacyFile) {
-    ctx.recordStep({ name, status: "skipped", detail: "no legacy graph file found" });
-    return;
+    return { name, status: "skipped", detail: "no legacy graph file found" };
   }
-  if (!fs12.existsSync(ctx.paths.indexDbPath)) {
-    ctx.recordStep({
+  if (!fs14.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`
-    });
-    return;
+    };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({
+    return {
       name,
       status: "success",
       detail: `[dry-run] would parse ${legacyFile} and import into ${ctx.paths.indexDbPath} graph tables`
-    });
-    return;
+    };
   }
   try {
-    const raw = fs12.readFileSync(legacyFile, "utf8");
+    const raw = fs14.readFileSync(legacyFile, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      ctx.recordStep({ name, status: "failed", detail: `${legacyFile} is not valid JSON: ${msg}` });
-      return;
+      return { name, status: "failed", detail: `${legacyFile} is not valid JSON: ${msg}` };
     }
     const validation = validateGraphSnapshot(parsed);
     if (!validation.ok) {
-      ctx.recordStep({
+      return {
         name,
         status: "failed",
         detail: `${legacyFile} does not match expected GraphSnapshot shape: ${validation.reason}`
-      });
-      return;
+      };
     }
     const snapshot = validation.data;
     const { openExistingDatabase: openExistingDatabase2, closeDatabase: closeDatabase2 } = await Promise.resolve().then(() => (init_db(), exports_db));
@@ -17382,51 +18393,48 @@ async function migrateGraphFileToDb(ctx) {
       const importedCount = db.prepare("SELECT COUNT(*) AS cnt FROM graph_files WHERE stash_root = ?").get(snapshot.stashRoot).cnt;
       const meta = loadStoredGraphMeta2(snapshot.stashRoot, db);
       if (!meta) {
-        ctx.recordStep({
+        return {
           name,
           status: "failed",
           detail: `import did not produce a graph_meta row for stash ${snapshot.stashRoot}`
-        });
-        return;
+        };
       }
       if (importedCount === 0) {
-        ctx.recordStep({
+        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.`
-        });
-        return;
+        };
       }
       const renamed = `${legacyFile}.migrated`;
       try {
-        fs12.renameSync(legacyFile, renamed);
+        fs14.renameSync(legacyFile, renamed);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        ctx.recordStep({
+        return {
           name,
           status: "success",
           detail: `imported graph for ${snapshot.stashRoot} into ${ctx.paths.indexDbPath} but could not rename ${legacyFile}: ${msg}`
-        });
-        return;
+        };
       }
-      ctx.recordStep({
+      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 {
       closeDatabase2(db);
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    ctx.recordStep({ name, status: "failed", detail: msg });
+    return { name, status: "failed", detail: msg };
   }
 }
 function resolvePrimaryStashDir(configDirPath) {
   try {
-    const cfgPath = path10.join(configDirPath, "config.json");
-    if (fs12.existsSync(cfgPath)) {
-      const cfg = JSON.parse(fs12.readFileSync(cfgPath, "utf8"));
+    const cfgPath = path12.join(configDirPath, "config.json");
+    if (fs14.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
       if (typeof cfg.stashDir === "string" && cfg.stashDir.length > 0)
         return cfg.stashDir;
     }
@@ -17435,8 +18443,8 @@ function resolvePrimaryStashDir(configDirPath) {
 }
 function countEnvFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-    const full = path10.join(dir, entry.name);
+  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+    const full = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       count += countEnvFilesRecursive(full);
     } else if (entry.name === ".env" || entry.name.endsWith(".env")) {
@@ -17445,46 +18453,16 @@ function countEnvFilesRecursive(dir) {
   }
   return count;
 }
-function copyDirNoClobber(src, dest) {
-  let copied = 0;
-  let skipped = 0;
-  let failed = 0;
-  ensureDir(dest);
-  for (const entry of fs12.readdirSync(src, { withFileTypes: true })) {
-    const srcEntry = path10.join(src, entry.name);
-    const destEntry = path10.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const sub = copyDirNoClobber(srcEntry, destEntry);
-      copied += sub.copied;
-      skipped += sub.skipped;
-      failed += sub.failed;
-      continue;
-    }
-    if (fs12.existsSync(destEntry)) {
-      skipped++;
-      continue;
-    }
-    try {
-      if (copyAndVerify(srcEntry, destEntry))
-        copied++;
-      else
-        failed++;
-    } catch {
-      failed++;
-    }
-  }
-  return { copied, skipped, failed };
-}
 function chmodTreeSecure(dir) {
   const isWin = process.platform === "win32";
   try {
-    fs12.chmodSync(dir, 448);
+    fs14.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 fs12.readdirSync(dir, { withFileTypes: true })) {
-    const full = path10.join(dir, entry.name);
+  for (const entry of fs14.readdirSync(dir, { withFileTypes: true })) {
+    const full = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       const sub = chmodTreeSecure(full);
       if (!sub.ok)
@@ -17492,8 +18470,8 @@ function chmodTreeSecure(dir) {
       continue;
     }
     try {
-      fs12.chmodSync(full, 384);
-      if (!isWin && (fs12.statSync(full).mode & 511) !== 384) {
+      fs14.chmodSync(full, 384);
+      if (!isWin && (fs14.statSync(full).mode & 511) !== 384) {
         return { ok: false, detail: `mode verification failed for ${full}` };
       }
     } catch (err) {
@@ -17506,59 +18484,52 @@ function chmodTreeSecure(dir) {
 async function migrateVaultsToEnv(ctx) {
   const name = "vaults/ \u2192 env/";
   const stashDir = resolvePrimaryStashDir(ctx.paths.configDir);
-  const vaultsDir = path10.join(stashDir, "vaults");
-  const envDir = path10.join(stashDir, "env");
-  const marker = path10.join(vaultsDir, ".migrated");
-  if (!fs12.existsSync(vaultsDir)) {
-    ctx.recordStep({ name, status: "skipped", detail: `no vaults/ directory under ${stashDir}` });
-    return;
+  const vaultsDir = path12.join(stashDir, "vaults");
+  const envDir = path12.join(stashDir, "env");
+  const marker = path12.join(vaultsDir, MIGRATED_MARKER);
+  if (!fs14.existsSync(vaultsDir)) {
+    return { name, status: "skipped", detail: `no vaults/ directory under ${stashDir}` };
   }
-  if (fs12.existsSync(marker)) {
-    ctx.recordStep({ name, status: "skipped", detail: "already migrated (.migrated marker present)" });
-    return;
+  if (fs14.existsSync(marker)) {
+    return { name, status: "skipped", detail: "already migrated (.migrated marker present)" };
   }
   const vaultEnvCount = countEnvFilesRecursive(vaultsDir);
   if (vaultEnvCount === 0) {
-    ctx.recordStep({ name, status: "skipped", detail: "vaults/ has no .env files to migrate" });
-    return;
+    return { name, status: "skipped", detail: "vaults/ has no .env files to migrate" };
   }
   if (ctx.dryRun) {
-    ctx.recordStep({
+    return {
       name,
       status: "success",
       detail: `[dry-run] would copy ${vaultEnvCount} .env file(s) ${vaultsDir} \u2192 ${envDir}, chmod 0600/0700, and write ${marker}`
-    });
-    return;
+    };
   }
   try {
-    const { copied, skipped, failed } = copyDirNoClobber(vaultsDir, envDir);
+    const { copied, skipped, failed } = copyTree(vaultsDir, envDir, { clobber: false });
     if (failed > 0) {
-      ctx.recordStep({ name, status: "failed", detail: `${failed} file(s) failed to copy; env/ left as-is, no marker written` });
-      return;
+      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) {
-      ctx.recordStep({ name, status: "failed", detail: chmodRes.detail ?? "permission tightening failed" });
-      return;
+      return { name, status: "failed", detail: chmodRes.detail ?? "permission tightening failed" };
     }
     const envEnvCount = countEnvFilesRecursive(envDir);
     if (envEnvCount < vaultEnvCount) {
-      ctx.recordStep({
+      return {
         name,
         status: "failed",
         detail: `post-copy count ${envEnvCount} < source ${vaultEnvCount}; no marker written`
-      });
-      return;
+      };
     }
-    fs12.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
+    fs14.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
 `, { mode: 384 });
-    ctx.recordStep({
+    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) {
-    ctx.recordStep({ name, status: "failed", detail: err instanceof Error ? err.message : String(err) });
+    return { name, status: "failed", detail: err instanceof Error ? err.message : String(err) };
   }
 }
 var v08To09Migration = {
@@ -17567,10 +18538,10 @@ var v08To09Migration = {
   isNeeded: (_paths) => {
     return true;
   },
-  run: async (ctx) => {
-    await migrateGraphFileToDb(ctx);
-    await migrateVaultsToEnv(ctx);
-  }
+  steps: [
+    { id: "graph-snapshot-import", title: "Graph snapshot import", run: migrateGraphFileToDb },
+    { id: "vaults-to-env", title: "vaults/ \u2192 env/", run: migrateVaultsToEnv }
+  ]
 };
 var MIGRATIONS2 = [v07To08Migration, v08To09Migration];
 async function confirm() {
@@ -17656,12 +18627,12 @@ task_history: task_id PK).
 Migration complete. No errors.`);
   console.log(`
 Old files at the original locations are safe to delete manually after verifying akm works:
-  ${path10.join(cacheDir, "index.db")}
-  ${path10.join(cacheDir, "workflow.db")}
-  ${path10.join(cacheDir, "events.jsonl")}
-  ${path10.join(cacheDir, "tasks", "history")}
-  ${path10.join(cacheDir, "config-backups")}
-  ${path10.join(configDir, "akm.lock")}
+  ${path12.join(cacheDir, "index.db")}
+  ${path12.join(cacheDir, "workflow.db")}
+  ${path12.join(cacheDir, "events.jsonl")}
+  ${path12.join(cacheDir, "tasks", "history")}
+  ${path12.join(cacheDir, "config-backups")}
+  ${path12.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
@@ -17673,7 +18644,7 @@ Next step \u2014 repopulate graph data (if migrating from 0.7):
   docs/migration/v0.7-to-v0.8.md#graph-extraction-will-re-run-after-upgrade.
 `);
 }
-async function runMigrations2(opts = { dryRun: DRY_RUN }) {
+async function runMigrations3(opts = { dryRun: DRY_RUN }) {
   const paths = opts.paths ?? PATHS;
   const reports = [];
   const migrations = filteredMigrations();
@@ -17702,7 +18673,7 @@ async function runMigrations2(opts = { dryRun: DRY_RUN }) {
       continue;
     }
     try {
-      await migration.run(ctx);
+      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);
@@ -17741,7 +18712,7 @@ async function main() {
     console.log(`[dry-run] No changes will be written.
 `);
   }
-  const reports = await runMigrations2({ dryRun: DRY_RUN, paths: PATHS });
+  const reports = await runMigrations3({ dryRun: DRY_RUN, paths: PATHS });
   versionReports.push(...reports);
   printGroupedSummary();
   if (DRY_RUN) {
@@ -17754,7 +18725,7 @@ var invokedDirectly = (() => {
     if (!entry)
       return false;
     const here = new URL(import.meta.url).pathname;
-    return path10.resolve(entry) === here;
+    return path12.resolve(entry) === here;
   } catch {
     return false;
   }
@@ -17763,6 +18734,6 @@ if (invokedDirectly) {
   await main();
 }
 export {
-  runMigrations2 as runMigrations,
+  runMigrations3 as runMigrations,
   MIGRATIONS2 as MIGRATIONS
 };