akm-cli 0.9.0-rc.2 → 0.9.0-rc.4

package/dist/scripts/migrate-storage.js

@@ -7558,21 +7558,169 @@ var init_markdown = __esm(() => {
   init_frontmatter();
 });
 
-// src/storage/database.ts
+// src/core/paths.ts
+import path from "node:path";
+function isUnderBunTest(env) {
+  return env.BUN_TEST === "1" || env.NODE_ENV === "test";
+}
+function isTransientStashPath(p) {
+  return p.startsWith("/tmp/") || p === "/tmp" || p.startsWith("/var/tmp/") || p === "/var/tmp" || p.startsWith("/private/tmp/") || p.startsWith("/private/var/folders/") || p.startsWith("/var/folders/");
+}
+function testIsolationError() {
+  return new ConfigError("Refusing to resolve data directory under bun test: neither XDG_DATA_HOME nor AKM_DATA_DIR is set. " + "This guards against tests writing into the developer's real ~/.local/share/akm. " + "Set XDG_DATA_HOME (or AKM_DATA_DIR) to a mktemp-d directory in this test's env block.", "TEST_ISOLATION_MISSING");
+}
+function getConfigDir(env = process.env, platform = process.platform) {
+  const override = env.AKM_CONFIG_DIR?.trim();
+  if (override)
+    return override;
+  if (platform === "win32") {
+    const appData = env.APPDATA?.trim();
+    if (appData)
+      return path.join(appData, "akm");
+  } else {
+    const xdgConfigHome2 = env.XDG_CONFIG_HOME?.trim();
+    if (xdgConfigHome2)
+      return path.join(xdgConfigHome2, "akm");
+  }
+  const stashOverride = env.AKM_STASH_DIR?.trim();
+  if (stashOverride && isTransientStashPath(stashOverride)) {
+    return path.join(stashOverride, ".akm");
+  }
+  if (platform === "win32") {
+    const appData = env.APPDATA?.trim();
+    if (appData)
+      return path.join(appData, "akm");
+    const userProfile = env.USERPROFILE?.trim();
+    if (!userProfile) {
+      throw new ConfigError("Unable to determine config directory. Set APPDATA or USERPROFILE.", "CONFIG_DIR_UNRESOLVABLE");
+    }
+    return path.join(userProfile, "AppData", "Roaming", "akm");
+  }
+  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
+  if (xdgConfigHome)
+    return path.join(xdgConfigHome, "akm");
+  const home = env.HOME?.trim();
+  if (!home) {
+    throw new ConfigError("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.", "CONFIG_DIR_UNRESOLVABLE");
+  }
+  return path.join(home, ".config", "akm");
+}
+function getConfigPath(env = process.env) {
+  return path.join(getConfigDir(env), "config.json");
+}
+function getDataDir(env = process.env, platform = process.platform) {
+  const override = env.AKM_DATA_DIR?.trim();
+  if (override)
+    return override;
+  if (isUnderBunTest(env) && !env.XDG_DATA_HOME?.trim()) {
+    throw testIsolationError();
+  }
+  if (platform === "win32") {
+    const localAppData = env.LOCALAPPDATA?.trim();
+    if (localAppData)
+      return path.join(localAppData, "akm", "data");
+    const userProfile = env.USERPROFILE?.trim();
+    if (userProfile)
+      return path.join(userProfile, "AppData", "Local", "akm", "data");
+    const appData = env.APPDATA?.trim();
+    if (!appData) {
+      throw new ConfigError("Unable to determine data directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
+    }
+    return path.join(appData, "..", "Local", "akm", "data");
+  }
+  const xdgDataHome = env.XDG_DATA_HOME?.trim();
+  if (xdgDataHome)
+    return path.join(xdgDataHome, "akm");
+  const home = env.HOME?.trim();
+  if (!home)
+    return path.join("/tmp", "akm-data");
+  return path.join(home, ".local", "share", "akm");
+}
+function getDbPath(env = process.env) {
+  return path.join(getDataDir(env), "index.db");
+}
+function getMaintenanceBarrierPath() {
+  return path.join(getDataDir(), "maintenance.barrier.lock");
+}
+var init_paths = __esm(() => {
+  init_common();
+  init_errors();
+});
+
+// src/core/migration-operation.ts
+import crypto from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+function installationId() {
+  return crypto.createHash("sha256").update(path2.resolve(path2.dirname(getConfigPath()))).update("\x00").update(path2.resolve(getDataDir())).digest("hex").slice(0, 24);
+}
+function getMigrationOperationRoot() {
+  return path2.join(getDataDir(), "backups", "migrations", installationId());
+}
+function getMigrationRestoreJournalPath() {
+  return path2.join(getMigrationOperationRoot(), "restore-active.json");
+}
+function getMigrationApplyJournalPath() {
+  return path2.join(getMigrationOperationRoot(), "apply-active.json");
+}
+function assertNoPendingMigrationOperation() {
+  for (const [kind, journalPath] of [
+    ["restore", getMigrationRestoreJournalPath()],
+    ["migration apply", getMigrationApplyJournalPath()]
+  ]) {
+    if (fs2.existsSync(journalPath)) {
+      throw new ConfigError(`AKM ${kind} recovery is pending at ${journalPath}; refusing canonical config/database access until recovery completes.`, "INVALID_CONFIG_FILE");
+    }
+  }
+  const hook = afterPendingCheckHook;
+  afterPendingCheckHook = undefined;
+  hook?.();
+}
+var afterPendingCheckHook;
+var init_migration_operation = __esm(() => {
+  init_errors();
+  init_paths();
+});
+
+// src/runtime.ts
+import { createHash } from "node:crypto";
+import { createWriteStream, statfsSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function statfsType(path3) {
+  try {
+    return statfsSync(path3).type;
+  } catch {
+    return;
+  }
+}
+function bunGlobal() {
+  return globalThis.Bun;
+}
+var isBun, nodeRequire, mainPath;
+var init_runtime = __esm(() => {
+  isBun = !!process.versions?.bun;
+  nodeRequire = createRequire2(import.meta.url);
+  mainPath = isBun ? bunGlobal().main : process.argv[1];
+});
+
+// src/storage/database.ts
+import { createRequire as createRequire3 } from "node:module";
 function selectProvider() {
   const provider = PROVIDERS.find((p) => p.supported());
   if (!provider) {
-    throw new Error(`No storage provider supports the current runtime (${isBun ? "Bun" : "Node"}).`);
+    throw new Error(`No storage provider supports the current runtime (${isBun2 ? "Bun" : "Node"}).`);
   }
   return provider;
 }
-function openDatabase(path, opts) {
-  return selectProvider().open(path, opts);
+function openDatabase(path3, opts) {
+  return selectProvider().open(path3, opts);
 }
-function openBunDatabase(path, opts) {
+function openBunDatabase(path3, opts) {
   const { Database: BunDatabase } = loadBunSqlite();
-  const db = opts ? new BunDatabase(path, bunOptions(opts)) : new BunDatabase(path);
+  const db = opts ? new BunDatabase(path3, bunOptions(opts)) : new BunDatabase(path3);
   return db;
 }
 function bunOptions(opts) {
@@ -7585,7 +7733,7 @@ function bunOptions(opts) {
 }
 function loadBunSqlite() {
   if (!bunSqliteModule) {
-    bunSqliteModule = nodeRequire("bun:sqlite");
+    bunSqliteModule = nodeRequire2("bun:sqlite");
   }
   return bunSqliteModule;
 }
@@ -7593,7 +7741,7 @@ function loadBetterSqlite3() {
   if (!betterSqlite3Ctor) {
     let mod;
     try {
-      mod = nodeRequire("better-sqlite3");
+      mod = nodeRequire2("better-sqlite3");
     } catch (err) {
       throw new Error(`akm could not load 'better-sqlite3', the SQLite driver it needs on Node.js.
 ` + `  • Reinstall akm with a working C/C++ build toolchain so its optional
@@ -7605,14 +7753,14 @@ function loadBetterSqlite3() {
   }
   return betterSqlite3Ctor;
 }
-function openNodeDatabase(path, opts) {
+function openNodeDatabase(path3, 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(path, options) : new BetterSqlite3(path);
+  const db = opts ? new BetterSqlite3(path3, options) : new BetterSqlite3(path3);
   return {
     prepare: db.prepare.bind(db),
     exec: db.exec.bind(db),
@@ -7624,83 +7772,52 @@ function openNodeDatabase(path, opts) {
     close: db.close.bind(db)
   };
 }
-var isBun, nodeRequire, bunSqliteProvider, nodeSqliteProvider, PROVIDERS, bunSqliteModule, betterSqlite3Ctor;
+var isBun2, nodeRequire2, bunSqliteProvider, nodeSqliteProvider, PROVIDERS, bunSqliteModule, betterSqlite3Ctor;
 var init_database = __esm(() => {
-  isBun = !!process.versions?.bun;
-  nodeRequire = createRequire2(import.meta.url);
+  isBun2 = !!process.versions?.bun;
+  nodeRequire2 = createRequire3(import.meta.url);
   bunSqliteProvider = {
     name: "bun:sqlite",
-    supported: () => isBun,
+    supported: () => isBun2,
     open: openBunDatabase
   };
   nodeSqliteProvider = {
     name: "better-sqlite3",
-    supported: () => !isBun,
+    supported: () => !isBun2,
     open: openNodeDatabase
   };
   PROVIDERS = [bunSqliteProvider, nodeSqliteProvider];
 });
 
-// src/runtime.ts
-import { createHash } from "node:crypto";
-import { createWriteStream, statfsSync } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-function sha256Hex(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-function statfsType(path) {
-  try {
-    return statfsSync(path).type;
-  } catch {
-    return;
-  }
-}
-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 = createRequire3(import.meta.url);
-  mainPath = isBun2 ? bunGlobal().main : process.argv[1];
-});
-
 // src/core/file-lock.ts
 import { randomUUID } from "node:crypto";
-import fs2 from "node:fs";
-import path from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 function readLockSnapshot(lockPath) {
   let fd;
   try {
-    fd = fs2.openSync(lockPath, "r");
+    fd = fs3.openSync(lockPath, "r");
   } catch (err) {
     if (err.code === "ENOENT")
       return;
     throw err;
   }
   try {
-    const rawContent = fs2.readFileSync(fd, "utf8");
-    const stat = fs2.fstatSync(fd);
+    const rawContent = readTextFileDescriptorWithLimit(fd, MAX_LOCK_METADATA_BYTES, "Lock metadata", lockPath);
+    const stat = fs3.fstatSync(fd);
     return {
       rawContent,
       identity: { dev: stat.dev, ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs }
     };
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
 function sameIdentity(left, right) {
   return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs;
 }
 function operationMutexPath(lockPath) {
-  return path.join(path.dirname(lockPath), `.${path.basename(lockPath)}.operations.sensitive`);
+  return path3.join(path3.dirname(lockPath), `.${path3.basename(lockPath)}.operations.sensitive`);
 }
 function withLockOperationMutex(lockPath, run) {
   const db = openDatabase(operationMutexPath(lockPath));
@@ -7732,7 +7849,7 @@ function withLockOperationMutex(lockPath, run) {
 }
 function tryAcquireLockRaw(lockPath, payload) {
   try {
-    fs2.writeFileSync(lockPath, payload, { flag: "wx" });
+    fs3.writeFileSync(lockPath, payload, { flag: "wx" });
   } catch (err) {
     if (err.code === "EEXIST")
       return;
@@ -7753,7 +7870,7 @@ function tryAcquireLockRaw(lockPath, payload) {
 }
 function releaseLockRaw(lockPath) {
   try {
-    fs2.unlinkSync(lockPath);
+    fs3.unlinkSync(lockPath);
   } catch {}
 }
 function tryAcquireLockSync(lockPath, payload) {
@@ -7802,7 +7919,7 @@ function reclaimStaleLock(lockPath, probe, options) {
     }
     const quarantinePath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
     try {
-      fs2.renameSync(lockPath, quarantinePath);
+      fs3.renameSync(lockPath, quarantinePath);
     } catch (err) {
       if (err.code === "ENOENT")
         return false;
@@ -7816,7 +7933,7 @@ function reclaimStaleLock(lockPath, probe, options) {
     }
     if (!quarantined || quarantined.rawContent !== expectedContent || !sameIdentity(quarantined.identity, expectedIdentity)) {
       try {
-        fs2.linkSync(quarantinePath, lockPath);
+        fs3.linkSync(quarantinePath, lockPath);
       } catch (err) {
         if (err.code !== "EEXIST")
           throw err;
@@ -7826,7 +7943,7 @@ function reclaimStaleLock(lockPath, probe, options) {
     }
     options?.afterQuarantineVerified?.();
     try {
-      fs2.unlinkSync(quarantinePath);
+      fs3.unlinkSync(quarantinePath);
       return true;
     } catch (err) {
       if (err.code === "ENOENT")
@@ -7837,7 +7954,7 @@ function reclaimStaleLock(lockPath, probe, options) {
 }
 function releaseLock(ownership) {
   const { lockPath } = ownership;
-  if (!fs2.existsSync(lockPath) && !fs2.existsSync(operationMutexPath(lockPath)))
+  if (!fs3.existsSync(lockPath) && !fs3.existsSync(operationMutexPath(lockPath)))
     return;
   withLockOperationMutex(lockPath, () => {
     let current;
@@ -7872,245 +7989,7 @@ var init_file_lock = __esm(() => {
   init_common();
 });
 
-// src/core/paths.ts
-import path2 from "node:path";
-function isUnderBunTest(env) {
-  return env.BUN_TEST === "1" || env.NODE_ENV === "test";
-}
-function isTransientStashPath(p) {
-  return p.startsWith("/tmp/") || p === "/tmp" || p.startsWith("/var/tmp/") || p === "/var/tmp" || p.startsWith("/private/tmp/") || p.startsWith("/private/var/folders/") || p.startsWith("/var/folders/");
-}
-function testIsolationError() {
-  return new ConfigError("Refusing to resolve data directory under bun test: neither XDG_DATA_HOME nor AKM_DATA_DIR is set. " + "This guards against tests writing into the developer's real ~/.local/share/akm. " + "Set XDG_DATA_HOME (or AKM_DATA_DIR) to a mktemp-d directory in this test's env block.", "TEST_ISOLATION_MISSING");
-}
-function getConfigDir(env = process.env, platform = process.platform) {
-  const override = env.AKM_CONFIG_DIR?.trim();
-  if (override)
-    return override;
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path2.join(appData, "akm");
-  } else {
-    const xdgConfigHome2 = env.XDG_CONFIG_HOME?.trim();
-    if (xdgConfigHome2)
-      return path2.join(xdgConfigHome2, "akm");
-  }
-  const stashOverride = env.AKM_STASH_DIR?.trim();
-  if (stashOverride && isTransientStashPath(stashOverride)) {
-    return path2.join(stashOverride, ".akm");
-  }
-  if (platform === "win32") {
-    const appData = env.APPDATA?.trim();
-    if (appData)
-      return path2.join(appData, "akm");
-    const userProfile = env.USERPROFILE?.trim();
-    if (!userProfile) {
-      throw new ConfigError("Unable to determine config directory. Set APPDATA or USERPROFILE.", "CONFIG_DIR_UNRESOLVABLE");
-    }
-    return path2.join(userProfile, "AppData", "Roaming", "akm");
-  }
-  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
-  if (xdgConfigHome)
-    return path2.join(xdgConfigHome, "akm");
-  const home = env.HOME?.trim();
-  if (!home) {
-    throw new ConfigError("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.", "CONFIG_DIR_UNRESOLVABLE");
-  }
-  return path2.join(home, ".config", "akm");
-}
-function getConfigPath(env = process.env) {
-  return path2.join(getConfigDir(env), "config.json");
-}
-function getCacheDir(env = process.env) {
-  const override = env.AKM_CACHE_DIR?.trim();
-  if (override)
-    return override;
-  if (IS_WINDOWS) {
-    const localAppData = env.LOCALAPPDATA?.trim();
-    if (localAppData)
-      return path2.join(localAppData, "akm");
-    const userProfile = env.USERPROFILE?.trim();
-    if (userProfile)
-      return path2.join(userProfile, "AppData", "Local", "akm");
-    const appData = env.APPDATA?.trim();
-    if (appData) {
-      return path2.join(appData, "..", "Local", "akm");
-    }
-  } else {
-    const xdgCacheHome = env.XDG_CACHE_HOME?.trim();
-    if (xdgCacheHome)
-      return path2.join(xdgCacheHome, "akm");
-  }
-  const stashOverride = env.AKM_STASH_DIR?.trim();
-  if (stashOverride && isTransientStashPath(stashOverride)) {
-    return path2.join(stashOverride, ".akm", "cache");
-  }
-  if (IS_WINDOWS) {
-    throw new ConfigError("Unable to determine cache directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
-  }
-  const home = env.HOME?.trim();
-  if (!home)
-    return path2.join("/tmp", "akm-cache");
-  return path2.join(home, ".cache", "akm");
-}
-function getDataDir(env = process.env, platform = process.platform) {
-  const override = env.AKM_DATA_DIR?.trim();
-  if (override)
-    return override;
-  if (isUnderBunTest(env) && !env.XDG_DATA_HOME?.trim()) {
-    throw testIsolationError();
-  }
-  if (platform === "win32") {
-    const localAppData = env.LOCALAPPDATA?.trim();
-    if (localAppData)
-      return path2.join(localAppData, "akm", "data");
-    const userProfile = env.USERPROFILE?.trim();
-    if (userProfile)
-      return path2.join(userProfile, "AppData", "Local", "akm", "data");
-    const appData = env.APPDATA?.trim();
-    if (!appData) {
-      throw new ConfigError("Unable to determine data directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
-    }
-    return path2.join(appData, "..", "Local", "akm", "data");
-  }
-  const xdgDataHome = env.XDG_DATA_HOME?.trim();
-  if (xdgDataHome)
-    return path2.join(xdgDataHome, "akm");
-  const home = env.HOME?.trim();
-  if (!home)
-    return path2.join("/tmp", "akm-data");
-  return path2.join(home, ".local", "share", "akm");
-}
-function getDbPath(env = process.env) {
-  return path2.join(getDataDir(env), "index.db");
-}
-function getMaintenanceBarrierPath() {
-  return path2.join(getDataDir(), "maintenance.barrier.lock");
-}
-function getWorkflowDbPath() {
-  return path2.join(getDataDir(), "workflow.db");
-}
-function getStateDbPathInDataDir() {
-  return path2.join(getDataDir(), "state.db");
-}
-var init_paths = __esm(() => {
-  init_common();
-  init_errors();
-});
-
 // src/core/config/config-io.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-function parseConfigText(text, sourcePath) {
-  const stripped = stripJsonComments(text);
-  const where = sourcePath ? ` at ${sourcePath}` : "";
-  let parsed;
-  try {
-    parsed = JSON.parse(stripped);
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    throw new ConfigError(`Failed to parse config JSON${where}: ${detail}`, "INVALID_CONFIG_FILE", "Edit the file to fix the JSON syntax error. Comments (// and /* */) are allowed; trailing commas are not.");
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new ConfigError(`Config file${where} must contain a JSON object at the root, got ${describeJsonRoot(parsed)}.`, "INVALID_CONFIG_FILE");
-  }
-  return parsed;
-}
-function describeJsonRoot(value) {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "an array";
-  if (typeof value === "string")
-    return "a string";
-  if (typeof value === "number")
-    return "a number";
-  if (typeof value === "boolean")
-    return "a boolean";
-  return typeof value;
-}
-function getConfigLockPath() {
-  return path3.join(getConfigDir(), "config.json.lck");
-}
-function sleepSyncMs(ms) {
-  sleepSync(ms);
-}
-function acquireConfigLock() {
-  const lockPath = getConfigLockPath();
-  try {
-    fs3.mkdirSync(path3.dirname(lockPath), { recursive: true });
-  } catch {}
-  for (let attempt = 0;attempt < CONFIG_LOCK_MAX_RETRIES; attempt++) {
-    try {
-      const ownership = tryAcquireLockSync(lockPath, createLockPayload());
-      if (ownership) {
-        return () => releaseLock(ownership);
-      }
-    } catch (error) {
-      throw new ConfigError(`Unable to acquire config lock at ${lockPath}: ${error instanceof Error ? error.message : String(error)}`, "INVALID_CONFIG_FILE");
-    }
-    const probe = probeLock(lockPath);
-    if (probe.state === "stale" && reclaimStaleLock(lockPath, probe)) {
-      continue;
-    }
-    if (attempt < CONFIG_LOCK_MAX_RETRIES - 1) {
-      sleepSyncMs(CONFIG_LOCK_RETRY_DELAY_MS);
-    }
-  }
-  throw new ConfigError(`Timed out waiting for config lock at ${lockPath}. Another AKM process may be updating config.`, "INVALID_CONFIG_FILE");
-}
-function withConfigLock(fn) {
-  const release = acquireConfigLock();
-  try {
-    return fn();
-  } finally {
-    release();
-  }
-}
-function stripJsonComments(text) {
-  let result = "";
-  let i = 0;
-  let inString = false;
-  while (i < text.length) {
-    if (inString) {
-      if (text[i] === "\\") {
-        result += text[i] + (text[i + 1] ?? "");
-        i += 2;
-        continue;
-      }
-      if (text[i] === '"') {
-        inString = false;
-      }
-      result += text[i];
-      i++;
-      continue;
-    }
-    if (text[i] === '"') {
-      inString = true;
-      result += text[i];
-      i++;
-      continue;
-    }
-    if (text[i] === "/" && text[i + 1] === "/") {
-      while (i < text.length && text[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (text[i] === "/" && text[i + 1] === "*") {
-      i += 2;
-      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
-        i++;
-      i += 2;
-      continue;
-    }
-    result += text[i];
-    i++;
-  }
-  return result;
-}
-var CONFIG_LOCK_MAX_RETRIES = 10, CONFIG_LOCK_RETRY_DELAY_MS = 50;
 var init_config_io = __esm(() => {
   init_runtime();
   init_common();
@@ -14467,6 +14346,15 @@ var init_config_schema = __esm(() => {
         message: "feedbackDistillation was removed in 0.8.0 — use processes.distill.enabled instead. " + "It now controls both the orchestration gate and the LLM-call gate."
       });
     }
+    for (const [name, process2] of Object.entries(val)) {
+      if (!(name in IMPROVE_PROCESS_ENGINE_CAPABILITIES) && process2 !== null && typeof process2 === "object" && process2.enabled === true) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          path: [name],
+          message: `Unknown enabled improve process "${name}"`
+        });
+      }
+    }
   });
   ImproveProfileConfigSchema = exports_external.object({
     engine: engineName.optional(),
@@ -14895,328 +14783,7 @@ var init_config_schema = __esm(() => {
         });
       }
     }
-  });
-});
-
-// src/core/maintenance-barrier.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
-function tryAcquireMaintenanceBarrier() {
-  const lockPath = getMaintenanceBarrierPath();
-  fs6.mkdirSync(path6.dirname(lockPath), { recursive: true });
-  for (let attempt = 0;attempt < 2; attempt += 1) {
-    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: "maintenance-start" }));
-    if (ownership) {
-      return () => releaseLock(ownership);
-    }
-    const probe = probeLock(lockPath);
-    if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
-      return;
-  }
-  return;
-}
-function acquireMaintenanceBarrier() {
-  const release = tryAcquireMaintenanceBarrier();
-  if (release)
-    return release;
-  throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes.`, "INVALID_CONFIG_FILE");
-}
-function withMaintenanceStartBarrierSyncWait(run) {
-  if (heldBarrierContext.getStore()?.active)
-    return run();
-  const deadline = Date.now() + 5000;
-  let release = tryAcquireMaintenanceBarrier();
-  while (!release && Date.now() < deadline) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
-    release = tryAcquireMaintenanceBarrier();
-  }
-  if (!release)
-    release = acquireMaintenanceBarrier();
-  const ownership = { active: true };
-  try {
-    return heldBarrierContext.run(ownership, run);
-  } finally {
-    ownership.active = false;
-    release();
-  }
-}
-function acquireMaintenanceActivitySync(name) {
-  return withMaintenanceStartBarrierSyncWait(() => {
-    const directory = path6.join(path6.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
-    fs6.mkdirSync(directory, { recursive: true, mode: 448 });
-    const lockPath = path6.join(directory, `${name}-${process.pid}-${randomUUID2()}.lock`);
-    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
-    if (!ownership) {
-      throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
-    }
-    return () => releaseLock(ownership);
-  });
-}
-var heldBarrierContext;
-var init_maintenance_barrier = __esm(() => {
-  init_errors();
-  init_file_lock();
-  init_paths();
-  heldBarrierContext = new AsyncLocalStorage;
-});
-
-// src/core/migration-backup.ts
-import crypto from "node:crypto";
-import fs7 from "node:fs";
-import path7 from "node:path";
-function getMigrationBackupDir() {
-  return path7.join(getCacheDir(), "migration-backups", MIGRATION_BACKUP_VERSION);
-}
-function migrationBackupLockPath() {
-  return path7.join(getCacheDir(), "migration-backups", `${MIGRATION_BACKUP_VERSION}.lock`);
-}
-function expectedSourcePaths() {
-  return {
-    "config.json": getConfigPath(),
-    "state.db": getStateDbPathInDataDir(),
-    "workflow.db": getWorkflowDbPath()
-  };
-}
-function sha256File(filePath) {
-  return crypto.createHash("sha256").update(fs7.readFileSync(filePath)).digest("hex");
-}
-function ownerOnlyMode(filePath, directory) {
-  if (process.platform === "win32")
-    return true;
-  const mode = fs7.statSync(filePath).mode & 511;
-  return mode === (directory ? 448 : 384);
-}
-function fsyncDirectory(directory) {
-  try {
-    const fd = fs7.openSync(directory, "r");
-    try {
-      fs7.fsyncSync(fd);
-    } finally {
-      fs7.closeSync(fd);
-    }
-  } catch (error) {
-    const code = error.code;
-    if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EISDIR" && code !== "EPERM")
-      throw error;
-  }
-}
-function parseManifest(bundlePath) {
-  const manifestPath = path7.join(bundlePath, "manifest.json");
-  let value;
-  try {
-    value = JSON.parse(fs7.readFileSync(manifestPath, "utf8"));
-  } catch (error) {
-    throw new ConfigError(`Migration backup at ${bundlePath} is incomplete or unreadable: ${error instanceof Error ? error.message : String(error)}. Remove it only after preserving any recoverable files, then retry backup creation.`, "INVALID_CONFIG_FILE");
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new ConfigError(`Migration backup manifest at ${manifestPath} is invalid.`, "INVALID_CONFIG_FILE");
-  }
-  const manifest = value;
-  if (manifest.version !== MIGRATION_BACKUP_VERSION || typeof manifest.createdAt !== "string") {
-    throw new ConfigError(`Migration backup manifest at ${manifestPath} has an unsupported version.`, "INVALID_CONFIG_FILE");
-  }
-  const expected = expectedSourcePaths();
-  for (const name of ARTIFACT_NAMES) {
-    const artifact = manifest.artifacts?.[name];
-    if (!artifact || artifact.sourcePath !== expected[name] || typeof artifact.present !== "boolean" || !Number.isSafeInteger(artifact.byteSize) || artifact.byteSize < 0 || typeof artifact.createdAt !== "string" || (artifact.present ? typeof artifact.sha256 !== "string" || artifact.sha256.length !== 64 : artifact.sha256 !== null)) {
-      throw new ConfigError(`Migration backup manifest has an invalid ${name} entry.`, "INVALID_CONFIG_FILE");
-    }
-  }
-  return manifest;
-}
-function verifyMigrationBackup(bundlePath = getMigrationBackupDir()) {
-  if (!fs7.existsSync(bundlePath) || !fs7.statSync(bundlePath).isDirectory()) {
-    throw new ConfigError(`Migration backup does not exist at ${bundlePath}.`, "INVALID_CONFIG_FILE");
-  }
-  if (!ownerOnlyMode(bundlePath, true)) {
-    throw new ConfigError(`Migration backup directory ${bundlePath} must have mode 0700.`, "INVALID_CONFIG_FILE");
-  }
-  const manifest = parseManifest(bundlePath);
-  const expectedFiles = new Set(["manifest.json"]);
-  for (const name of ARTIFACT_NAMES) {
-    const artifact = manifest.artifacts[name];
-    const artifactPath = path7.join(bundlePath, name);
-    if (!artifact.present) {
-      if (fs7.existsSync(artifactPath)) {
-        throw new ConfigError(`Migration backup contains ${name}, but its manifest records it absent.`, "INVALID_CONFIG_FILE");
-      }
-      continue;
-    }
-    expectedFiles.add(name);
-    if (!fs7.existsSync(artifactPath) || !fs7.statSync(artifactPath).isFile()) {
-      throw new ConfigError(`Migration backup is missing ${artifactPath}.`, "INVALID_CONFIG_FILE");
-    }
-    if (!ownerOnlyMode(artifactPath, false)) {
-      throw new ConfigError(`Migration backup artifact ${artifactPath} must have mode 0600.`, "INVALID_CONFIG_FILE");
-    }
-    const stat = fs7.statSync(artifactPath);
-    if (stat.size !== artifact.byteSize || sha256File(artifactPath) !== artifact.sha256) {
-      throw new ConfigError(`Migration backup artifact ${artifactPath} failed checksum verification.`, "INVALID_CONFIG_FILE");
-    }
-  }
-  if (!ownerOnlyMode(path7.join(bundlePath, "manifest.json"), false)) {
-    throw new ConfigError(`Migration backup manifest must have mode 0600.`, "INVALID_CONFIG_FILE");
-  }
-  const extras = fs7.readdirSync(bundlePath).filter((name) => !expectedFiles.has(name));
-  if (extras.length > 0) {
-    throw new ConfigError(`Migration backup contains unexpected files: ${extras.join(", ")}.`, "INVALID_CONFIG_FILE");
-  }
-  return manifest;
-}
-function acquireMigrationBackupLock() {
-  const lockPath = migrationBackupLockPath();
-  fs7.mkdirSync(path7.dirname(lockPath), { recursive: true, mode: 448 });
-  fs7.chmodSync(path7.dirname(lockPath), 448);
-  for (let attempt = 0;attempt < 50; attempt += 1) {
-    const ownership = tryAcquireLockSync(lockPath, createLockPayload());
-    if (ownership)
-      return () => releaseLock(ownership);
-    const probe = probeLock(lockPath);
-    if (probe.state === "stale" && reclaimStaleLock(lockPath, probe)) {
-      continue;
-    }
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
-  }
-  throw new ConfigError(`Timed out waiting for migration backup lock at ${lockPath}.`, "INVALID_CONFIG_FILE");
-}
-function assertNotAlreadyCutOver() {
-  const configPath = getConfigPath();
-  let text;
-  try {
-    text = fs7.readFileSync(configPath, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-  const raw = parseConfigText(text, configPath);
-  if (raw.configVersion === CURRENT_CONFIG_VERSION) {
-    throw new ConfigError(`Refusing to create a pre-0.9 migration backup from an existing ${CURRENT_CONFIG_VERSION} config at ${configPath}. Restore the original migration bundle or pre-cutover config before retrying.`, "INVALID_CONFIG_FILE");
-  }
-}
-function copyRegularArtifact(source, destination) {
-  const stat = fs7.statSync(source);
-  if (!stat.isFile())
-    throw new ConfigError(`Backup source is not a regular file: ${source}`, "INVALID_CONFIG_FILE");
-  writeFileAtomic(destination, fs7.readFileSync(source), 384);
-  fs7.chmodSync(destination, 384);
-}
-function sqliteQuote(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function backupSqlite(source, destination) {
-  const stat = fs7.statSync(source);
-  if (!stat.isFile())
-    throw new ConfigError(`SQLite backup source is not a regular file: ${source}`, "INVALID_CONFIG_FILE");
-  const resolvedSource = path7.resolve(source);
-  const activityName = resolvedSource === path7.resolve(getWorkflowDbPath()) ? "workflow-db" : resolvedSource === path7.resolve(getStateDbPathInDataDir()) ? "state-db" : undefined;
-  const releaseActivity = activityName ? acquireMaintenanceActivitySync(activityName) : undefined;
-  let db;
-  try {
-    db = openDatabase(source);
-    db.exec("PRAGMA busy_timeout = 10000");
-    db.exec("PRAGMA wal_checkpoint(FULL)");
-    db.exec(`VACUUM INTO ${sqliteQuote(destination)}`);
-  } finally {
-    try {
-      db?.close();
-    } finally {
-      releaseActivity?.();
-    }
-  }
-  fs7.chmodSync(destination, 384);
-  const fd = fs7.openSync(destination, "r");
-  try {
-    fs7.fsyncSync(fd);
-  } finally {
-    fs7.closeSync(fd);
-  }
-}
-function createMigrationBackupUnlocked() {
-  const bundlePath = getMigrationBackupDir();
-  if (fs7.existsSync(bundlePath)) {
-    return { path: bundlePath, created: false, manifest: verifyMigrationBackup(bundlePath) };
-  }
-  assertNotAlreadyCutOver();
-  const parent = path7.dirname(bundlePath);
-  fs7.mkdirSync(parent, { recursive: true, mode: 448 });
-  fs7.chmodSync(parent, 448);
-  const temporary = path7.join(parent, `.0.9.0.tmp.${process.pid}.${crypto.randomBytes(8).toString("hex")}`);
-  fs7.mkdirSync(temporary, { mode: 448 });
-  const createdAt = new Date().toISOString();
-  const sources = expectedSourcePaths();
-  const artifacts = {};
-  try {
-    for (const name of ARTIFACT_NAMES) {
-      const sourcePath = sources[name];
-      const destination = path7.join(temporary, name);
-      let present = true;
-      try {
-        fs7.statSync(sourcePath);
-      } catch (error) {
-        if (error.code === "ENOENT")
-          present = false;
-        else
-          throw error;
-      }
-      if (present) {
-        if (name === "config.json")
-          copyRegularArtifact(sourcePath, destination);
-        else
-          backupSqlite(sourcePath, destination);
-      }
-      const byteSize = present ? fs7.statSync(destination).size : 0;
-      artifacts[name] = {
-        sourcePath,
-        present,
-        byteSize,
-        sha256: present ? sha256File(destination) : null,
-        createdAt
-      };
-    }
-    const manifest = { version: MIGRATION_BACKUP_VERSION, createdAt, artifacts };
-    writeFileAtomic(path7.join(temporary, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
-`, 384);
-    fs7.chmodSync(path7.join(temporary, "manifest.json"), 384);
-    fsyncDirectory(temporary);
-    fs7.renameSync(temporary, bundlePath);
-    fsyncDirectory(parent);
-    return { path: bundlePath, created: true, manifest: verifyMigrationBackup(bundlePath) };
-  } catch (error) {
-    fs7.rmSync(temporary, { recursive: true, force: true });
-    if (fs7.existsSync(bundlePath)) {
-      throw new ConfigError(`Migration backup creation raced with another writer and left ${bundlePath}. Verify or preserve it before retrying.`, "INVALID_CONFIG_FILE");
-    }
-    throw error;
-  }
-}
-function withMigrationBackupLock(fn) {
-  const release = acquireMigrationBackupLock();
-  try {
-    return fn();
-  } finally {
-    release();
-  }
-}
-function createMigrationBackup() {
-  return withConfigLock(() => withMigrationBackupLock(createMigrationBackupUnlocked));
-}
-function ensureMigrationBackup() {
-  return createMigrationBackup();
-}
-var MIGRATION_BACKUP_VERSION = "0.9.0", ARTIFACT_NAMES;
-var init_migration_backup = __esm(() => {
-  init_database();
-  init_common();
-  init_config_io();
-  init_config_schema();
-  init_errors();
-  init_file_lock();
-  init_maintenance_barrier();
-  init_paths();
-  ARTIFACT_NAMES = ["config.json", "state.db", "workflow.db"];
+  });
 });
 
 // src/core/config/deep-merge.ts
@@ -15396,7 +14963,7 @@ var init_engine_resolution = __esm(() => {
 });
 
 // src/core/warn.ts
-import fs8 from "node:fs";
+import fs6 from "node:fs";
 function isVerbose() {
   const env = process.env.AKM_VERBOSE?.trim().toLowerCase();
   if (env === "1" || env === "true" || env === "yes" || env === "on")
@@ -15411,7 +14978,7 @@ function appendToLogFile(level, args) {
   const ts = new Date().toISOString();
   const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
   try {
-    fs8.appendFileSync(logFilePath, `[${ts}] [${level}] ${msg}
+    fs6.appendFileSync(logFilePath, `[${ts}] [${level}] ${msg}
 `);
   } catch (e) {
     process.stderr.write(`[akm:warn] log-file write failed (${logFilePath}): ${e}
@@ -15456,11 +15023,11 @@ var init_warn = () => {};
 var init_config_sources = () => {};
 
 // src/core/config/config.ts
-import path8 from "node:path";
+import path6 from "node:path";
 var PROJECT_CONFIG_RELATIVE_PATH, INDEX_RESERVED_KEYS, PROJECT_CONFIG_DEPRECATION_WARNED;
 var init_config = __esm(() => {
   init_errors();
-  init_migration_backup();
+  init_migration_operation();
   init_config_io();
   init_config_schema();
   init_deep_merge();
@@ -15471,7 +15038,7 @@ var init_config = __esm(() => {
   init_config_types();
   init_config_schema();
   init_config_sources();
-  PROJECT_CONFIG_RELATIVE_PATH = path8.join(".akm", "config.json");
+  PROJECT_CONFIG_RELATIVE_PATH = path6.join(".akm", "config.json");
   INDEX_RESERVED_KEYS = new Set(["metadataEnhance", "stalenessDetection", "indexBodyOpening"]);
   PROJECT_CONFIG_DEPRECATION_WARNED = new Set;
 });
@@ -15494,11 +15061,11 @@ var init_metadata_contributors = __esm(() => {
 });
 
 // src/indexer/passes/metadata.ts
-import fs9 from "node:fs";
+import fs7 from "node:fs";
 function extractDescriptionFromComments(filePath) {
   let content;
   try {
-    content = fs9.readFileSync(filePath, "utf8");
+    content = fs7.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -15548,7 +15115,18 @@ var init_metadata = __esm(() => {
 });
 
 // src/core/asset/asset-ref.ts
-import path9 from "node:path";
+import path7 from "node:path";
+function makeAssetRef(type, name, origin) {
+  validateName(name);
+  const normalized = normalizeName(name);
+  const asset = `${type}:${normalized}`;
+  if (!origin)
+    return asset;
+  return `${origin}//${asset}`;
+}
+function refToString(ref) {
+  return makeAssetRef(ref.type, ref.name, ref.origin);
+}
 function parseAssetRef(ref) {
   const trimmed = ref.trim();
   if (!trimmed)
@@ -15586,8 +15164,8 @@ function validateName(name) {
     throw new UsageError("Null byte in asset name.", "MISSING_REQUIRED_ARGUMENT");
   if (/^[A-Za-z]:/.test(name))
     throw new UsageError("Windows drive path in asset name.", "MISSING_REQUIRED_ARGUMENT");
-  const normalized = path9.posix.normalize(name.replace(/\\/g, "/"));
-  if (path9.posix.isAbsolute(normalized))
+  const normalized = path7.posix.normalize(name.replace(/\\/g, "/"));
+  if (path7.posix.isAbsolute(normalized))
     throw new UsageError("Absolute path in asset name.", "MISSING_REQUIRED_ARGUMENT");
   if (normalized === ".." || normalized.startsWith("../")) {
     throw new UsageError("Path traversal in asset name.", "MISSING_REQUIRED_ARGUMENT");
@@ -15598,7 +15176,7 @@ function validateName(name) {
   }
 }
 function normalizeName(name) {
-  return path9.posix.normalize(name.replace(/\\/g, "/"));
+  return path7.posix.normalize(name.replace(/\\/g, "/"));
 }
 var TYPE_ALIASES;
 var init_asset_ref = __esm(() => {
@@ -15631,10 +15209,30 @@ var WORKFLOW_SCHEMA_VERSION = 1;
 // src/workflows/validator.ts
 function runSemanticChecks(draft, frontmatterData, frontmatterEndLine, errors3) {
   checkFrontmatterKeys(frontmatterData, frontmatterEndLine, errors3);
+  checkXrefs(frontmatterData.xrefs, frontmatterEndLine, errors3);
   checkStepIdFormat(draft, errors3);
   checkDuplicateStepIds(draft, errors3);
   checkResourceLimits(draft, errors3);
 }
+function checkXrefs(value, line, errors3) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value)) {
+    errors3.push({ line, message: 'Workflow frontmatter "xrefs" must be an array of canonical asset refs.' });
+    return;
+  }
+  for (const ref of value) {
+    try {
+      if (typeof ref !== "string" || refToString(parseAssetRef(ref)) !== ref)
+        throw new Error("non-canonical ref");
+    } catch {
+      errors3.push({
+        line,
+        message: `Workflow frontmatter "xrefs" contains an invalid or non-canonical ref: ${String(ref)}.`
+      });
+    }
+  }
+}
 function checkResourceLimits(draft, errors3) {
   if (draft.steps.length > WORKFLOW_MAX_STEPS) {
     errors3.push({ line: 1, message: `Workflow must contain at most ${WORKFLOW_MAX_STEPS} steps.` });
@@ -15657,7 +15255,7 @@ function checkFrontmatterKeys(data, fmEndLine, errors3) {
       continue;
     errors3.push({
       line: fmEndLine,
-      message: `Workflow frontmatter "${key}" is not supported. Use only: description, tags, params, name, updated, when_to_use.`
+      message: `Workflow frontmatter "${key}" is not supported. Use only: description, tags, params, name, updated, when_to_use, xrefs.`
     });
   }
 }
@@ -15687,9 +15285,10 @@ function checkDuplicateStepIds(draft, errors3) {
 }
 var STEP_ID_REGEX, ALLOWED_FRONTMATTER_KEYS;
 var init_validator = __esm(() => {
+  init_asset_ref();
   init_resource_limits();
   STEP_ID_REGEX = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-  ALLOWED_FRONTMATTER_KEYS = new Set(["description", "tags", "params", "name", "updated", "when_to_use"]);
+  ALLOWED_FRONTMATTER_KEYS = new Set(["description", "tags", "params", "name", "updated", "when_to_use", "xrefs"]);
 });
 
 // src/workflows/parser.ts
@@ -15701,7 +15300,7 @@ function parseWorkflow(markdown, source) {
     };
   }
   const errors3 = [];
-  const path10 = source.path;
+  const path8 = source.path;
   const lines = markdown.split(/\r?\n/);
   const totalLines = lines.length;
   const fmBlock = parseFrontmatterBlock(markdown);
@@ -15709,7 +15308,7 @@ function parseWorkflow(markdown, source) {
   const fmData = readFrontmatter(fmBlock?.frontmatter, errors3);
   const description = readDescription(fmData);
   const tags = readTags(fmData, errors3, frontmatterEndLine);
-  const parameters = readParameters(fmData, errors3, frontmatterEndLine, path10);
+  const parameters = readParameters(fmData, errors3, frontmatterEndLine, path8);
   const toc = parseMarkdownToc(markdown);
   const { title, titleLine } = extractTitle(toc.headings, errors3);
   for (const h of toc.headings) {
@@ -15726,7 +15325,7 @@ function parseWorkflow(markdown, source) {
       });
     }
   }
-  const steps = extractSteps(toc.headings, lines, totalLines, path10, errors3);
+  const steps = extractSteps(toc.headings, lines, totalLines, path8, errors3);
   if (steps.length === 0 && titleLine > 0) {
     errors3.push({
       line: titleLine,
@@ -15740,7 +15339,7 @@ function parseWorkflow(markdown, source) {
     ...tags ? { tags } : {},
     ...parameters ? { parameters } : {},
     steps,
-    source: { path: path10, lineCount: totalLines }
+    source: { path: path8, lineCount: totalLines }
   };
   runSemanticChecks(draft, fmData, frontmatterEndLine, errors3);
   if (errors3.length > 0) {
@@ -15775,7 +15374,7 @@ function extractTitle(headings, errors3) {
   }
   return { title, titleLine: first.line };
 }
-function extractSteps(headings, lines, totalLines, path10, errors3) {
+function extractSteps(headings, lines, totalLines, path8, errors3) {
   const steps = [];
   let sequenceIndex = 0;
   for (let i = 0;i < headings.length; i++) {
@@ -15791,11 +15390,11 @@ function extractSteps(headings, lines, totalLines, path10, errors3) {
       continue;
     }
     const stepEnd = Math.min(findNextSiblingOrParentLine(headings, i, 2) - 1, totalLines);
-    const stepSource = { path: path10, start: h.line, end: stepEnd };
+    const stepSource = { path: path8, start: h.line, end: stepEnd };
     const subsections = collectSubsections(headings, i, stepEnd);
     const stepIdSearchEnd = subsections.length > 0 ? subsections[0].headingLine - 1 : stepEnd;
     const stepId = scanStepId(lines, h.line + 1, stepIdSearchEnd, stepTitle, errors3);
-    const { instructions, completionCriteria } = collectStepBody(subsections, lines, path10, stepTitle, errors3);
+    const { instructions, completionCriteria } = collectStepBody(subsections, lines, path8, stepTitle, errors3);
     if (!stepId)
       continue;
     if (!instructions) {
@@ -15835,7 +15434,7 @@ function collectSubsections(headings, stepIndex, stepEnd) {
   }
   return subs;
 }
-function collectStepBody(subsections, lines, path10, stepTitle, errors3) {
+function collectStepBody(subsections, lines, path8, stepTitle, errors3) {
   let instructions;
   let completionCriteria;
   for (const sub of subsections) {
@@ -15857,7 +15456,7 @@ function collectStepBody(subsections, lines, path10, stepTitle, errors3) {
       }
       instructions = {
         text,
-        source: { path: path10, start: sub.bodyStart, end: sub.bodyEnd }
+        source: { path: path8, start: sub.bodyStart, end: sub.bodyEnd }
       };
       continue;
     }
@@ -15869,7 +15468,7 @@ function collectStepBody(subsections, lines, path10, stepTitle, errors3) {
         });
         continue;
       }
-      const items = collectBullets(lines, sub.bodyStart, sub.bodyEnd, path10);
+      const items = collectBullets(lines, sub.bodyStart, sub.bodyEnd, path8);
       if (items.length === 0) {
         errors3.push({
           line: sub.headingLine,
@@ -15918,7 +15517,7 @@ function scanStepId(lines, startLineInclusive, endLineInclusive, stepTitle, erro
   }
   return foundId;
 }
-function collectBullets(lines, startLineInclusive, endLineInclusive, path10) {
+function collectBullets(lines, startLineInclusive, endLineInclusive, path8) {
   const items = [];
   for (let lineNum = startLineInclusive;lineNum <= endLineInclusive; lineNum++) {
     const trimmed = (lines[lineNum - 1] ?? "").trim();
@@ -15929,7 +15528,7 @@ function collectBullets(lines, startLineInclusive, endLineInclusive, path10) {
       continue;
     items.push({
       text: match[1].trim(),
-      source: { path: path10, start: lineNum, end: lineNum }
+      source: { path: path8, start: lineNum, end: lineNum }
     });
   }
   return items;
@@ -15998,7 +15597,7 @@ function readTags(data, errors3, fmEndLine) {
   }
   return v.map((tag) => tag.trim());
 }
-function readParameters(data, errors3, fmEndLine, path10) {
+function readParameters(data, errors3, fmEndLine, path8) {
   const v = data.params;
   if (v === undefined || v === null)
     return;
@@ -16032,7 +15631,7 @@ function readParameters(data, errors3, fmEndLine, path10) {
     out.push({
       name: trimmedName,
       description: desc.trim(),
-      source: { path: path10, start: 1, end: fmEndLine }
+      source: { path: path8, start: 1, end: fmEndLine }
     });
   }
   return out.length > 0 ? out : undefined;
@@ -16105,9 +15704,9 @@ function parseWorkflowProgram(yamlText, source) {
   } catch (cause) {
     return { ok: false, errors: [{ line: 1, message: `YAML expansion failed: ${describeError(cause)}` }] };
   }
-  const lineAt = (path10) => {
-    for (let depth = path10.length;depth >= 0; depth--) {
-      const node = depth === 0 ? doc.contents : doc.getIn(path10.slice(0, depth), true);
+  const lineAt = (path8) => {
+    for (let depth = path8.length;depth >= 0; depth--) {
+      const node = depth === 0 ? doc.contents : doc.getIn(path8.slice(0, depth), true);
       const range = node?.range;
       if (range)
         return Math.max(1, lineCounter2.linePos(range[0]).line);
@@ -16119,10 +15718,10 @@ function parseWorkflowProgram(yamlText, source) {
     errors: errors3,
     lineAt,
     lineAtOffset: (offset) => Math.max(1, lineCounter2.linePos(offset).line),
-    nodeAt: (path10) => path10.length === 0 ? doc.contents : doc.getIn(path10, true),
-    refAt: (path10) => {
-      for (let depth = path10.length;depth >= 0; depth--) {
-        const node = depth === 0 ? doc.contents : doc.getIn(path10.slice(0, depth), true);
+    nodeAt: (path8) => path8.length === 0 ? doc.contents : doc.getIn(path8, true),
+    refAt: (path8) => {
+      for (let depth = path8.length;depth >= 0; depth--) {
+        const node = depth === 0 ? doc.contents : doc.getIn(path8.slice(0, depth), true);
         const range = node?.range;
         if (range) {
           const start = Math.max(1, lineCounter2.linePos(range[0]).line);
@@ -16132,9 +15731,9 @@ function parseWorkflowProgram(yamlText, source) {
       }
       return { path: source.path, start: 1, end: 1 };
     },
-    err: (path10, message) => errors3.push({ line: lineAt(path10), message }),
+    err: (path8, message) => errors3.push({ line: lineAt(path8), message }),
     errAtLine: (line, message) => errors3.push({ line, message }),
-    checkTemplates: (text, path10, label) => checkTemplates(ctx, text, path10, label)
+    checkTemplates: (text, path8, label) => checkTemplates(ctx, text, path8, label)
   };
   if (!isPlainRecord(root)) {
     return {
@@ -16214,32 +15813,32 @@ function parseParams(ctx, raw) {
 function parseDefaults(ctx, raw) {
   if (raw === undefined)
     return;
-  const path10 = ["defaults"];
+  const path8 = ["defaults"];
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `"defaults" must be a mapping with any of: ${DEFAULTS_KEYS.join(", ")}.`);
+    ctx.err(path8, `"defaults" must be a mapping with any of: ${DEFAULTS_KEYS.join(", ")}.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, DEFAULTS_KEYS, `"defaults"`);
+  checkUnknownKeys(ctx, raw, path8, DEFAULTS_KEYS, `"defaults"`);
   const defaults = {};
   if (raw.engine !== undefined) {
     if (typeof raw.engine === "string" && raw.engine.trim() !== "")
       defaults.engine = raw.engine.trim();
     else
-      ctx.err([...path10, "engine"], `"defaults.engine" must be a non-empty engine name.`);
+      ctx.err([...path8, "engine"], `"defaults.engine" must be a non-empty engine name.`);
   }
   if (raw.model !== undefined) {
     if (typeof raw.model === "string" && raw.model.trim() !== "")
       defaults.model = raw.model.trim();
     else
-      ctx.err([...path10, "model"], `"defaults.model" must be a non-empty string (a model alias or exact id).`);
+      ctx.err([...path8, "model"], `"defaults.model" must be a non-empty string (a model alias or exact id).`);
   }
-  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path10, "timeout"], `"defaults.timeout"`);
+  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path8, "timeout"], `"defaults.timeout"`);
   if (timeoutMs !== undefined)
     defaults.timeoutMs = timeoutMs;
-  const onError = parseEnumField(ctx, raw.on_error, [...path10, "on_error"], `"defaults.on_error"`, PROGRAM_ON_ERROR);
+  const onError = parseEnumField(ctx, raw.on_error, [...path8, "on_error"], `"defaults.on_error"`, PROGRAM_ON_ERROR);
   if (onError !== undefined)
     defaults.onError = onError;
-  const llm = parseLlmOverrides(ctx, raw.llm, [...path10, "llm"], `"defaults.llm"`);
+  const llm = parseLlmOverrides(ctx, raw.llm, [...path8, "llm"], `"defaults.llm"`);
   if (llm !== undefined)
     defaults.llm = llm;
   return Object.keys(defaults).length > 0 ? defaults : undefined;
@@ -16247,25 +15846,25 @@ function parseDefaults(ctx, raw) {
 function parseBudget(ctx, raw) {
   if (raw === undefined)
     return;
-  const path10 = ["budget"];
+  const path8 = ["budget"];
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `"budget" must be a mapping with any of: ${BUDGET_KEYS.join(", ")}.`);
+    ctx.err(path8, `"budget" must be a mapping with any of: ${BUDGET_KEYS.join(", ")}.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, BUDGET_KEYS, `"budget"`);
+  checkUnknownKeys(ctx, raw, path8, BUDGET_KEYS, `"budget"`);
   const budget = {};
   if (raw.max_tokens !== undefined) {
     if (typeof raw.max_tokens === "number" && Number.isInteger(raw.max_tokens) && raw.max_tokens >= 1) {
       budget.maxTokens = raw.max_tokens;
     } else {
-      ctx.err([...path10, "max_tokens"], `"budget.max_tokens" must be an integer >= 1.`);
+      ctx.err([...path8, "max_tokens"], `"budget.max_tokens" must be an integer >= 1.`);
     }
   }
   if (raw.max_units !== undefined) {
     if (typeof raw.max_units === "number" && Number.isInteger(raw.max_units) && raw.max_units >= 1 && raw.max_units <= WORKFLOW_MAX_MAP_EXPANSION) {
       budget.maxUnits = raw.max_units;
     } else {
-      ctx.err([...path10, "max_units"], `"budget.max_units" must be an integer from 1 through ${WORKFLOW_MAX_MAP_EXPANSION}.`);
+      ctx.err([...path8, "max_units"], `"budget.max_units" must be an integer from 1 through ${WORKFLOW_MAX_MAP_EXPANSION}.`);
     }
   }
   return Object.keys(budget).length > 0 ? budget : undefined;
@@ -16288,23 +15887,23 @@ function parseSteps(ctx, raw) {
   const seenIds = new Map;
   const routeChecks = [];
   raw.forEach((rawStep, index) => {
-    const path10 = ["steps", index];
+    const path8 = ["steps", index];
     if (!isPlainRecord(rawStep)) {
-      ctx.err(path10, `Step ${index + 1} must be a mapping with an "id" and exactly one of "unit", "map", or "route".`);
+      ctx.err(path8, `Step ${index + 1} must be a mapping with an "id" and exactly one of "unit", "map", or "route".`);
       return;
     }
     const label = typeof rawStep.id === "string" && rawStep.id !== "" ? `Step "${rawStep.id}"` : `Step ${index + 1}`;
-    checkUnknownKeys(ctx, rawStep, path10, STEP_KEYS, label);
+    checkUnknownKeys(ctx, rawStep, path8, STEP_KEYS, label);
     let id = "";
     if (typeof rawStep.id !== "string" || rawStep.id === "") {
-      ctx.err([...path10, "id"], `${label} requires a non-empty string "id".`);
+      ctx.err([...path8, "id"], `${label} requires a non-empty string "id".`);
     } else if (!PROGRAM_STEP_ID_PATTERN.test(rawStep.id)) {
-      ctx.err([...path10, "id"], `${label} has an invalid id "${rawStep.id}". A step id cannot be referenced from \${{ }} expressions ` + `unless it matches [A-Za-z_][A-Za-z0-9_-]* (a letter or underscore first, then letters, digits, ` + `underscores, or dashes; no dots, no leading digit) — otherwise \${{ steps.${rawStep.id}.output }} ` + `cannot be written.`);
+      ctx.err([...path8, "id"], `${label} has an invalid id "${rawStep.id}". A step id cannot be referenced from \${{ }} expressions ` + `unless it matches [A-Za-z_][A-Za-z0-9_-]* (a letter or underscore first, then letters, digits, ` + `underscores, or dashes; no dots, no leading digit) — otherwise \${{ steps.${rawStep.id}.output }} ` + `cannot be written.`);
     } else {
       id = rawStep.id;
       const firstIndex = seenIds.get(id);
       if (firstIndex !== undefined) {
-        ctx.err([...path10, "id"], `Duplicate step id "${id}" (first used by step ${firstIndex + 1}). Step ids must be unique.`);
+        ctx.err([...path8, "id"], `Duplicate step id "${id}" (first used by step ${firstIndex + 1}). Step ids must be unique.`);
       } else {
         seenIds.set(id, index);
       }
@@ -16313,22 +15912,22 @@ function parseSteps(ctx, raw) {
     if (rawStep.title !== undefined) {
       if (typeof rawStep.title === "string" && rawStep.title.trim() !== "") {
         title = rawStep.title.trim();
-        ctx.checkTemplates(rawStep.title, [...path10, "title"], `${label} "title"`);
+        ctx.checkTemplates(rawStep.title, [...path8, "title"], `${label} "title"`);
       } else {
-        ctx.err([...path10, "title"], `${label} "title" must be a non-empty string.`);
+        ctx.err([...path8, "title"], `${label} "title" must be a non-empty string.`);
       }
     }
     const declaredKinds = STEP_KINDS.filter((kind) => rawStep[kind] !== undefined);
     if (declaredKinds.length !== 1) {
       const found = declaredKinds.length === 0 ? "found none" : `found ${declaredKinds.join(" + ")}`;
-      ctx.err(path10, `${label} must declare exactly one of "unit", "map", or "route" (${found}).`);
-    }
-    const unit = rawStep.unit !== undefined ? parseUnit(ctx, rawStep.unit, [...path10, "unit"], label) : undefined;
-    const map = rawStep.map !== undefined ? parseMap(ctx, rawStep.map, [...path10, "map"], label) : undefined;
-    const route = rawStep.route !== undefined ? parseRoute(ctx, rawStep.route, [...path10, "route"], label, index, routeChecks) : undefined;
-    const output = parseSchemaObject(ctx, rawStep.output, [...path10, "output"], `${label} "output"`);
-    const gate = rawStep.gate !== undefined ? parseGate(ctx, rawStep.gate, [...path10, "gate"], label) : undefined;
-    const step = { id, source: ctx.refAt(path10) };
+      ctx.err(path8, `${label} must declare exactly one of "unit", "map", or "route" (${found}).`);
+    }
+    const unit = rawStep.unit !== undefined ? parseUnit(ctx, rawStep.unit, [...path8, "unit"], label) : undefined;
+    const map = rawStep.map !== undefined ? parseMap(ctx, rawStep.map, [...path8, "map"], label) : undefined;
+    const route = rawStep.route !== undefined ? parseRoute(ctx, rawStep.route, [...path8, "route"], label, index, routeChecks) : undefined;
+    const output = parseSchemaObject(ctx, rawStep.output, [...path8, "output"], `${label} "output"`);
+    const gate = rawStep.gate !== undefined ? parseGate(ctx, rawStep.gate, [...path8, "gate"], label) : undefined;
+    const step = { id, source: ctx.refAt(path8) };
     if (title !== undefined)
       step.title = title;
     if (declaredKinds.length === 1) {
@@ -16362,86 +15961,86 @@ function parseSteps(ctx, raw) {
   }
   return steps;
 }
-function parseUnit(ctx, raw, path10, stepLabel) {
+function parseUnit(ctx, raw, path8, stepLabel) {
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${stepLabel} "unit" must be a mapping with an "instructions" key.`);
+    ctx.err(path8, `${stepLabel} "unit" must be a mapping with an "instructions" key.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, UNIT_KEYS, `${stepLabel} "unit"`);
-  const unit = { instructions: "", source: ctx.refAt(path10) };
+  checkUnknownKeys(ctx, raw, path8, UNIT_KEYS, `${stepLabel} "unit"`);
+  const unit = { instructions: "", source: ctx.refAt(path8) };
   if (typeof raw.instructions === "string" && raw.instructions.trim() !== "") {
     unit.instructions = raw.instructions;
-    ctx.checkTemplates(raw.instructions, [...path10, "instructions"], `${stepLabel} "instructions"`);
+    ctx.checkTemplates(raw.instructions, [...path8, "instructions"], `${stepLabel} "instructions"`);
     if (utf8Bytes(raw.instructions) > WORKFLOW_MAX_INSTRUCTION_BYTES) {
-      ctx.err([...path10, "instructions"], `${stepLabel} "instructions" exceeds the 256 KiB resource limit.`);
+      ctx.err([...path8, "instructions"], `${stepLabel} "instructions" exceeds the 256 KiB resource limit.`);
     }
   } else {
-    ctx.err([...path10, "instructions"], `${stepLabel} "unit" requires non-empty string "instructions".`);
+    ctx.err([...path8, "instructions"], `${stepLabel} "unit" requires non-empty string "instructions".`);
   }
   if (raw.engine !== undefined) {
     if (typeof raw.engine === "string" && raw.engine.trim() !== "")
       unit.engine = raw.engine.trim();
     else
-      ctx.err([...path10, "engine"], `${stepLabel} "engine" must be a non-empty engine name.`);
+      ctx.err([...path8, "engine"], `${stepLabel} "engine" must be a non-empty engine name.`);
   }
   if (raw.model !== undefined) {
     if (typeof raw.model === "string" && raw.model.trim() !== "")
       unit.model = raw.model.trim();
     else
-      ctx.err([...path10, "model"], `${stepLabel} "model" must be a non-empty string (a model alias or exact id).`);
+      ctx.err([...path8, "model"], `${stepLabel} "model" must be a non-empty string (a model alias or exact id).`);
   }
-  const llm = parseLlmOverrides(ctx, raw.llm, [...path10, "llm"], `${stepLabel} "llm"`);
+  const llm = parseLlmOverrides(ctx, raw.llm, [...path8, "llm"], `${stepLabel} "llm"`);
   if (llm !== undefined)
     unit.llm = llm;
-  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path10, "timeout"], `${stepLabel} "timeout"`);
+  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path8, "timeout"], `${stepLabel} "timeout"`);
   if (timeoutMs !== undefined)
     unit.timeoutMs = timeoutMs;
-  const retry = parseRetry(ctx, raw.retry, [...path10, "retry"], stepLabel);
+  const retry = parseRetry(ctx, raw.retry, [...path8, "retry"], stepLabel);
   if (retry !== undefined)
     unit.retry = retry;
-  const onError = parseEnumField(ctx, raw.on_error, [...path10, "on_error"], `${stepLabel} "on_error"`, PROGRAM_ON_ERROR);
+  const onError = parseEnumField(ctx, raw.on_error, [...path8, "on_error"], `${stepLabel} "on_error"`, PROGRAM_ON_ERROR);
   if (onError !== undefined)
     unit.onError = onError;
-  const output = parseSchemaObject(ctx, raw.output, [...path10, "output"], `${stepLabel} unit "output"`);
+  const output = parseSchemaObject(ctx, raw.output, [...path8, "output"], `${stepLabel} unit "output"`);
   if (output !== undefined)
     unit.output = output;
   if (raw.env !== undefined) {
     if (Array.isArray(raw.env) && raw.env.every((entry) => typeof entry === "string" && entry.trim() !== "")) {
       unit.env = raw.env.map((entry) => entry.trim());
     } else {
-      ctx.err([...path10, "env"], `${stepLabel} "env" must be a list of non-empty env asset refs.`);
+      ctx.err([...path8, "env"], `${stepLabel} "env" must be a list of non-empty env asset refs.`);
     }
   }
-  const isolation = parseEnumField(ctx, raw.isolation, [...path10, "isolation"], `${stepLabel} "isolation"`, PROGRAM_ISOLATION_KINDS);
+  const isolation = parseEnumField(ctx, raw.isolation, [...path8, "isolation"], `${stepLabel} "isolation"`, PROGRAM_ISOLATION_KINDS);
   if (isolation !== undefined)
     unit.isolation = isolation;
   return unit;
 }
-function parseMap(ctx, raw, path10, stepLabel) {
+function parseMap(ctx, raw, path8, stepLabel) {
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${stepLabel} "map" must be a mapping with "over" and "unit" keys.`);
+    ctx.err(path8, `${stepLabel} "map" must be a mapping with "over" and "unit" keys.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, MAP_KEYS, `${stepLabel} "map"`);
+  checkUnknownKeys(ctx, raw, path8, MAP_KEYS, `${stepLabel} "map"`);
   let over = "";
   if (typeof raw.over === "string" && raw.over.trim() !== "") {
     over = raw.over.trim();
-    ctx.checkTemplates(raw.over, [...path10, "over"], `${stepLabel} "over"`);
+    ctx.checkTemplates(raw.over, [...path8, "over"], `${stepLabel} "over"`);
   } else {
-    ctx.err([...path10, "over"], `${stepLabel} "map" requires "over": a \${{ … }} expression naming the item list (e.g. \${{ steps.discover.output.files }}).`);
+    ctx.err([...path8, "over"], `${stepLabel} "map" requires "over": a \${{ … }} expression naming the item list (e.g. \${{ steps.discover.output.files }}).`);
   }
   let concurrency;
   if (raw.concurrency !== undefined) {
     if (typeof raw.concurrency === "number" && Number.isInteger(raw.concurrency) && raw.concurrency > 0) {
       concurrency = raw.concurrency;
     } else {
-      ctx.err([...path10, "concurrency"], `${stepLabel} "concurrency" must be a positive integer.`);
+      ctx.err([...path8, "concurrency"], `${stepLabel} "concurrency" must be a positive integer.`);
     }
   }
-  const reducer = parseEnumField(ctx, raw.reducer, [...path10, "reducer"], `${stepLabel} "reducer"`, PROGRAM_REDUCERS);
-  const unit = raw.unit !== undefined ? parseUnit(ctx, raw.unit, [...path10, "unit"], stepLabel) : undefined;
+  const reducer = parseEnumField(ctx, raw.reducer, [...path8, "reducer"], `${stepLabel} "reducer"`, PROGRAM_REDUCERS);
+  const unit = raw.unit !== undefined ? parseUnit(ctx, raw.unit, [...path8, "unit"], stepLabel) : undefined;
   if (raw.unit === undefined) {
-    ctx.err(path10, `${stepLabel} "map" requires a nested "unit" to fan out.`);
+    ctx.err(path8, `${stepLabel} "map" requires a nested "unit" to fan out.`);
   }
   if (unit === undefined)
     return;
@@ -16452,21 +16051,21 @@ function parseMap(ctx, raw, path10, stepLabel) {
     map.reducer = reducer;
   return map;
 }
-function parseRoute(ctx, raw, path10, stepLabel, stepIndex, routeChecks) {
+function parseRoute(ctx, raw, path8, stepLabel, stepIndex, routeChecks) {
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${stepLabel} "route" must be a mapping with "input" and "when" keys.`);
+    ctx.err(path8, `${stepLabel} "route" must be a mapping with "input" and "when" keys.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, ROUTE_KEYS, `${stepLabel} "route"`);
+  checkUnknownKeys(ctx, raw, path8, ROUTE_KEYS, `${stepLabel} "route"`);
   let input = "";
   if (typeof raw.input === "string" && raw.input.trim() !== "") {
     input = raw.input.trim();
-    ctx.checkTemplates(raw.input, [...path10, "input"], `${stepLabel} "route.input"`);
+    ctx.checkTemplates(raw.input, [...path8, "input"], `${stepLabel} "route.input"`);
   } else {
-    ctx.err([...path10, "input"], `${stepLabel} "route" requires "input": a \${{ … }} expression naming the value to route on.`);
+    ctx.err([...path8, "input"], `${stepLabel} "route" requires "input": a \${{ … }} expression naming the value to route on.`);
   }
   const check = { stepIndex, stepLabel, branches: [] };
-  const whenPath = [...path10, "when"];
+  const whenPath = [...path8, "when"];
   const whenNode = ctx.nodeAt(whenPath);
   if (raw.when === undefined || !isPlainRecord(raw.when)) {
     ctx.err(whenPath, `${stepLabel} "route" requires "when": a mapping of match value to target step id (e.g. when: { pass: ship }).`);
@@ -16519,9 +16118,9 @@ function parseRoute(ctx, raw, path10, stepLabel, stepIndex, routeChecks) {
   if (raw.default !== undefined) {
     if (typeof raw.default === "string" && raw.default.trim() !== "") {
       defaultStepId = raw.default.trim();
-      check.defaultTarget = { stepId: defaultStepId, line: ctx.lineAt([...path10, "default"]) };
+      check.defaultTarget = { stepId: defaultStepId, line: ctx.lineAt([...path8, "default"]) };
     } else {
-      ctx.err([...path10, "default"], `${stepLabel} "route.default" must be a step id string.`);
+      ctx.err([...path8, "default"], `${stepLabel} "route.default" must be a step id string.`);
     }
   }
   routeChecks.push(check);
@@ -16530,48 +16129,48 @@ function parseRoute(ctx, raw, path10, stepLabel, stepIndex, routeChecks) {
     route.defaultStepId = defaultStepId;
   return route;
 }
-function parseGate(ctx, raw, path10, stepLabel) {
+function parseGate(ctx, raw, path8, stepLabel) {
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${stepLabel} "gate" must be a mapping with a "criteria" list.`);
+    ctx.err(path8, `${stepLabel} "gate" must be a mapping with a "criteria" list.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, GATE_KEYS, `${stepLabel} "gate"`);
+  checkUnknownKeys(ctx, raw, path8, GATE_KEYS, `${stepLabel} "gate"`);
   const gate = { criteria: [] };
   if (Array.isArray(raw.criteria) && raw.criteria.length > 0 && raw.criteria.every((c) => typeof c === "string" && c.trim() !== "")) {
     gate.criteria = raw.criteria.map((c) => c.trim());
     for (const [i, c] of raw.criteria.entries()) {
-      ctx.checkTemplates(c, [...path10, "criteria", i], `${stepLabel} gate criterion ${i + 1}`);
+      ctx.checkTemplates(c, [...path8, "criteria", i], `${stepLabel} gate criterion ${i + 1}`);
     }
   } else {
-    ctx.err([...path10, "criteria"], `${stepLabel} "gate" requires "criteria": a non-empty list of criterion strings.`);
+    ctx.err([...path8, "criteria"], `${stepLabel} "gate" requires "criteria": a non-empty list of criterion strings.`);
   }
   if (raw.max_loops !== undefined) {
     if (typeof raw.max_loops === "number" && Number.isInteger(raw.max_loops) && raw.max_loops >= 1) {
       gate.maxLoops = raw.max_loops;
     } else {
-      ctx.err([...path10, "max_loops"], `${stepLabel} "gate.max_loops" must be an integer >= 1.`);
+      ctx.err([...path8, "max_loops"], `${stepLabel} "gate.max_loops" must be an integer >= 1.`);
     }
   }
   if (raw.required !== undefined) {
     if (typeof raw.required === "boolean") {
       gate.required = raw.required;
     } else {
-      ctx.err([...path10, "required"], `${stepLabel} "gate.required" must be a boolean (true or false).`);
+      ctx.err([...path8, "required"], `${stepLabel} "gate.required" must be a boolean (true or false).`);
     }
   }
   return gate;
 }
-function parseRetry(ctx, raw, path10, stepLabel) {
+function parseRetry(ctx, raw, path8, stepLabel) {
   if (raw === undefined)
     return;
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${stepLabel} "retry" must be a mapping: { max: <n>, on: [<failure_reason>, …] }.`);
+    ctx.err(path8, `${stepLabel} "retry" must be a mapping: { max: <n>, on: [<failure_reason>, …] }.`);
     return;
   }
-  checkUnknownKeys(ctx, raw, path10, RETRY_KEYS, `${stepLabel} "retry"`);
+  checkUnknownKeys(ctx, raw, path8, RETRY_KEYS, `${stepLabel} "retry"`);
   let ok = true;
   if (!(typeof raw.max === "number" && Number.isInteger(raw.max) && raw.max >= 0)) {
-    ctx.err([...path10, "max"], `${stepLabel} "retry.max" is required and must be a non-negative integer.`);
+    ctx.err([...path8, "max"], `${stepLabel} "retry.max" is required and must be a non-negative integer.`);
     ok = false;
   }
   const on = [];
@@ -16580,27 +16179,27 @@ function parseRetry(ctx, raw, path10, stepLabel) {
       if (typeof reason === "string" && PROGRAM_RETRY_REASONS.includes(reason)) {
         on.push(reason);
       } else {
-        ctx.err([...path10, "on", i], `${stepLabel} "retry.on" has unknown failure reason ${JSON.stringify(reason)}. Valid reasons: ${PROGRAM_RETRY_REASONS.join(", ")}.`);
+        ctx.err([...path8, "on", i], `${stepLabel} "retry.on" has unknown failure reason ${JSON.stringify(reason)}. Valid reasons: ${PROGRAM_RETRY_REASONS.join(", ")}.`);
         ok = false;
       }
     });
   } else {
-    ctx.err([...path10, "on"], `${stepLabel} "retry.on" is required and must be a non-empty list of failure reasons (${PROGRAM_RETRY_REASONS.join(", ")}).`);
+    ctx.err([...path8, "on"], `${stepLabel} "retry.on" is required and must be a non-empty list of failure reasons (${PROGRAM_RETRY_REASONS.join(", ")}).`);
     ok = false;
   }
   return ok ? { max: raw.max, on } : undefined;
 }
-function parseTimeoutField(ctx, raw, path10, label) {
+function parseTimeoutField(ctx, raw, path8, label) {
   if (raw === undefined)
     return;
   if (typeof raw === "number") {
     if (Number.isInteger(raw) && raw > 0)
       return raw;
-    ctx.err(path10, `${label} has a non-positive timeout ${JSON.stringify(raw)}. ${TIMEOUT_HINT}.`);
+    ctx.err(path8, `${label} has a non-positive timeout ${JSON.stringify(raw)}. ${TIMEOUT_HINT}.`);
     return;
   }
   if (typeof raw !== "string") {
-    ctx.err(path10, `${label} must be a duration string. ${TIMEOUT_HINT}.`);
+    ctx.err(path8, `${label} must be a duration string. ${TIMEOUT_HINT}.`);
     return;
   }
   const value = raw.trim().toLowerCase();
@@ -16608,31 +16207,31 @@ function parseTimeoutField(ctx, raw, path10, label) {
     return null;
   const match = value.match(TIMEOUT_VALUE);
   if (!match) {
-    ctx.err(path10, `${label} has an invalid timeout "${raw}". ${TIMEOUT_HINT}.`);
+    ctx.err(path8, `${label} has an invalid timeout "${raw}". ${TIMEOUT_HINT}.`);
     return;
   }
   const n = Number.parseInt(match[1], 10);
   const unit = match[2] ?? "ms";
   const timeoutMs = unit === "m" ? n * 60000 : unit === "s" ? n * 1000 : n;
   if (timeoutMs <= 0) {
-    ctx.err(path10, `${label} has a non-positive timeout "${raw}". Use a positive duration or "none".`);
+    ctx.err(path8, `${label} has a non-positive timeout "${raw}". Use a positive duration or "none".`);
     return;
   }
   return timeoutMs;
 }
-function parseEnumField(ctx, raw, path10, label, allowed) {
+function parseEnumField(ctx, raw, path8, label, allowed) {
   if (raw === undefined)
     return;
   if (typeof raw === "string" && allowed.includes(raw))
     return raw;
-  ctx.err(path10, `${label} must be one of: ${allowed.join(" | ")} (got ${JSON.stringify(raw)}).`);
+  ctx.err(path8, `${label} must be one of: ${allowed.join(" | ")} (got ${JSON.stringify(raw)}).`);
   return;
 }
-function parseLlmOverrides(ctx, raw, path10, label) {
+function parseLlmOverrides(ctx, raw, path8, label) {
   if (raw === undefined)
     return;
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${label} must be a mapping of LLM invocation overrides.`);
+    ctx.err(path8, `${label} must be a mapping of LLM invocation overrides.`);
     return;
   }
   const keys = [
@@ -16643,36 +16242,36 @@ function parseLlmOverrides(ctx, raw, path10, label) {
     "context_length",
     "enable_thinking"
   ];
-  checkUnknownKeys(ctx, raw, path10, keys, label);
+  checkUnknownKeys(ctx, raw, path8, keys, label);
   const result = {};
   if (raw.temperature !== undefined) {
     if (typeof raw.temperature === "number" && Number.isFinite(raw.temperature))
       result.temperature = raw.temperature;
     else
-      ctx.err([...path10, "temperature"], `${label}.temperature must be a finite number.`);
+      ctx.err([...path8, "temperature"], `${label}.temperature must be a finite number.`);
   }
   if (raw.max_tokens !== undefined) {
     if (typeof raw.max_tokens === "number" && Number.isInteger(raw.max_tokens) && raw.max_tokens > 0) {
       result.maxTokens = raw.max_tokens;
     } else
-      ctx.err([...path10, "max_tokens"], `${label}.max_tokens must be a positive integer.`);
+      ctx.err([...path8, "max_tokens"], `${label}.max_tokens must be a positive integer.`);
   }
   if (raw.supports_json_schema !== undefined) {
     if (typeof raw.supports_json_schema === "boolean")
       result.supportsJsonSchema = raw.supports_json_schema;
     else
-      ctx.err([...path10, "supports_json_schema"], `${label}.supports_json_schema must be a boolean.`);
+      ctx.err([...path8, "supports_json_schema"], `${label}.supports_json_schema must be a boolean.`);
   }
   if (raw.extra_params !== undefined) {
     if (!isPlainRecord(raw.extra_params)) {
-      ctx.err([...path10, "extra_params"], `${label}.extra_params must be a JSON object.`);
+      ctx.err([...path8, "extra_params"], `${label}.extra_params must be a JSON object.`);
     } else {
       const issues = validateExtraParams(raw.extra_params);
       for (const issue of issues) {
-        ctx.err([...path10, "extra_params", ...issue.path], `${formatExtraParamsIssue(`${label}.extra_params`, issue)}.`);
+        ctx.err([...path8, "extra_params", ...issue.path], `${formatExtraParamsIssue(`${label}.extra_params`, issue)}.`);
       }
       if (jsonBytes(raw.extra_params) > WORKFLOW_MAX_EXTRA_PARAMS_BYTES) {
-        ctx.err([...path10, "extra_params"], `${label}.extra_params exceeds the 64 KiB resource limit.`);
+        ctx.err([...path8, "extra_params"], `${label}.extra_params exceeds the 64 KiB resource limit.`);
       }
       if (issues.length === 0 && jsonBytes(raw.extra_params) <= WORKFLOW_MAX_EXTRA_PARAMS_BYTES) {
         result.extraParams = raw.extra_params;
@@ -16683,32 +16282,32 @@ function parseLlmOverrides(ctx, raw, path10, label) {
     if (typeof raw.context_length === "number" && Number.isInteger(raw.context_length) && raw.context_length > 0) {
       result.contextLength = raw.context_length;
     } else
-      ctx.err([...path10, "context_length"], `${label}.context_length must be a positive integer.`);
+      ctx.err([...path8, "context_length"], `${label}.context_length must be a positive integer.`);
   }
   if (raw.enable_thinking !== undefined) {
     if (typeof raw.enable_thinking === "boolean")
       result.enableThinking = raw.enable_thinking;
     else
-      ctx.err([...path10, "enable_thinking"], `${label}.enable_thinking must be a boolean.`);
+      ctx.err([...path8, "enable_thinking"], `${label}.enable_thinking must be a boolean.`);
   }
   return Object.keys(result).length > 0 ? result : undefined;
 }
-function parseSchemaObject(ctx, raw, path10, label) {
+function parseSchemaObject(ctx, raw, path8, label) {
   if (raw === undefined)
     return;
   if (!isPlainRecord(raw)) {
-    ctx.err(path10, `${label} must be a JSON Schema object (e.g. { type: object, properties: { … } }).`);
+    ctx.err(path8, `${label} must be a JSON Schema object (e.g. { type: object, properties: { … } }).`);
     return;
   }
   if (jsonBytes(raw) > WORKFLOW_MAX_SCHEMA_BYTES) {
-    ctx.err(path10, `${label} exceeds the 256 KiB resource limit.`);
+    ctx.err(path8, `${label} exceeds the 256 KiB resource limit.`);
   }
   return raw;
 }
-function checkUnknownKeys(ctx, obj, path10, allowed, label) {
+function checkUnknownKeys(ctx, obj, path8, allowed, label) {
   for (const key of Object.keys(obj)) {
     if (!allowed.includes(key)) {
-      ctx.err([...path10, key], `Unknown ${label} key "${key}". Allowed keys: ${allowed.join(", ")}.`);
+      ctx.err([...path8, key], `Unknown ${label} key "${key}". Allowed keys: ${allowed.join(", ")}.`);
     }
   }
 }
@@ -16716,7 +16315,7 @@ function rangedLine(ctx, node, fallbackPath) {
   const range = node?.range;
   return range ? ctx.lineAtOffset(range[0]) : ctx.lineAt(fallbackPath);
 }
-function checkTemplates(ctx, text, path10, label) {
+function checkTemplates(ctx, text, path8, label) {
   let idx = 0;
   while (true) {
     const open = text.indexOf("${{", idx);
@@ -16725,7 +16324,7 @@ function checkTemplates(ctx, text, path10, label) {
     const close = text.indexOf("}}", open + 3);
     const nextOpen = text.indexOf("${{", open + 3);
     if (close === -1 || nextOpen !== -1 && nextOpen < close) {
-      ctx.err(path10, `${label} contains an unterminated "\${{" expression. Close it with "}}".`);
+      ctx.err(path8, `${label} contains an unterminated "\${{" expression. Close it with "}}".`);
       return;
     }
     idx = close + 2;
@@ -16734,7 +16333,7 @@ function checkTemplates(ctx, text, path10, label) {
   if (checker) {
     const message = checker(text);
     if (message !== null)
-      ctx.err(path10, `${label}: ${message}`);
+      ctx.err(path8, `${label}: ${message}`);
   }
 }
 function loadExpressionChecker() {
@@ -17140,8 +16739,8 @@ var init_asset_registry = __esm(() => {
 });
 
 // src/core/asset/asset-spec.ts
-import fs10 from "node:fs";
-import path10 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 function toPosix2(input) {
   return input.replace(/\\/g, "/");
 }
@@ -17154,9 +16753,9 @@ var init_asset_spec = __esm(() => {
   init_asset_registry();
   WORKFLOW_EXTENSIONS = [".md", ".yaml", ".yml"];
   workflowSpec = {
-    isRelevantFile: (fileName) => WORKFLOW_EXTENSIONS.includes(path10.extname(fileName).toLowerCase()),
+    isRelevantFile: (fileName) => WORKFLOW_EXTENSIONS.includes(path8.extname(fileName).toLowerCase()),
     toCanonicalName: (typeRoot, filePath) => {
-      const rel = toPosix2(path10.relative(typeRoot, filePath));
+      const rel = toPosix2(path8.relative(typeRoot, filePath));
       for (const ext of WORKFLOW_EXTENSIONS) {
         if (rel.toLowerCase().endsWith(ext))
           return rel.slice(0, -ext.length);
@@ -17167,25 +16766,25 @@ var init_asset_spec = __esm(() => {
       const lower = name.toLowerCase();
       for (const ext of WORKFLOW_EXTENSIONS) {
         if (lower.endsWith(ext))
-          return path10.join(typeRoot, name);
+          return path8.join(typeRoot, name);
       }
       for (const ext of WORKFLOW_EXTENSIONS) {
-        const candidate = path10.join(typeRoot, `${name}${ext}`);
-        if (fs10.existsSync(candidate))
+        const candidate = path8.join(typeRoot, `${name}${ext}`);
+        if (fs8.existsSync(candidate))
           return candidate;
       }
-      return path10.join(typeRoot, `${name}.md`);
+      return path8.join(typeRoot, `${name}.md`);
     }
   };
   markdownSpec = {
-    isRelevantFile: (fileName) => path10.extname(fileName).toLowerCase() === ".md",
+    isRelevantFile: (fileName) => path8.extname(fileName).toLowerCase() === ".md",
     toCanonicalName: (typeRoot, filePath) => {
-      const rel = toPosix2(path10.relative(typeRoot, filePath));
+      const rel = toPosix2(path8.relative(typeRoot, filePath));
       return rel.endsWith(".md") ? rel.slice(0, -3) : rel;
     },
     toAssetPath: (typeRoot, name) => {
       const withExt = name.endsWith(".md") ? name : `${name}.md`;
-      return path10.join(typeRoot, withExt);
+      return path8.join(typeRoot, withExt);
     }
   };
   SCRIPT_EXTENSIONS = new Set([
@@ -17207,21 +16806,21 @@ var init_asset_spec = __esm(() => {
     ".kts"
   ]);
   scriptSpec = {
-    isRelevantFile: (fileName) => SCRIPT_EXTENSIONS.has(path10.extname(fileName).toLowerCase()),
-    toCanonicalName: (typeRoot, filePath) => toPosix2(path10.relative(typeRoot, filePath)),
-    toAssetPath: (typeRoot, name) => path10.join(typeRoot, name)
+    isRelevantFile: (fileName) => SCRIPT_EXTENSIONS.has(path8.extname(fileName).toLowerCase()),
+    toCanonicalName: (typeRoot, filePath) => toPosix2(path8.relative(typeRoot, filePath)),
+    toAssetPath: (typeRoot, name) => path8.join(typeRoot, name)
   };
   ASSET_SPECS_INTERNAL = {
     skill: {
       stashDir: "skills",
       isRelevantFile: (fileName) => fileName === "SKILL.md",
       toCanonicalName: (typeRoot, filePath) => {
-        const relDir = toPosix2(path10.dirname(path10.relative(typeRoot, filePath)));
+        const relDir = toPosix2(path8.dirname(path8.relative(typeRoot, filePath)));
         if (!relDir || relDir === ".")
           return;
         return relDir;
       },
-      toAssetPath: (typeRoot, name) => path10.join(typeRoot, name, "SKILL.md")
+      toAssetPath: (typeRoot, name) => path8.join(typeRoot, name, "SKILL.md")
     },
     command: { stashDir: "commands", ...markdownSpec },
     agent: { stashDir: "agents", ...markdownSpec },
@@ -17238,10 +16837,10 @@ var init_asset_spec = __esm(() => {
       stashDir: "env",
       isRelevantFile: (fileName) => fileName === ".env" || fileName.endsWith(".env"),
       toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix2(path10.relative(typeRoot, filePath));
-        const fileName = path10.basename(rel);
+        const rel = toPosix2(path8.relative(typeRoot, filePath));
+        const fileName = path8.basename(rel);
         if (fileName === ".env") {
-          const dir = path10.dirname(rel);
+          const dir = path8.dirname(rel);
           return dir === "." || dir === "" ? "default" : `${dir}/default`;
         }
         const stripped = rel.endsWith(".env") ? rel.slice(0, -4) : rel;
@@ -17249,8 +16848,8 @@ var init_asset_spec = __esm(() => {
       },
       toAssetPath: (typeRoot, name) => {
         if (name === "default")
-          return path10.join(typeRoot, ".env");
-        return path10.join(typeRoot, name.endsWith(".env") ? name : `${name}.env`);
+          return path8.join(typeRoot, ".env");
+        return path8.join(typeRoot, name.endsWith(".env") ? name : `${name}.env`);
       },
       rendererName: "env-file",
       actionBuilder: (ref) => `akm show ${ref} -> inspect key names; akm env run ${ref} -- <command> -> run with the whole .env injected (prefer --clean to minimize inherited parent env; child stdout is not redacted); akm env export ${ref} --out <file> -> write a sourceable script to a file`
@@ -17258,8 +16857,8 @@ var init_asset_spec = __esm(() => {
     secret: {
       stashDir: "secrets",
       isRelevantFile: (fileName) => !fileName.endsWith(".lock") && !fileName.endsWith(".sensitive"),
-      toCanonicalName: (typeRoot, filePath) => toPosix2(path10.relative(typeRoot, filePath)),
-      toAssetPath: (typeRoot, name) => path10.join(typeRoot, name),
+      toCanonicalName: (typeRoot, filePath) => toPosix2(path8.relative(typeRoot, filePath)),
+      toAssetPath: (typeRoot, name) => path8.join(typeRoot, name),
       rendererName: "secret-file",
       actionBuilder: (ref) => `akm show ${ref} -> name only (value never shown); akm secret path ${ref} -> file path; akm secret run ${ref} <VAR> -- <command> -> run with value injected into $VAR`
     },
@@ -17277,14 +16876,14 @@ var init_asset_spec = __esm(() => {
     },
     task: {
       stashDir: "tasks",
-      isRelevantFile: (fileName) => path10.extname(fileName).toLowerCase() === ".yml",
+      isRelevantFile: (fileName) => path8.extname(fileName).toLowerCase() === ".yml",
       toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix2(path10.relative(typeRoot, filePath));
+        const rel = toPosix2(path8.relative(typeRoot, filePath));
         return rel.endsWith(".yml") ? rel.slice(0, -4) : rel;
       },
       toAssetPath: (typeRoot, name) => {
         const withExt = name.endsWith(".yml") ? name : `${name}.yml`;
-        return path10.join(typeRoot, withExt);
+        return path8.join(typeRoot, withExt);
       },
       rendererName: "task-yaml",
       actionBuilder: buildTaskAction
@@ -17306,32 +16905,29 @@ var init_asset_spec = __esm(() => {
 });
 
 // src/core/common.ts
-import crypto2 from "node:crypto";
-import fs11 from "node:fs";
-import path11 from "node:path";
+import fs9 from "node:fs";
 function isAssetType(type) {
   return Object.hasOwn(TYPE_DIRS, type);
 }
-function writeFileAtomic(target, content, mode) {
-  const tmp = `${target}.tmp.${process.pid}.${crypto2.randomBytes(8).toString("hex")}`;
-  const fd = fs11.openSync(tmp, "w", mode ?? 384);
-  try {
-    fs11.writeSync(fd, typeof content === "string" ? Buffer.from(content) : content);
-    try {
-      fs11.fdatasyncSync(fd);
-    } catch {}
-  } finally {
-    fs11.closeSync(fd);
+function readTextFileDescriptorWithLimit(fd, maxBytes, label = "File", displayPath = "(open file)") {
+  const stat = fs9.fstatSync(fd);
+  if (!stat.isFile())
+    throw new ConfigError(`${label} is not a regular file: ${displayPath}.`, "INVALID_CONFIG_FILE");
+  if (stat.size > maxBytes) {
+    throw new ConfigError(`${label} exceeds the ${maxBytes}-byte limit: ${displayPath}.`, "INVALID_CONFIG_FILE");
+  }
+  const buffer = Buffer.allocUnsafe(maxBytes + 1);
+  let total = 0;
+  while (total <= maxBytes) {
+    const bytesRead = fs9.readSync(fd, buffer, total, maxBytes + 1 - total, null);
+    if (bytesRead === 0)
+      break;
+    total += bytesRead;
   }
-  fs11.renameSync(tmp, target);
-  try {
-    const dirFd = fs11.openSync(path11.dirname(target), "r");
-    try {
-      fs11.fsyncSync(dirFd);
-    } finally {
-      fs11.closeSync(dirFd);
-    }
-  } catch {}
+  if (total > maxBytes) {
+    throw new ConfigError(`${label} exceeds the ${maxBytes}-byte limit: ${displayPath}.`, "INVALID_CONFIG_FILE");
+  }
+  return buffer.subarray(0, total).toString("utf8");
 }
 function asNonEmptyString3(value) {
   if (typeof value !== "string")
@@ -17347,7 +16943,7 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-var ASSET_TYPES, ASSET_TYPE_SET, IS_WINDOWS, DEFAULT_RESPONSE_BYTE_CAP;
+var ASSET_TYPES, ASSET_TYPE_SET, IS_WINDOWS, MAX_CONFIG_FILE_BYTES, MAX_LOCAL_METADATA_BYTES, MAX_LOCK_METADATA_BYTES, DEFAULT_RESPONSE_BYTE_CAP;
 var init_common = __esm(() => {
   init_asset_spec();
   init_errors();
@@ -17355,9 +16951,147 @@ var init_common = __esm(() => {
   ASSET_TYPES = Object.freeze([...getAssetTypes()]);
   ASSET_TYPE_SET = new Set(ASSET_TYPES);
   IS_WINDOWS = process.platform === "win32";
+  MAX_CONFIG_FILE_BYTES = 1024 * 1024;
+  MAX_LOCAL_METADATA_BYTES = 1024 * 1024;
+  MAX_LOCK_METADATA_BYTES = 64 * 1024;
   DEFAULT_RESPONSE_BYTE_CAP = 10 * 1024 * 1024;
 });
 
+// src/storage/engines/sqlite-migrations.ts
+import crypto2 from "node:crypto";
+function migrationChecksum(migration) {
+  return crypto2.createHash("sha256").update(migration.id).update("\x00").update(migration.up).digest("hex");
+}
+function migrationsTableExists(db) {
+  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
+}
+function ledgerHasChecksum(db) {
+  return db.prepare("PRAGMA table_info(schema_migrations)").all().some((column) => column.name === "checksum");
+}
+function inspectMigrationLedger(db, migrations) {
+  const registryIds = migrations.map((migration) => migration.id);
+  if (new Set(registryIds).size !== registryIds.length) {
+    return {
+      status: "inconsistent",
+      migrationIds: [],
+      checksums: [],
+      detail: "migration registry contains duplicate IDs"
+    };
+  }
+  if (!migrationsTableExists(db))
+    return { status: registryIds.length === 0 ? "current" : "old", migrationIds: [], checksums: [] };
+  const hasChecksum = ledgerHasChecksum(db);
+  const rows = db.prepare(`SELECT id${hasChecksum ? ", checksum" : ""} FROM schema_migrations ORDER BY rowid`).all();
+  const migrationIds = rows.map((row) => row.id);
+  const checksums = rows.map((row) => row.checksum ?? null);
+  for (let index = 0;index < rows.length; index += 1) {
+    const expected = migrations[index];
+    const row = rows[index];
+    if (!expected) {
+      return { status: "newer", migrationIds, checksums, detail: `unknown migration ID ${row.id}` };
+    }
+    if (row.id !== expected.id) {
+      const knownLater = registryIds.includes(row.id);
+      return {
+        status: knownLater ? "inconsistent" : "newer",
+        migrationIds,
+        checksums,
+        detail: knownLater ? `migration ledger is not an exact ordered prefix at position ${index + 1}` : `unknown migration ID ${row.id}`
+      };
+    }
+    const expectedChecksum = migrationChecksum(expected);
+    if (row.checksum && row.checksum !== expectedChecksum) {
+      return {
+        status: "inconsistent",
+        migrationIds,
+        checksums,
+        detail: `migration ${row.id} checksum does not match the released migration body`
+      };
+    }
+  }
+  const missingChecksum = checksums.indexOf(null);
+  if (missingChecksum >= 0) {
+    return {
+      status: "old",
+      migrationIds,
+      checksums,
+      detail: `migration ${migrationIds[missingChecksum]} has not been sealed with a checksum`
+    };
+  }
+  return {
+    status: rows.length === migrations.length ? "current" : "old",
+    migrationIds,
+    checksums
+  };
+}
+function assertMigrationLedger(db, migrations) {
+  const state = inspectMigrationLedger(db, migrations);
+  if (state.status === "newer") {
+    throw new Error(`Refusing to open a database with a newer migration ledger: ${state.detail}.`);
+  }
+  if (state.status === "inconsistent") {
+    throw new Error(`Refusing a database whose migrations are not an exact ordered prefix: ${state.detail}.`);
+  }
+  return state;
+}
+function assertCurrentMigrationLedger(db, migrations) {
+  const state = assertMigrationLedger(db, migrations);
+  if (state.status !== "current") {
+    throw new Error(`Refusing to open an obsolete writable schema; run \`akm migrate apply\`: ${state.detail ?? "pending migrations"}.`);
+  }
+  return state;
+}
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      id         TEXT    PRIMARY KEY,
+      applied_at TEXT    NOT NULL DEFAULT (datetime('now')),
+      checksum   TEXT
+    );
+  `);
+  if (!ledgerHasChecksum(db))
+    db.exec("ALTER TABLE schema_migrations ADD COLUMN checksum TEXT");
+}
+function runMigrations(db, migrations, opts) {
+  if (opts?.applyPending === false) {
+    assertMigrationLedger(db, migrations);
+    return;
+  }
+  if (migrationsTableExists(db))
+    assertMigrationLedger(db, migrations);
+  ensureMigrationsTable(db);
+  opts?.bootstrap?.(db);
+  const ledger = assertMigrationLedger(db, migrations);
+  db.transaction(() => {
+    const update = db.prepare("UPDATE schema_migrations SET checksum = ? WHERE id = ? AND checksum IS NULL");
+    for (let index = 0;index < ledger.migrationIds.length; index += 1) {
+      update.run(migrationChecksum(migrations[index]), ledger.migrationIds[index]);
+    }
+    if (opts?.generationMarker) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS akm_migration_generation (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          operation_id TEXT NOT NULL,
+          phase TEXT NOT NULL
+        )
+      `);
+      db.prepare("INSERT INTO akm_migration_generation(singleton, operation_id, phase) VALUES (1, ?, ?) ON CONFLICT(singleton) DO UPDATE SET operation_id=excluded.operation_id, phase=excluded.phase").run(opts.generationMarker.operationId, opts.generationMarker.phase);
+    }
+  })();
+  const appliedRows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
+  const applied = new Set(appliedRows.map((r) => r.id));
+  for (const migration of migrations) {
+    if (applied.has(migration.id))
+      continue;
+    opts?.beforeMigration?.(migration);
+    db.transaction(() => {
+      db.exec(migration.up);
+      db.prepare("INSERT INTO schema_migrations (id, checksum) VALUES (?, ?)").run(migration.id, migrationChecksum(migration));
+    })();
+  }
+}
+var init_sqlite_migrations = () => {};
+
 // src/storage/sqlite-pragmas.ts
 function resolveJournalMode(raw) {
   if (raw === undefined)
@@ -17425,12 +17159,12 @@ var init_sqlite_pragmas = __esm(() => {
 });
 
 // src/storage/managed-db.ts
-import fs12 from "node:fs";
-import path13 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 function openManagedDatabase(spec) {
-  const dir = path13.dirname(spec.path);
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  const dir = path10.dirname(spec.path);
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
   }
   const db = openDatabase(spec.path);
   applyStandardPragmas(db, spec.pragmas ?? { dataDir: dir });
@@ -17464,44 +17198,81 @@ var init_managed_db = __esm(() => {
   init_sqlite_pragmas();
 });
 
-// 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'))
-    );
-  `);
+// src/core/maintenance-barrier.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs11 from "node:fs";
+import path11 from "node:path";
+function tryAcquireMaintenanceBarrier() {
+  const lockPath = getMaintenanceBarrierPath();
+  fs11.mkdirSync(path11.dirname(lockPath), { recursive: true });
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: "maintenance-start" }));
+    if (ownership) {
+      return () => releaseLock(ownership);
+    }
+    const probe = probeLock(lockPath);
+    if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
+      return;
+  }
+  return;
 }
-function runMigrations(db, migrations, opts) {
-  ensureMigrationsTable(db);
-  opts?.bootstrap?.(db);
-  const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
-  const applied = new Set(appliedRows.map((r) => r.id));
-  for (const migration of migrations) {
-    if (applied.has(migration.id))
-      continue;
-    opts?.beforeMigration?.(migration);
-    db.transaction(() => {
-      db.exec(migration.up);
-      db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
-    })();
+function acquireMaintenanceBarrier() {
+  const release = tryAcquireMaintenanceBarrier();
+  if (release)
+    return release;
+  throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes.`, "INVALID_CONFIG_FILE");
+}
+function withMaintenanceStartBarrierSyncWait(run) {
+  if (heldBarrierContext.getStore()?.active)
+    return run();
+  const deadline = Date.now() + 5000;
+  let release = tryAcquireMaintenanceBarrier();
+  while (!release && Date.now() < deadline) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+    release = tryAcquireMaintenanceBarrier();
+  }
+  if (!release)
+    release = acquireMaintenanceBarrier();
+  const ownership = { active: true };
+  try {
+    return heldBarrierContext.run(ownership, run);
+  } finally {
+    ownership.active = false;
+    release();
   }
 }
+function acquireMaintenanceActivitySync(name) {
+  return withMaintenanceStartBarrierSyncWait(() => {
+    const directory = path11.join(path11.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
+    fs11.mkdirSync(directory, { recursive: true, mode: 448 });
+    const lockPath = path11.join(directory, `${name}-${process.pid}-${randomUUID2()}.lock`);
+    const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
+    if (!ownership) {
+      throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
+    }
+    return () => releaseLock(ownership);
+  });
+}
+var heldBarrierContext;
+var init_maintenance_barrier = __esm(() => {
+  init_errors();
+  init_file_lock();
+  init_paths();
+  heldBarrierContext = new AsyncLocalStorage;
+});
 
 // src/core/state/migrations.ts
 function runMigrations2(db, options) {
-  runMigrations(db, MIGRATIONS, {
-    beforeMigration(migration) {
-      if (options?.ensureCutoverBackup && migration.id === "017-improve-run-strategy")
-        ensureMigrationBackup();
-    }
+  runMigrations(db, STATE_MIGRATIONS, {
+    applyPending: options?.applyPending,
+    generationMarker: options?.generationMarker
   });
 }
-var MIGRATIONS;
+var STATE_MIGRATIONS;
 var init_migrations = __esm(() => {
-  init_migration_backup();
-  MIGRATIONS = [
+  init_sqlite_migrations();
+  STATE_MIGRATIONS = [
     {
       id: "001-initial-schema",
       up: `
@@ -17947,22 +17718,37 @@ __export(exports_state_db, {
   listExistingTableNames: () => listExistingTableNames,
   getStateDbPath: () => getStateDbPath
 });
-import fs13 from "node:fs";
-import path14 from "node:path";
+import fs12 from "node:fs";
+import path12 from "node:path";
 function getStateDbPath() {
-  return path14.join(getDataDir(), "state.db");
+  return path12.join(getDataDir(), "state.db");
 }
 function openStateDatabase(dbPath) {
   const canonicalPath = getStateDbPath();
   const resolvedPath = dbPath ?? canonicalPath;
-  const isCanonical = path14.resolve(resolvedPath) === path14.resolve(canonicalPath);
+  const isCanonical = path12.resolve(resolvedPath) === path12.resolve(canonicalPath);
+  if (isCanonical)
+    assertNoPendingMigrationOperation();
   const releaseActivity = isCanonical ? acquireMaintenanceActivitySync("state-db") : undefined;
   try {
-    if (isCanonical && !fs13.existsSync(getMigrationBackupDir()))
-      ensureMigrationBackup();
+    if (isCanonical)
+      assertNoPendingMigrationOperation();
+    const existed = fs12.existsSync(resolvedPath);
+    if (existed) {
+      const preflight = openDatabase(resolvedPath, { readonly: true });
+      try {
+        preflight.exec("PRAGMA busy_timeout = 30000");
+        if (isCanonical)
+          assertCurrentMigrationLedger(preflight, STATE_MIGRATIONS);
+        else
+          assertMigrationLedger(preflight, STATE_MIGRATIONS);
+      } finally {
+        preflight.close();
+      }
+    }
     const db = openManagedDatabase({
       path: resolvedPath,
-      init: (db2) => runMigrations2(db2, { ensureCutoverBackup: isCanonical })
+      init: (db2) => runMigrations2(db2, { applyPending: !(isCanonical && existed) })
     });
     if (!releaseActivity)
       return db;
@@ -18001,7 +17787,7 @@ function isRetryableBeginError(err) {
   const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
   return msg.includes("database is locked") || msg.includes("database table is locked") || msg.includes("did not open a transaction");
 }
-function sleepSyncMs2(ms) {
+function sleepSyncMs(ms) {
   if (ms <= 0)
     return;
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -18025,7 +17811,7 @@ function withImmediateTransaction(db, fn) {
             db.exec("ROLLBACK");
           } catch {}
         }
-        sleepSyncMs2(2 ** (attempt - 1));
+        sleepSyncMs(2 ** (attempt - 1));
         continue;
       }
       throw err;
@@ -18056,9 +17842,11 @@ function listExistingTableNames(db, names) {
 }
 var WITH_IMMEDIATE_TX_MAX_ATTEMPTS = 5;
 var init_state_db = __esm(() => {
+  init_database();
+  init_sqlite_migrations();
   init_managed_db();
   init_maintenance_barrier();
-  init_migration_backup();
+  init_migration_operation();
   init_paths();
   init_migrations();
 });
@@ -18068,6 +17856,7 @@ var exports_events_repository = {};
 __export(exports_events_repository, {
   readStateEvents: () => readStateEvents,
   purgeOldEvents: () => purgeOldEvents,
+  insertEventOnce: () => insertEventOnce,
   insertEvent: () => insertEvent,
   importEventsJsonl: () => importEventsJsonl,
   eventRowToEnvelope: () => eventRowToEnvelope
@@ -18101,6 +17890,22 @@ function insertEvent(db, input) {
     return;
   }
 }
+function insertEventOnce(db, input) {
+  const rows = db.prepare("SELECT id, metadata_json FROM events WHERE event_type = ? AND ref IS ? ORDER BY id").all(input.eventType, input.ref ?? null);
+  for (const row of rows) {
+    try {
+      const metadata = JSON.parse(row.metadata_json);
+      if (metadata[input.idempotencyMetadataKey ?? "proposalTransactionId"] === input.idempotencyKey)
+        return row.id;
+    } catch {}
+  }
+  const result = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
+       VALUES (?, ?, ?, ?)
+       RETURNING id`).get(input.eventType, input.ts, input.ref ?? null, JSON.stringify(input.metadata));
+  if (!result)
+    throw new Error(`Failed to persist ${input.eventType} event.`);
+  return result.id;
+}
 function readStateEvents(db, options = {}) {
   const conditions = [];
   const params = [];
@@ -18189,10 +17994,12 @@ var init_events_repository = __esm(() => {
 var exports_task_history_repository = {};
 __export(exports_task_history_repository, {
   upsertTaskHistory: () => upsertTaskHistory,
+  reserveTaskHistoryAttempt: () => reserveTaskHistoryAttempt,
   queryTaskHistory: () => queryTaskHistory,
   queryCompletedTaskIntervals: () => queryCompletedTaskIntervals,
   getTaskHistoryRuns: () => getTaskHistoryRuns,
   getTaskHistory: () => getTaskHistory,
+  finalizeTaskHistoryAttempt: () => finalizeTaskHistoryAttempt,
   decodeTaskHistoryMetadata: () => decodeTaskHistoryMetadata
 });
 function metadataError(message) {
@@ -18271,6 +18078,21 @@ function decodeTaskHistoryMetadata(input) {
   }
   metadataError(`unsupported metadataVersion: ${String(version)}`);
 }
+function reserveTaskHistoryAttempt(db, row) {
+  const result = db.prepare(`INSERT OR IGNORE INTO task_history
+         (task_id, status, started_at, completed_at, failed_at, log_path,
+          target_kind, target_ref, metadata_json)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.task_id, row.status, row.started_at, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json);
+  return Number(result.changes) === 1;
+}
+function finalizeTaskHistoryAttempt(db, row) {
+  const result = db.prepare(`UPDATE task_history
+       SET status = ?, completed_at = ?, failed_at = ?, log_path = ?,
+           target_kind = ?, target_ref = ?, metadata_json = ?
+       WHERE task_id = ? AND started_at = ?
+         AND status = 'active' AND completed_at IS NULL`).run(row.status, row.completed_at ?? null, row.failed_at ?? null, row.log_path ?? null, row.target_kind ?? null, row.target_ref ?? null, row.metadata_json, row.task_id, row.started_at);
+  return Number(result.changes) === 1;
+}
 function upsertTaskHistory(db, row) {
   db.prepare(`
     INSERT OR IGNORE INTO task_history
@@ -18282,12 +18104,12 @@ function upsertTaskHistory(db, row) {
 function getTaskHistory(db, taskId) {
   return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT 1`).get(taskId);
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT 1`).get(taskId);
 }
 function getTaskHistoryRuns(db, taskId, limit = 50) {
   return db.prepare(`SELECT id, task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history WHERE task_id = ? ORDER BY started_at DESC LIMIT ?`).all(taskId, limit);
+       FROM task_history WHERE task_id = ? ORDER BY started_at DESC, id DESC LIMIT ?`).all(taskId, limit);
 }
 function queryTaskHistory(db, options = {}) {
   const conditions = [];
@@ -18315,7 +18137,7 @@ function queryTaskHistory(db, options = {}) {
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   return db.prepare(`SELECT task_id, status, started_at, completed_at, failed_at, log_path,
               target_kind, target_ref, metadata_json
-       FROM task_history ${where} ORDER BY started_at DESC`).all(...params);
+       FROM task_history ${where} ORDER BY started_at DESC, id DESC`).all(...params);
 }
 function queryCompletedTaskIntervals(db, since, until) {
   const sql = until ? "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND started_at < ? AND completed_at IS NOT NULL ORDER BY started_at" : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";
@@ -18966,9 +18788,9 @@ __export(exports_db, {
   UTILITY_REVIEW_THRESHOLD: () => UTILITY_REVIEW_THRESHOLD,
   HIGH_UTILITY_THRESHOLD: () => HIGH_UTILITY_THRESHOLD
 });
-import fs14 from "node:fs";
+import fs13 from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import path15 from "node:path";
+import path13 from "node:path";
 function openIndexDatabase(dbPath, options) {
   return openManagedDatabase({
     path: dbPath ?? getDbPath(),
@@ -18998,7 +18820,7 @@ function openExistingDatabase2(dbPath) {
 }
 function openReadonlyExistingDatabase(dbPath) {
   const resolvedPath = dbPath ?? getDbPath();
-  if (!fs14.existsSync(resolvedPath))
+  if (!fs13.existsSync(resolvedPath))
     return;
   return openDatabase(resolvedPath, { readonly: true, create: false });
 }
@@ -19073,7 +18895,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}${path15.sep}%`);
+  db.prepare("DELETE FROM index_dir_state WHERE dir_path = ? OR dir_path LIKE ?").run(stashDir, `${stashDir}${path13.sep}%`);
 }
 function upsertEntry(db, entryKey, dirPath, filePath, stashDir, entry, searchText) {
   const stmts = getUpsertStmts(db);
@@ -19148,16 +18970,19 @@ function getBaseBeliefStatesForDerivedTwins(db, twinIds) {
   return out;
 }
 function rekeyEntryInPlace(db, opts) {
-  const row = db.prepare("SELECT id, entry_json, search_text FROM entries WHERE entry_key = ?").get(opts.oldEntryKey);
+  const row = db.prepare("SELECT id, stash_dir, entry_json, search_text FROM entries WHERE entry_key = ?").get(opts.oldEntryKey);
   if (!row)
     return null;
+  if (opts.sourceRoot && path13.resolve(row.stash_dir) !== path13.resolve(opts.sourceRoot)) {
+    throw new Error(`Refusing to re-key entry ${opts.oldEntryKey}: source root does not match.`);
+  }
   let entryJson = row.entry_json;
   let searchText = row.search_text;
   try {
     const entry = JSON.parse(row.entry_json);
     entry.name = opts.newName;
     if (typeof entry.filename === "string")
-      entry.filename = path15.basename(opts.newFilePath);
+      entry.filename = path13.basename(opts.newFilePath);
     if (opts.newDerivedFrom !== undefined)
       entry.derivedFrom = opts.newDerivedFrom;
     entryJson = JSON.stringify(entry);
@@ -19169,22 +18994,32 @@ function rekeyEntryInPlace(db, opts) {
       deleteRelatedRows(db, [{ id: stale.id }]);
       db.prepare("DELETE FROM entries WHERE id = ?").run(stale.id);
     }
-    db.prepare("UPDATE entries SET entry_key = ?, dir_path = ?, file_path = ?, entry_json = ?, search_text = ? WHERE id = ?").run(opts.newEntryKey, path15.dirname(opts.newFilePath), opts.newFilePath, entryJson, searchText, row.id);
+    db.prepare("UPDATE entries SET entry_key = ?, dir_path = ?, file_path = ?, entry_json = ?, search_text = ? WHERE id = ?").run(opts.newEntryKey, path13.dirname(opts.newFilePath), opts.newFilePath, entryJson, searchText, row.id);
     if (opts.newDerivedFrom !== undefined) {
       db.prepare("UPDATE entries SET derived_from = ? WHERE id = ?").run(opts.newDerivedFrom, row.id);
     }
-    bestEffort(() => {
-      db.prepare("DELETE FROM usage_events WHERE entry_id IS NULL AND entry_ref = ?").run(opts.newRef);
-      db.prepare(`DELETE FROM usage_events
-          WHERE entry_id IS NULL
-            AND instr(entry_ref, '//') > 0
-            AND substr(entry_ref, instr(entry_ref, '//') + 2) = ?`).run(opts.newRef);
-      db.prepare("UPDATE usage_events SET entry_ref = ? WHERE entry_ref = ?").run(opts.newRef, opts.oldRef);
-      db.prepare(`UPDATE usage_events
-            SET entry_ref = substr(entry_ref, 1, instr(entry_ref, '//') + 1) || ?
-          WHERE instr(entry_ref, '//') > 0
-            AND substr(entry_ref, instr(entry_ref, '//') + 2) = ?`).run(opts.newRef, opts.oldRef);
-    }, "usage_events table may be missing on legacy DBs — no usage history to re-key");
+    try {
+      if (opts.sourceName) {
+        const origins = new Set([opts.sourceName]);
+        if (opts.sourceName === "stash" && opts.includeLegacyBare)
+          origins.add("local");
+        for (const origin of origins) {
+          const oldQualifiedRef = `${origin}//${opts.oldRef}`;
+          const newQualifiedRef = `${origin}//${opts.newRef}`;
+          db.prepare("DELETE FROM usage_events WHERE entry_id IS NULL AND entry_ref = ?").run(newQualifiedRef);
+          db.prepare("UPDATE usage_events SET entry_ref = ? WHERE entry_ref = ?").run(newQualifiedRef, oldQualifiedRef);
+        }
+      }
+      if (opts.includeLegacyBare || !opts.sourceName) {
+        db.prepare("DELETE FROM usage_events WHERE entry_id IS NULL AND entry_ref = ?").run(opts.newRef);
+        db.prepare("UPDATE usage_events SET entry_ref = ? WHERE entry_ref = ?").run(opts.newRef, opts.oldRef);
+      }
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      const missingLegacyUsageSchema = /no such table:\s*(?:main\.)?usage_events\b/i.test(message) || /no such column:\s*(?:usage_events\.)?(?:entry_id|entry_ref)\b/i.test(message) || /table\s+usage_events\s+has no column named\s+(?:entry_id|entry_ref)\b/i.test(message);
+      if (!missingLegacyUsageSchema)
+        throw error2;
+    }
     db.prepare("INSERT OR IGNORE INTO entries_fts_dirty (entry_id) VALUES (?)").run(row.id);
   })();
   return row.id;
@@ -19506,7 +19341,7 @@ function getEntitiesByEntryIds(db, entryIds) {
   }
   return result;
 }
-function findEntryIdByRef(db, ref) {
+function findEntryIdByRef(db, ref, stashDir) {
   const parsed = parseAssetRef(ref);
   const nameVariants = [parsed.name];
   if (parsed.name.endsWith(".md")) {
@@ -19514,10 +19349,14 @@ function findEntryIdByRef(db, ref) {
   } else {
     nameVariants.push(`${parsed.name}.md`);
   }
-  const stmt = db.prepare("SELECT id FROM entries WHERE entry_type = ? AND substr(entry_key, length(entry_key) - length(?) + 1) = ? LIMIT 1");
+  const stmt = db.prepare(`SELECT id FROM entries
+     WHERE entry_type = ?
+       AND substr(entry_key, length(entry_key) - length(?) + 1) = ?
+       ${stashDir ? "AND stash_dir = ?" : ""}
+     LIMIT 1`);
   for (const name of nameVariants) {
     const suffix = `${parsed.type}:${name}`;
-    const row = stmt.get(parsed.type, suffix, suffix);
+    const row = stmt.get(parsed.type, suffix, suffix, ...stashDir ? [stashDir] : []);
     if (row)
       return row.id;
   }
@@ -19535,7 +19374,7 @@ function getEmbeddingCount(db) {
   return row.cnt;
 }
 function getEntryById(db, id) {
-  const row = db.prepare("SELECT file_path, entry_json FROM entries WHERE id = ?").get(id);
+  const row = db.prepare("SELECT file_path, stash_dir, entry_json FROM entries WHERE id = ?").get(id);
   if (!row)
     return;
   let entry;
@@ -19545,7 +19384,7 @@ function getEntryById(db, id) {
     warn(`[db] getEntryById: skipping entry id=${id} — corrupt entry_json`);
     return;
   }
-  return { filePath: row.file_path, entry };
+  return { filePath: row.file_path, stashDir: row.stash_dir, entry };
 }
 function getEntriesByDir(db, dirPath) {
   const rows = db.prepare(`SELECT ${ENTRY_COLUMNS} FROM entries WHERE dir_path = ?`).all(dirPath);
@@ -19694,9 +19533,12 @@ function bareRef(ref) {
     return ref;
   }
 }
-function getRetrievalCounts(db, refs) {
+function getRetrievalCounts(db, refs, options = {}) {
   if (refs.length === 0)
     return new Map;
+  if (options.sourceName || options.stashDir) {
+    return getSourceScopedRetrievalCounts(db, refs, options);
+  }
   const bareToInputs = new Map;
   for (const ref of refs) {
     const bare = bareRef(ref);
@@ -19740,6 +19582,51 @@ function getRetrievalCounts(db, refs) {
   }
   return result;
 }
+function getSourceScopedRetrievalCounts(db, refs, options) {
+  const bareToInputs = new Map;
+  for (const ref of refs) {
+    const bare = bareRef(ref);
+    const inputs = bareToInputs.get(bare);
+    if (inputs)
+      inputs.push(ref);
+    else
+      bareToInputs.set(bare, [ref]);
+  }
+  const countsByBare = new Map;
+  const bareForms = [...bareToInputs.keys()];
+  const selectedRoot = options.stashDir ? path13.resolve(options.stashDir) : undefined;
+  for (let i = 0;i < bareForms.length; i += SQLITE_CHUNK_SIZE) {
+    const chunk = bareForms.slice(i, i + SQLITE_CHUNK_SIZE);
+    const placeholders = chunk.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT ue.entry_ref, ue.entry_id, e.stash_dir
+           FROM usage_events ue
+           LEFT JOIN entries e ON e.id = ue.entry_id
+          WHERE ue.event_type IN ('search','show','curate')
+            AND ue.entry_ref IS NOT NULL
+            AND (ue.source IS NULL OR ue.source NOT IN ('improve','task'))
+            AND CASE
+                  WHEN instr(ue.entry_ref, '//') > 0
+                    THEN substr(ue.entry_ref, instr(ue.entry_ref, '//') + 2)
+                  ELSE ue.entry_ref
+                END IN (${placeholders})`).all(...chunk);
+    for (const row of rows) {
+      const bare = bareRef(row.entry_ref);
+      const linkedToSelectedRoot = row.entry_id !== null && selectedRoot !== undefined && row.stash_dir !== null ? path13.resolve(row.stash_dir) === selectedRoot : false;
+      const detached = row.entry_id === null || selectedRoot === undefined;
+      const qualifiedForSource = detached && options.sourceName !== undefined && row.entry_ref === `${options.sourceName}//${bare}`;
+      const acceptedLegacyBare = detached && options.includeLegacyBare === true && row.entry_ref === bare;
+      if (!linkedToSelectedRoot && !qualifiedForSource && !acceptedLegacyBare)
+        continue;
+      countsByBare.set(bare, (countsByBare.get(bare) ?? 0) + 1);
+    }
+  }
+  const result = new Map;
+  for (const [bare, count] of countsByBare) {
+    for (const input of bareToInputs.get(bare) ?? [])
+      result.set(input, count);
+  }
+  return result;
+}
 function bumpUtilityScoresBatch(db, entryIds, reward, lr = 0.1, scopeKey) {
   if (entryIds.length === 0)
     return;
@@ -19833,7 +19720,15 @@ function applyFeedbackToUtilityScore(db, entryId, positiveCount, negativeCount)
   `).run(entryId, result.nextUtility, now, now, result.nextUtility, now);
   return result;
 }
-function relinkUsageEvents(db) {
+function resolveUsageEventEntryId(db, ref, options) {
+  const parsed = parseAssetRef(ref);
+  if (!parsed.origin) {
+    return options.defaultStashDir ? findEntryIdByRef(db, ref, options.defaultStashDir) : undefined;
+  }
+  const source = parsed.origin === "local" || parsed.origin === "stash" ? options.sources?.[0] : options.sources?.find((candidate) => candidate.registryId === parsed.origin);
+  return source ? findEntryIdByRef(db, ref, source.path) : undefined;
+}
+function relinkUsageEvents(db, options = {}) {
   bestEffort(() => {
     db.exec(`
       UPDATE usage_events
@@ -19847,7 +19742,7 @@ function relinkUsageEvents(db) {
       for (const { ref } of refs) {
         let id;
         try {
-          id = findEntryIdByRef(db, ref);
+          id = resolveUsageEventEntryId(db, ref, options);
         } catch (err) {
           if (err instanceof Error && err.name === "UsageError")
             continue;
@@ -19912,12 +19807,12 @@ __export(exports_graph_db, {
   drainExtractionQueue: () => drainExtractionQueue,
   deleteStoredGraph: () => deleteStoredGraph
 });
-import fs15 from "node:fs";
+import fs14 from "node:fs";
 function withReadableGraphDb(db, fn) {
   if (db)
     return fn(db);
   const dbPath = getDbPath();
-  if (!fs15.existsSync(dbPath))
+  if (!fs14.existsSync(dbPath))
     throw new Error("GRAPH_DB_MISSING");
   const opened = openExistingDatabase(dbPath);
   try {
@@ -20260,15 +20155,15 @@ var init_graph_db = __esm(() => {
 });
 
 // scripts/migrate-storage.ts
-import fs16 from "fs";
+import fs15 from "fs";
 import os3 from "os";
-import path16 from "path";
+import path14 from "path";
 import readline from "readline";
 
 // src/core/paths.ts
 init_common();
 init_errors();
-import path12 from "node:path";
+import path9 from "node:path";
 function isTransientStashPath2(p) {
   return p.startsWith("/tmp/") || p === "/tmp" || p.startsWith("/var/tmp/") || p === "/var/tmp" || p.startsWith("/private/tmp/") || p.startsWith("/private/var/folders/") || p.startsWith("/var/folders/");
 }
@@ -20279,34 +20174,34 @@ function getConfigDir2(env = process.env, platform = process.platform) {
   if (platform === "win32") {
     const appData = env.APPDATA?.trim();
     if (appData)
-      return path12.join(appData, "akm");
+      return path9.join(appData, "akm");
   } else {
     const xdgConfigHome2 = env.XDG_CONFIG_HOME?.trim();
     if (xdgConfigHome2)
-      return path12.join(xdgConfigHome2, "akm");
+      return path9.join(xdgConfigHome2, "akm");
   }
   const stashOverride = env.AKM_STASH_DIR?.trim();
   if (stashOverride && isTransientStashPath2(stashOverride)) {
-    return path12.join(stashOverride, ".akm");
+    return path9.join(stashOverride, ".akm");
   }
   if (platform === "win32") {
     const appData = env.APPDATA?.trim();
     if (appData)
-      return path12.join(appData, "akm");
+      return path9.join(appData, "akm");
     const userProfile = env.USERPROFILE?.trim();
     if (!userProfile) {
       throw new ConfigError("Unable to determine config directory. Set APPDATA or USERPROFILE.", "CONFIG_DIR_UNRESOLVABLE");
     }
-    return path12.join(userProfile, "AppData", "Roaming", "akm");
+    return path9.join(userProfile, "AppData", "Roaming", "akm");
   }
   const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
   if (xdgConfigHome)
-    return path12.join(xdgConfigHome, "akm");
+    return path9.join(xdgConfigHome, "akm");
   const home = env.HOME?.trim();
   if (!home) {
     throw new ConfigError("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.", "CONFIG_DIR_UNRESOLVABLE");
   }
-  return path12.join(home, ".config", "akm");
+  return path9.join(home, ".config", "akm");
 }
 function getCacheDir2(env = process.env) {
   const override = env.AKM_CACHE_DIR?.trim();
@@ -20315,30 +20210,30 @@ function getCacheDir2(env = process.env) {
   if (IS_WINDOWS) {
     const localAppData = env.LOCALAPPDATA?.trim();
     if (localAppData)
-      return path12.join(localAppData, "akm");
+      return path9.join(localAppData, "akm");
     const userProfile = env.USERPROFILE?.trim();
     if (userProfile)
-      return path12.join(userProfile, "AppData", "Local", "akm");
+      return path9.join(userProfile, "AppData", "Local", "akm");
     const appData = env.APPDATA?.trim();
     if (appData) {
-      return path12.join(appData, "..", "Local", "akm");
+      return path9.join(appData, "..", "Local", "akm");
     }
   } else {
     const xdgCacheHome = env.XDG_CACHE_HOME?.trim();
     if (xdgCacheHome)
-      return path12.join(xdgCacheHome, "akm");
+      return path9.join(xdgCacheHome, "akm");
   }
   const stashOverride = env.AKM_STASH_DIR?.trim();
   if (stashOverride && isTransientStashPath2(stashOverride)) {
-    return path12.join(stashOverride, ".akm", "cache");
+    return path9.join(stashOverride, ".akm", "cache");
   }
   if (IS_WINDOWS) {
     throw new ConfigError("Unable to determine cache directory. Set LOCALAPPDATA, USERPROFILE, or APPDATA.", "CONFIG_DIR_UNRESOLVABLE");
   }
   const home = env.HOME?.trim();
   if (!home)
-    return path12.join("/tmp", "akm-cache");
-  return path12.join(home, ".cache", "akm");
+    return path9.join("/tmp", "akm-cache");
+  return path9.join(home, ".cache", "akm");
 }
 function getDefaultStashDir2(env = process.env) {
   const override = env.AKM_STASH_DIR?.trim();
@@ -20347,14 +20242,14 @@ function getDefaultStashDir2(env = process.env) {
   if (IS_WINDOWS) {
     const userProfile = env.USERPROFILE?.trim();
     if (userProfile)
-      return path12.join(userProfile, "Documents", "akm");
-    return path12.join("C:\\", "akm");
+      return path9.join(userProfile, "Documents", "akm");
+    return path9.join("C:\\", "akm");
   }
   const home = env.HOME?.trim();
   if (!home) {
     throw new ConfigError("Unable to determine default stash directory. Set HOME.", "STASH_DIR_NOT_FOUND");
   }
-  return path12.join(home, "akm");
+  return path9.join(home, "akm");
 }
 
 // src/indexer/usage/unmigrated-vaults-guard.ts
@@ -20379,12 +20274,12 @@ function parseFromArg() {
   return val;
 }
 var FROM_VERSION = parseFromArg();
-var dataDir = process.env.AKM_DATA_DIR?.trim() ?? (process.env.XDG_DATA_HOME?.trim() ? path16.join(process.env.XDG_DATA_HOME.trim(), "akm") : path16.join(os3.homedir(), ".local", "share", "akm"));
-var stateDir = process.env.AKM_STATE_DIR?.trim() ?? (process.env.XDG_STATE_HOME?.trim() ? path16.join(process.env.XDG_STATE_HOME.trim(), "akm") : path16.join(os3.homedir(), ".local", "state", "akm"));
+var dataDir = process.env.AKM_DATA_DIR?.trim() ?? (process.env.XDG_DATA_HOME?.trim() ? path14.join(process.env.XDG_DATA_HOME.trim(), "akm") : path14.join(os3.homedir(), ".local", "share", "akm"));
+var stateDir = process.env.AKM_STATE_DIR?.trim() ?? (process.env.XDG_STATE_HOME?.trim() ? path14.join(process.env.XDG_STATE_HOME.trim(), "akm") : path14.join(os3.homedir(), ".local", "state", "akm"));
 var cacheDir = getCacheDir2();
 var configDir = getConfigDir2();
-var stateDbPath = path16.join(dataDir, "state.db");
-var indexDbPath = path16.join(dataDir, "index.db");
+var stateDbPath = path14.join(dataDir, "state.db");
+var indexDbPath = path14.join(dataDir, "index.db");
 var PATHS = {
   cacheDir,
   configDir,
@@ -20395,14 +20290,14 @@ var PATHS = {
 };
 var versionReports = [];
 function ensureDir(dir) {
-  if (!fs16.existsSync(dir)) {
-    fs16.mkdirSync(dir, { recursive: true });
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
   }
 }
 function copyAndVerify(src, dest) {
-  fs16.copyFileSync(src, dest);
-  const srcStat = fs16.statSync(src);
-  const destStat = fs16.statSync(dest);
+  fs15.copyFileSync(src, dest);
+  const srcStat = fs15.statSync(src);
+  const destStat = fs15.statSync(dest);
   return destStat.size === srcStat.size;
 }
 function copyTree(src, dest, opts) {
@@ -20410,9 +20305,9 @@ function copyTree(src, dest, opts) {
   let skipped = 0;
   let failed = 0;
   ensureDir(dest);
-  for (const entry of fs16.readdirSync(src, { withFileTypes: true })) {
-    const srcEntry = path16.join(src, entry.name);
-    const destEntry = path16.join(dest, entry.name);
+  for (const entry of fs15.readdirSync(src, { withFileTypes: true })) {
+    const srcEntry = path14.join(src, entry.name);
+    const destEntry = path14.join(dest, entry.name);
     if (entry.isDirectory()) {
       const sub = copyTree(srcEntry, destEntry, opts);
       copied += sub.copied;
@@ -20420,7 +20315,7 @@ function copyTree(src, dest, opts) {
       failed += sub.failed;
       continue;
     }
-    if (!opts.clobber && fs16.existsSync(destEntry)) {
+    if (!opts.clobber && fs15.existsSync(destEntry)) {
       skipped++;
       continue;
     }
@@ -20438,9 +20333,9 @@ function copyTree(src, dest, opts) {
 }
 function countFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      count += countFilesRecursive(path16.join(dir, entry.name));
+      count += countFilesRecursive(path14.join(dir, entry.name));
     } else {
       count++;
     }
@@ -20453,12 +20348,12 @@ async function runSteps(steps, ctx) {
   }
 }
 function migrateDb(ctx, filename) {
-  const src = path16.join(ctx.paths.cacheDir, filename);
-  const dest = path16.join(ctx.paths.dataDir, filename);
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, filename);
+  const dest = path14.join(ctx.paths.dataDir, filename);
+  if (!fs15.existsSync(src)) {
     return { name: filename, status: "skipped", detail: "source not found" };
   }
-  if (fs16.existsSync(dest)) {
+  if (fs15.existsSync(dest)) {
     return { name: filename, status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -20476,8 +20371,8 @@ function migrateDb(ctx, filename) {
   return { name: filename, status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
 }
 async function migrateEventsJsonl(ctx) {
-  const src = path16.join(ctx.paths.cacheDir, "events.jsonl");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, "events.jsonl");
+  if (!fs15.existsSync(src)) {
     return { name: "events.jsonl \u2192 state.db", status: "skipped", detail: "source not found" };
   }
   if (ctx.dryRun) {
@@ -20522,13 +20417,13 @@ async function migrateEventsJsonl(ctx) {
   }
 }
 function migrateTaskHistory(ctx) {
-  const src = path16.join(ctx.paths.cacheDir, "tasks", "history");
-  const dest = path16.join(ctx.paths.stateDir, "tasks", "history");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, "tasks", "history");
+  const dest = path14.join(ctx.paths.stateDir, "tasks", "history");
+  if (!fs15.existsSync(src)) {
     return { name: "tasks/history/", status: "skipped", detail: "source directory not found" };
   }
   try {
-    const files = fs16.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+    const files = fs15.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
     if (files.length === 0) {
       return { name: "tasks/history/", status: "skipped", detail: "no *.jsonl files found in source directory" };
     }
@@ -20543,8 +20438,8 @@ function migrateTaskHistory(ctx) {
     let copied = 0;
     let failed = 0;
     for (const file of files) {
-      const srcFile = path16.join(src, file);
-      const destFile = path16.join(dest, file);
+      const srcFile = path14.join(src, file);
+      const destFile = path14.join(dest, file);
       try {
         if (copyAndVerify(srcFile, destFile)) {
           copied++;
@@ -20573,12 +20468,12 @@ function migrateTaskHistory(ctx) {
   }
 }
 function migrateLockfile(ctx) {
-  const src = path16.join(ctx.paths.configDir, "akm.lock");
-  const dest = path16.join(ctx.paths.dataDir, "akm.lock");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.configDir, "akm.lock");
+  const dest = path14.join(ctx.paths.dataDir, "akm.lock");
+  if (!fs15.existsSync(src)) {
     return { name: "akm.lock", status: "skipped", detail: "source not found" };
   }
-  if (fs16.existsSync(dest)) {
+  if (fs15.existsSync(dest)) {
     return { name: "akm.lock", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -20598,12 +20493,12 @@ function migrateLockfile(ctx) {
   return { name: "akm.lock", status: "failed", detail: `size mismatch after copy: ${src} \u2192 ${dest}` };
 }
 function migrateConfigBackups(ctx) {
-  const src = path16.join(ctx.paths.cacheDir, "config-backups");
-  const dest = path16.join(ctx.paths.dataDir, "config-backups");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, "config-backups");
+  const dest = path14.join(ctx.paths.dataDir, "config-backups");
+  if (!fs15.existsSync(src)) {
     return { name: "config-backups/", status: "skipped", detail: "source directory not found" };
   }
-  if (fs16.existsSync(dest)) {
+  if (fs15.existsSync(dest)) {
     return { name: "config-backups/", status: "skipped", detail: "destination already exists" };
   }
   if (ctx.dryRun) {
@@ -20620,7 +20515,7 @@ function migrateConfigBackups(ctx) {
   try {
     const srcCount = countFilesRecursive(src);
     const { copied, failed } = copyTree(src, dest, { clobber: true });
-    const destCount = fs16.existsSync(dest) ? countFilesRecursive(dest) : 0;
+    const destCount = fs15.existsSync(dest) ? countFilesRecursive(dest) : 0;
     if (failed === 0 && destCount === srcCount) {
       return {
         name: "config-backups/",
@@ -20639,11 +20534,11 @@ function migrateConfigBackups(ctx) {
   }
 }
 async function migrateTaskHistoryToDb(ctx) {
-  const src = path16.join(ctx.paths.cacheDir, "tasks", "history");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, "tasks", "history");
+  if (!fs15.existsSync(src)) {
     return { name: "tasks/history/ \u2192 state.db", status: "skipped", detail: "source directory not found" };
   }
-  const files = fs16.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
+  const files = fs15.readdirSync(src).filter((f) => f.endsWith(".jsonl"));
   if (files.length === 0) {
     return {
       name: "tasks/history/ \u2192 state.db",
@@ -20667,8 +20562,8 @@ async function migrateTaskHistoryToDb(ctx) {
     let failed = 0;
     try {
       for (const file of files) {
-        const filePath = path16.join(src, file);
-        const text = fs16.readFileSync(filePath, "utf8");
+        const filePath = path14.join(src, file);
+        const text = fs15.readFileSync(filePath, "utf8");
         const lines = text.split(`
 `).filter((l) => l.trim().length > 0);
         db.exec("BEGIN");
@@ -20727,11 +20622,11 @@ async function migrateTaskHistoryToDb(ctx) {
   }
 }
 function noteRegistryIndexCache(ctx) {
-  const src = path16.join(ctx.paths.cacheDir, "registry-index");
-  if (!fs16.existsSync(src)) {
+  const src = path14.join(ctx.paths.cacheDir, "registry-index");
+  if (!fs15.existsSync(src)) {
     return { name: "registry-index/ (note)", status: "skipped", detail: "no old $CACHE/registry-index/ directory found" };
   }
-  const legacyFiles = fs16.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
+  const legacyFiles = fs15.readdirSync(src).filter((f) => f.endsWith(".json") && !f.startsWith("website-"));
   if (legacyFiles.length === 0) {
     return { name: "registry-index/ (note)", status: "skipped", detail: "no old *.json cache files found" };
   }
@@ -20741,7 +20636,7 @@ 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) => `          ${path16.join(src, f)}`).join(`
+` + legacyFiles.map((f) => `          ${path14.join(src, f)}`).join(`
 `));
   }
   return {
@@ -20755,15 +20650,15 @@ var v07To08Migration = {
   sourceVersion: "0.7",
   isNeeded: (paths) => {
     const candidates = [
-      path16.join(paths.cacheDir, "index.db"),
-      path16.join(paths.cacheDir, "workflow.db"),
-      path16.join(paths.cacheDir, "events.jsonl"),
-      path16.join(paths.cacheDir, "tasks", "history"),
-      path16.join(paths.configDir, "akm.lock"),
-      path16.join(paths.cacheDir, "config-backups"),
-      path16.join(paths.cacheDir, "registry-index")
+      path14.join(paths.cacheDir, "index.db"),
+      path14.join(paths.cacheDir, "workflow.db"),
+      path14.join(paths.cacheDir, "events.jsonl"),
+      path14.join(paths.cacheDir, "tasks", "history"),
+      path14.join(paths.configDir, "akm.lock"),
+      path14.join(paths.cacheDir, "config-backups"),
+      path14.join(paths.cacheDir, "registry-index")
     ];
-    return candidates.some((p) => fs16.existsSync(p));
+    return candidates.some((p) => fs15.existsSync(p));
   },
   steps: [
     { id: "index-db", title: "index.db", run: (ctx) => migrateDb(ctx, "index.db") },
@@ -20778,20 +20673,20 @@ var v07To08Migration = {
 };
 function legacyGraphCandidatePaths(ctx) {
   return [
-    path16.join(ctx.paths.cacheDir, "graph-snapshot.json"),
-    path16.join(ctx.paths.dataDir, "graph-snapshot.json"),
-    path16.join(ctx.paths.dataDir, "graph-export.json")
+    path14.join(ctx.paths.cacheDir, "graph-snapshot.json"),
+    path14.join(ctx.paths.dataDir, "graph-snapshot.json"),
+    path14.join(ctx.paths.dataDir, "graph-export.json")
   ];
 }
 function findLegacyGraphFile(ctx) {
   for (const candidate of legacyGraphCandidatePaths(ctx)) {
-    if (fs16.existsSync(candidate) && fs16.statSync(candidate).isFile())
+    if (fs15.existsSync(candidate) && fs15.statSync(candidate).isFile())
       return candidate;
   }
-  const graphDir = path16.join(ctx.paths.cacheDir, "graph");
-  if (fs16.existsSync(graphDir) && fs16.statSync(graphDir).isDirectory()) {
+  const graphDir = path14.join(ctx.paths.cacheDir, "graph");
+  if (fs15.existsSync(graphDir) && fs15.statSync(graphDir).isDirectory()) {
     try {
-      const json = fs16.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path16.join(graphDir, f));
+      const json = fs15.readdirSync(graphDir).filter((f) => f.endsWith(".json")).map((f) => path14.join(graphDir, f));
       if (json.length > 0)
         return json[0];
     } catch {}
@@ -20827,7 +20722,7 @@ async function migrateGraphFileToDb(ctx) {
   if (!legacyFile) {
     return { name, status: "skipped", detail: "no legacy graph file found" };
   }
-  if (!fs16.existsSync(ctx.paths.indexDbPath)) {
+  if (!fs15.existsSync(ctx.paths.indexDbPath)) {
     return {
       name,
       status: "skipped",
@@ -20842,7 +20737,7 @@ async function migrateGraphFileToDb(ctx) {
     };
   }
   try {
-    const raw = fs16.readFileSync(legacyFile, "utf8");
+    const raw = fs15.readFileSync(legacyFile, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20919,7 +20814,7 @@ async function migrateGraphFileToDb(ctx) {
       }
       const renamed = `${legacyFile}.migrated`;
       try {
-        fs16.renameSync(legacyFile, renamed);
+        fs15.renameSync(legacyFile, renamed);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         return {
@@ -20943,9 +20838,9 @@ async function migrateGraphFileToDb(ctx) {
 }
 function resolvePrimaryStashDir(configDirPath) {
   try {
-    const cfgPath = path16.join(configDirPath, "config.json");
-    if (fs16.existsSync(cfgPath)) {
-      const cfg = JSON.parse(fs16.readFileSync(cfgPath, "utf8"));
+    const cfgPath = path14.join(configDirPath, "config.json");
+    if (fs15.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
       if (typeof cfg.stashDir === "string" && cfg.stashDir.length > 0)
         return cfg.stashDir;
     }
@@ -20954,8 +20849,8 @@ function resolvePrimaryStashDir(configDirPath) {
 }
 function countEnvFilesRecursive(dir) {
   let count = 0;
-  for (const entry of fs16.readdirSync(dir, { withFileTypes: true })) {
-    const full = path16.join(dir, entry.name);
+  for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
+    const full = path14.join(dir, entry.name);
     if (entry.isDirectory()) {
       count += countEnvFilesRecursive(full);
     } else if (entry.name === ".env" || entry.name.endsWith(".env")) {
@@ -20967,13 +20862,13 @@ function countEnvFilesRecursive(dir) {
 function chmodTreeSecure(dir) {
   const isWin = process.platform === "win32";
   try {
-    fs16.chmodSync(dir, 448);
+    fs15.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 fs16.readdirSync(dir, { withFileTypes: true })) {
-    const full = path16.join(dir, entry.name);
+  for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
+    const full = path14.join(dir, entry.name);
     if (entry.isDirectory()) {
       const sub = chmodTreeSecure(full);
       if (!sub.ok)
@@ -20981,8 +20876,8 @@ function chmodTreeSecure(dir) {
       continue;
     }
     try {
-      fs16.chmodSync(full, 384);
-      if (!isWin && (fs16.statSync(full).mode & 511) !== 384) {
+      fs15.chmodSync(full, 384);
+      if (!isWin && (fs15.statSync(full).mode & 511) !== 384) {
         return { ok: false, detail: `mode verification failed for ${full}` };
       }
     } catch (err) {
@@ -20995,13 +20890,13 @@ function chmodTreeSecure(dir) {
 async function migrateVaultsToEnv(ctx) {
   const name = "vaults/ \u2192 env/";
   const stashDir = resolvePrimaryStashDir(ctx.paths.configDir);
-  const vaultsDir = path16.join(stashDir, "vaults");
-  const envDir = path16.join(stashDir, "env");
-  const marker = path16.join(vaultsDir, MIGRATED_MARKER);
-  if (!fs16.existsSync(vaultsDir)) {
+  const vaultsDir = path14.join(stashDir, "vaults");
+  const envDir = path14.join(stashDir, "env");
+  const marker = path14.join(vaultsDir, MIGRATED_MARKER);
+  if (!fs15.existsSync(vaultsDir)) {
     return { name, status: "skipped", detail: `no vaults/ directory under ${stashDir}` };
   }
-  if (fs16.existsSync(marker)) {
+  if (fs15.existsSync(marker)) {
     return { name, status: "skipped", detail: "already migrated (.migrated marker present)" };
   }
   const vaultEnvCount = countEnvFilesRecursive(vaultsDir);
@@ -21032,7 +20927,7 @@ async function migrateVaultsToEnv(ctx) {
         detail: `post-copy count ${envEnvCount} < source ${vaultEnvCount}; no marker written`
       };
     }
-    fs16.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
+    fs15.writeFileSync(marker, `migrated vaults/ -> env/ at ${new Date().toISOString()}
 `, { mode: 384 });
     return {
       name,
@@ -21054,7 +20949,7 @@ var v08To09Migration = {
     { id: "vaults-to-env", title: "vaults/ \u2192 env/", run: migrateVaultsToEnv }
   ]
 };
-var MIGRATIONS2 = [v07To08Migration, v08To09Migration];
+var MIGRATIONS = [v07To08Migration, v08To09Migration];
 async function confirm() {
   if (YES)
     return true;
@@ -21068,7 +20963,7 @@ async function confirm() {
 }
 function printList() {
   console.log("akm storage migrations (in execution order):");
-  for (const m of MIGRATIONS2) {
+  for (const m of MIGRATIONS) {
     console.log(`  \u2022 ${m.label}    [sourceVersion=${m.sourceVersion}]`);
   }
   console.log();
@@ -21092,8 +20987,8 @@ function compareVersion(a, b) {
 }
 function filteredMigrations() {
   if (!FROM_VERSION)
-    return MIGRATIONS2;
-  return MIGRATIONS2.filter((m) => compareVersion(m.sourceVersion, FROM_VERSION) >= 0);
+    return MIGRATIONS;
+  return MIGRATIONS.filter((m) => compareVersion(m.sourceVersion, FROM_VERSION) >= 0);
 }
 function printGroupedSummary() {
   console.log(`
@@ -21138,12 +21033,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:
-  ${path16.join(cacheDir, "index.db")}
-  ${path16.join(cacheDir, "workflow.db")}
-  ${path16.join(cacheDir, "events.jsonl")}
-  ${path16.join(cacheDir, "tasks", "history")}
-  ${path16.join(cacheDir, "config-backups")}
-  ${path16.join(configDir, "akm.lock")}
+  ${path14.join(cacheDir, "index.db")}
+  ${path14.join(cacheDir, "workflow.db")}
+  ${path14.join(cacheDir, "events.jsonl")}
+  ${path14.join(cacheDir, "tasks", "history")}
+  ${path14.join(cacheDir, "config-backups")}
+  ${path14.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
@@ -21236,7 +21131,7 @@ var invokedDirectly = (() => {
     if (!entry)
       return false;
     const here = new URL(import.meta.url).pathname;
-    return path16.resolve(entry) === here;
+    return path14.resolve(entry) === here;
   } catch {
     return false;
   }
@@ -21247,5 +21142,5 @@ if (invokedDirectly) {
 export {
   runMigrations3 as runMigrations,
   main,
-  MIGRATIONS2 as MIGRATIONS
+  MIGRATIONS
 };