akm-cli 0.9.0-beta.9 → 0.9.0-rc.1

package/dist/scripts/migrations/import-fs-improve-runs-to-db.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 // @bun
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -32,23 +33,53 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/core/warn.ts
+import fs from "node:fs";
+function appendToLogFile(level, args) {
+  if (!logFilePath)
+    return;
+  const ts = new Date().toISOString();
+  const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+  try {
+    fs.appendFileSync(logFilePath, `[${ts}] [${level}] ${msg}
+`);
+  } catch (e) {
+    process.stderr.write(`[akm:warn] log-file write failed (${logFilePath}): ${e}
+`);
+    process.stderr.write(`[${ts}] [${level}] ${msg}
+`);
+  }
+}
+function warn(...args) {
+  if (sinkOverride) {
+    sinkOverride("warn", args);
+    return;
+  }
+  appendToLogFile("WARN", args);
+  if (!quiet) {
+    console.warn(...args);
+  }
+}
+var quiet = false, logFilePath, sinkOverride;
+var init_warn = () => {};
 
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var path = __require("path");
+  var fs3 = __require("fs");
+  var path2 = __require("path");
   var os = __require("os");
   var crypto = __require("crypto");
   var TIPS = [
-    "\u25C8 encrypted .env [www.dotenvx.com]",
-    "\u25C8 secrets for agents [www.dotenvx.com]",
-    "\u2301 auth for agents [www.vestauth.com]",
-    "\u2318 custom filepath { path: '/custom/path/.env' }",
-    "\u2318 enable debugging { debug: true }",
-    "\u2318 override existing { override: true }",
-    "\u2318 suppress logs { quiet: true }",
-    "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    "◈ encrypted .env [www.dotenvx.com]",
+    "◈ secrets for agents [www.dotenvx.com]",
+    "⌁ auth for agents [www.vestauth.com]",
+    "⌘ custom filepath { path: '/custom/path/.env' }",
+    "⌘ enable debugging { debug: true }",
+    "⌘ override existing { override: true }",
+    "⌘ suppress logs { quiet: true }",
+    "⌘ multiple files { path: ['.env.local', '.env'] }"
   ];
   function _getRandomTip() {
     return TIPS[Math.floor(Math.random() * TIPS.length)];
@@ -115,13 +146,13 @@ var require_main = __commonJS((exports, module) => {
     return DotenvModule.parse(decrypted);
   }
   function _warn(message) {
-    console.error(`\u26A0 ${message}`);
+    console.error(`⚠ ${message}`);
   }
   function _debug(message) {
-    console.log(`\u2506 ${message}`);
+    console.log(`┆ ${message}`);
   }
   function _log(message) {
-    console.log(`\u25C7 ${message}`);
+    console.log(`◇ ${message}`);
   }
   function _dotenvKey(options) {
     if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
@@ -170,7 +201,7 @@ var require_main = __commonJS((exports, module) => {
     if (options && options.path && options.path.length > 0) {
       if (Array.isArray(options.path)) {
         for (const filepath of options.path) {
-          if (fs.existsSync(filepath)) {
+          if (fs3.existsSync(filepath)) {
             possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
           }
         }
@@ -178,20 +209,20 @@ var require_main = __commonJS((exports, module) => {
         possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
       }
     } else {
-      possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
     }
-    if (fs.existsSync(possibleVaultPath)) {
+    if (fs3.existsSync(possibleVaultPath)) {
       return possibleVaultPath;
     }
     return null;
   }
   function _resolveHome(envPath) {
-    return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
   }
   function _configVault(options) {
     const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
-    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
-    if (debug || !quiet) {
+    const quiet2 = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+    if (debug || !quiet2) {
       _log("loading env from encrypted .env.vault");
     }
     const parsed = DotenvModule._parseVault(options);
@@ -203,14 +234,14 @@ var require_main = __commonJS((exports, module) => {
     return { parsed };
   }
   function configDotenv(options) {
-    const dotenvPath = path.resolve(process.cwd(), ".env");
+    const dotenvPath = path2.resolve(process.cwd(), ".env");
     let encoding = "utf8";
     let processEnv = process.env;
     if (options && options.processEnv != null) {
       processEnv = options.processEnv;
     }
     let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
-    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+    let quiet2 = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
     if (options && options.encoding) {
       encoding = options.encoding;
     } else {
@@ -231,26 +262,26 @@ var require_main = __commonJS((exports, module) => {
     }
     let lastError;
     const parsedAll = {};
-    for (const path2 of optionPaths) {
+    for (const path3 of optionPaths) {
       try {
-        const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+        const parsed = DotenvModule.parse(fs3.readFileSync(path3, { encoding }));
         DotenvModule.populate(parsedAll, parsed, options);
       } catch (e) {
         if (debug) {
-          _debug(`failed to load ${path2} ${e.message}`);
+          _debug(`failed to load ${path3} ${e.message}`);
         }
         lastError = e;
       }
     }
     const populated = DotenvModule.populate(processEnv, parsedAll, options);
     debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
-    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
-    if (debug || !quiet) {
+    quiet2 = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet2);
+    if (debug || !quiet2) {
       const keysCount = Object.keys(populated).length;
       const shortPaths = [];
       for (const filePath of optionPaths) {
         try {
-          const relative = path.relative(process.cwd(), filePath);
+          const relative = path2.relative(process.cwd(), filePath);
           shortPaths.push(relative);
         } catch (e) {
           if (debug) {
@@ -363,8 +394,9 @@ var init_errors = __esm(() => {
     EMBEDDING_NOT_CONFIGURED: 'Run `akm config set embedding \'{"endpoint":"...","model":"..."}\'` to enable embeddings.',
     LLM_NOT_CONFIGURED: 'Run `akm setup` or `akm config set profiles.llm.default \'{"endpoint":"...","model":"..."}\' to configure an LLM profile.',
     TEST_ISOLATION_MISSING: "Under bun test, when AKM_STASH_DIR is set you MUST also set XDG_DATA_HOME (or AKM_DATA_DIR) and XDG_STATE_HOME (or AKM_STATE_DIR) to temp directories so the test does not touch the developer's real ~/.local/share/akm or ~/.local/state/akm.",
-    SETUP_TMP_STASH_REFUSED: "Use a persistent directory, or set AKM_FORCE_SETUP_TMP_STASH=1 to opt in to a sandboxed setup (setup also pre-sets AKM_STASH_DIR so config and cache writes auto-isolate into $stashDir/.akm/ \u2014 host config is preserved).",
-    UNSAFE_STASH_DIR: "Choose a path inside your home directory (e.g. ~/akm) or another empty workspace. The stash directory cannot be the filesystem root, your home directory itself, or a sensitive system path like /etc, /var, ~/.config, or ~/.ssh."
+    SETUP_TMP_STASH_REFUSED: "Use a persistent directory, or set AKM_FORCE_SETUP_TMP_STASH=1 to opt in to a sandboxed setup (setup also pre-sets AKM_STASH_DIR so config and cache writes auto-isolate into $stashDir/.akm/ — host config is preserved).",
+    UNSAFE_STASH_DIR: "Choose a path inside your home directory (e.g. ~/akm) or another empty workspace. The stash directory cannot be the filesystem root, your home directory itself, or a sensitive system path like /etc, /var, ~/.config, or ~/.ssh.",
+    UNKNOWN_IMPROVE_PROFILE: "Pass one of the listed profile names to `--profile`, or define it under `profiles.improve` in your config. Names are case-sensitive."
   };
   USAGE_HINTS = {
     INVALID_FLAG_VALUE: "Run `akm <command> --help` to see accepted values.",
@@ -412,7 +444,7 @@ var init_errors = __esm(() => {
 });
 
 // src/commands/env/env.ts
-import fs from "fs";
+import fs3 from "node:fs";
 function scanKeys(text) {
   const keys = [];
   const seen = new Set;
@@ -428,21 +460,11 @@ function scanKeys(text) {
   }
   return keys;
 }
-function scanComments(text) {
-  const comments = [];
-  for (const line of text.split(/\r?\n/)) {
-    const trimmed = line.trimStart();
-    if (trimmed.startsWith("#")) {
-      comments.push(trimmed.slice(1).trimStart());
-    }
-  }
-  return comments;
-}
 function listKeys(envPath) {
-  if (!fs.existsSync(envPath))
-    return { keys: [], comments: [] };
-  const text = fs.readFileSync(envPath, "utf8");
-  return { keys: scanKeys(text), comments: scanComments(text) };
+  if (!fs3.existsSync(envPath))
+    return { keys: [] };
+  const text = fs3.readFileSync(envPath, "utf8");
+  return { keys: scanKeys(text) };
 }
 var import_dotenv, ASSIGN_RE;
 var init_env = __esm(() => {
@@ -452,251 +474,6 @@ var init_env = __esm(() => {
   ASSIGN_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
 });
 
-// src/core/asset/frontmatter.ts
-function parseFrontmatter(raw) {
-  const parsedBlock = parseFrontmatterBlock(raw);
-  if (!parsedBlock) {
-    return { data: {}, content: raw, frontmatter: null, bodyStartLine: 1 };
-  }
-  const data = {};
-  let currentKey = null;
-  let mode = "scalar";
-  let nested = null;
-  let currentList = null;
-  let blockLines = null;
-  let blockChomping = "clip";
-  const flushPending = () => {
-    if (mode === "pending" && currentKey !== null) {
-      data[currentKey] = "";
-    }
-  };
-  const flushBlock = () => {
-    if (mode !== "block" || currentKey === null || blockLines === null)
-      return;
-    const deindented = blockLines.map((l) => l.startsWith("  ") ? l.slice(2) : l);
-    if (blockChomping === "keep") {
-      data[currentKey] = deindented.join(`
-`);
-    } else if (blockChomping === "strip") {
-      data[currentKey] = deindented.join(`
-`).replace(/\n+$/, "");
-    } else {
-      data[currentKey] = `${deindented.join(`
-`).replace(/\n+$/, "")}
-`;
-    }
-  };
-  for (const line of parsedBlock.frontmatter.split(/\r?\n/)) {
-    if (mode === "block") {
-      if (line.startsWith("  ") || line === "") {
-        blockLines.push(line);
-        continue;
-      }
-      flushBlock();
-      mode = "scalar";
-      blockLines = null;
-    }
-    const seqItem = line.match(/^(?: {2})?- (.*)$/);
-    if (seqItem && currentKey !== null && (mode === "list" || mode === "pending")) {
-      if (mode === "pending") {
-        currentList = [];
-        data[currentKey] = currentList;
-        mode = "list";
-      }
-      currentList.push(parseYamlScalar(seqItem[1].trim()));
-      continue;
-    }
-    if (mode === "scalar" && currentKey !== null && /^ {2}\S/.test(line)) {
-      data[currentKey] = `${String(data[currentKey])} ${line.trim()}`;
-      continue;
-    }
-    const indented = line.match(/^ {2}(\w[\w-]*):\s*(.+)$/);
-    if (indented && currentKey !== null && (mode === "object" || mode === "pending")) {
-      if (mode === "pending") {
-        nested = {};
-        data[currentKey] = nested;
-        mode = "object";
-      }
-      nested[indented[1]] = parseYamlScalar(indented[2].trim());
-      continue;
-    }
-    const top = line.match(/^(\w[\w-]*):\s*(.*)$/);
-    if (!top) {
-      continue;
-    }
-    flushPending();
-    currentKey = top[1];
-    const value = top[2].trim();
-    if (value === "|" || value === "|-" || value === "|+") {
-      mode = "block";
-      blockLines = [];
-      blockChomping = value === "|-" ? "strip" : value === "|+" ? "keep" : "clip";
-      nested = null;
-      currentList = null;
-    } else if (value === "") {
-      mode = "pending";
-      nested = null;
-      currentList = null;
-    } else if (value.startsWith("[") && value.endsWith("]")) {
-      mode = "list";
-      nested = null;
-      currentList = null;
-      currentList = parseFlowArray(value);
-      data[currentKey] = currentList;
-    } else {
-      mode = "scalar";
-      nested = null;
-      currentList = null;
-      data[currentKey] = parseYamlScalar(value);
-    }
-  }
-  if (mode === "block") {
-    flushBlock();
-  }
-  flushPending();
-  return {
-    data,
-    content: parsedBlock.content,
-    frontmatter: parsedBlock.frontmatter,
-    bodyStartLine: parsedBlock.bodyStartLine
-  };
-}
-function parseFlowArray(value) {
-  const inner = value.slice(1, -1).trim();
-  if (!inner)
-    return [];
-  return inner.split(",").map((item) => parseYamlScalar(item.trim()));
-}
-function parseFrontmatterBlock(raw) {
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r\n|\r|\n|$)([\s\S]*)$/);
-  if (!match)
-    return null;
-  const frontmatter = match[1].replace(/\r/g, "");
-  const content = match[2];
-  return {
-    frontmatter,
-    content,
-    bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1
-  };
-}
-function countLines(text) {
-  if (text.length === 0)
-    return 0;
-  return text.split(/\r?\n/).length - 1;
-}
-function parseYamlScalar(value) {
-  if (value === "")
-    return "";
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  const asNumber = Number(value);
-  if (!Number.isNaN(asNumber))
-    return asNumber;
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-
-// src/core/asset/markdown.ts
-function parseMarkdownToc(content) {
-  const lines = content.split(/\r?\n/);
-  const headings = [];
-  const parsed = parseFrontmatter(content);
-  const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
-  for (let i = start;i < lines.length; i++) {
-    const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
-    if (match) {
-      headings.push({
-        level: match[1].length,
-        text: match[2].replace(/\s+#+\s*$/, "").trim(),
-        line: i + 1
-      });
-    }
-  }
-  return { headings, totalLines: lines.length };
-}
-var init_markdown = () => {};
-
-// src/core/warn.ts
-var init_warn = () => {};
-
-// src/indexer/walk/file-context.ts
-var renderers;
-var init_file_context = __esm(() => {
-  init_common();
-  renderers = new Map;
-});
-
-// src/indexer/passes/metadata-contributors.ts
-function registerMetadataContributor(contributor) {
-  contributors.push(contributor);
-}
-var contributors;
-var init_metadata_contributors = __esm(() => {
-  contributors = [];
-});
-
-// src/indexer/passes/metadata.ts
-import fs2 from "fs";
-function extractDescriptionFromComments(filePath) {
-  let content;
-  try {
-    content = fs2.readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-  const lines = content.split(/\r?\n/).slice(0, 50);
-  const blockStart = lines.findIndex((l) => /^\s*\/\*\*/.test(l));
-  if (blockStart >= 0) {
-    const desc = [];
-    for (let i = blockStart;i < lines.length; i++) {
-      const line = lines[i];
-      if (i > blockStart && /\*\//.test(line))
-        break;
-      const cleaned = line.replace(/^\s*\/?\*\*?\s?/, "").replace(/\*\/\s*$/, "").trim();
-      if (cleaned)
-        desc.push(cleaned);
-    }
-    if (desc.length > 0)
-      return desc.join(" ");
-  }
-  let start = 0;
-  if (lines[0]?.startsWith("#!"))
-    start = 1;
-  const hashLines = [];
-  for (let i = start;i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (line.startsWith("#") && !line.startsWith("#!")) {
-      hashLines.push(line.replace(/^#+\s*/, "").trim());
-    } else if (line === "") {} else {
-      break;
-    }
-  }
-  if (hashLines.length > 0)
-    return hashLines.join(" ");
-  return null;
-}
-var KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, WIKI_INFRA_FILES;
-var init_metadata = __esm(() => {
-  init_asset_spec();
-  init_common();
-  init_warn();
-  init_file_context();
-  init_metadata_contributors();
-  KNOWN_QUALITY_VALUES = new Set(["generated", "curated", "enriched", "proposed"]);
-  warnedUnknownQualityValues = new Set;
-  WIKI_INFRA_FILES = new Set(["schema.md", "index.md", "log.md"]);
-});
-
-// src/core/asset/asset-ref.ts
-var init_asset_ref = __esm(() => {
-  init_common();
-  init_errors();
-});
-
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS((exports) => {
   var ALIAS = Symbol.for("yaml.alias");
@@ -769,17 +546,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path) {
-    const ctrl = callVisitor(key, node, visitor, path);
+  function visit_(key, node, visitor, path2) {
+    const ctrl = callVisitor(key, node, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visit_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visit_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path = Object.freeze(path.concat(node));
+        path2 = Object.freeze(path2.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path);
+          const ci = visit_(i, node.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -790,13 +567,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path = Object.freeze(path.concat(node));
-        const ck = visit_("key", node.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node));
+        const ck = visit_("key", node.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path);
+        const cv = visit_("value", node.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -817,17 +594,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path) {
-    const ctrl = await callVisitor(key, node, visitor, path);
+  async function visitAsync_(key, node, visitor, path2) {
+    const ctrl = await callVisitor(key, node, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visitAsync_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visitAsync_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path = Object.freeze(path.concat(node));
+        path2 = Object.freeze(path2.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path);
+          const ci = await visitAsync_(i, node.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -838,13 +615,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path = Object.freeze(path.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path);
+        const cv = await visitAsync_("value", node.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -871,23 +648,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path) {
+  function callVisitor(key, node, visitor, path2) {
     if (typeof visitor === "function")
-      return visitor(key, node, path);
+      return visitor(key, node, path2);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path);
+      return visitor.Map?.(key, node, path2);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path);
+      return visitor.Seq?.(key, node, path2);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path);
+      return visitor.Pair?.(key, node, path2);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path);
+      return visitor.Scalar?.(key, node, path2);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path);
+      return visitor.Alias?.(key, node, path2);
     return;
   }
-  function replaceNode(key, path, node) {
-    const parent = path[path.length - 1];
+  function replaceNode(key, path2, node) {
+    const parent = path2[path2.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1446,10 +1223,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path, value) {
+  function collectionFromPath(schema, path2, value) {
     let v = value;
-    for (let i = path.length - 1;i >= 0; --i) {
-      const k = path[i];
+    for (let i = path2.length - 1;i >= 0; --i) {
+      const k = path2[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1468,7 +1245,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
+  var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1489,11 +1266,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path, value) {
-      if (isEmptyPath(path))
+    addIn(path2, value) {
+      if (isEmptyPath(path2))
         this.add(value);
       else {
-        const [key, ...rest] = path;
+        const [key, ...rest] = path2;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1503,8 +1280,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path) {
-      const [key, ...rest] = path;
+    deleteIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1513,8 +1290,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path, keepScalar) {
-      const [key, ...rest] = path;
+    getIn(path2, keepScalar) {
+      const [key, ...rest] = path2;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1529,15 +1306,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path) {
-      const [key, ...rest] = path;
+    hasIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path, value) {
-      const [key, ...rest] = path;
+    setIn(path2, value) {
+      const [key, ...rest] = path2;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3930,9 +3707,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path, value) {
+    addIn(path2, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path, value);
+        this.contents.addIn(path2, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -3981,30 +3758,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path) {
-      if (Collection.isEmptyPath(path)) {
+    deleteIn(path2) {
+      if (Collection.isEmptyPath(path2)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path, keepScalar) {
-      if (Collection.isEmptyPath(path))
+    getIn(path2, keepScalar) {
+      if (Collection.isEmptyPath(path2))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path) {
-      if (Collection.isEmptyPath(path))
+    hasIn(path2) {
+      if (Collection.isEmptyPath(path2))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -4013,13 +3790,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path, value) {
-      if (Collection.isEmptyPath(path)) {
+    setIn(path2, value) {
+      if (Collection.isEmptyPath(path2)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path, value);
+        this.contents.setIn(path2, value);
       }
     }
     setSchema(version, options = {}) {
@@ -4128,15 +3905,15 @@ var require_errors = __commonJS((exports) => {
     let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
     if (ci >= 60 && lineStr.length > 80) {
       const trimStart = Math.min(ci - 39, lineStr.length - 79);
-      lineStr = "\u2026" + lineStr.substring(trimStart);
+      lineStr = "…" + lineStr.substring(trimStart);
       ci -= trimStart - 1;
     }
     if (lineStr.length > 80)
-      lineStr = lineStr.substring(0, 79) + "\u2026";
+      lineStr = lineStr.substring(0, 79) + "…";
     if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
       let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
       if (prev.length > 80)
-        prev = prev.substring(0, 79) + `\u2026
+        prev = prev.substring(0, 79) + `…
 `;
       lineStr = prev + lineStr;
     }
@@ -5191,8 +4968,8 @@ var require_resolve_flow_scalar = __commonJS((exports) => {
     r: "\r",
     t: "\t",
     v: "\v",
-    N: "\x85",
-    _: "\xA0",
+    N: "…",
+    _: " ",
     L: "\u2028",
     P: "\u2029",
     " ": " ",
@@ -5914,9 +5691,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path) => {
+  visit.itemAtPath = (cst, path2) => {
     let item = cst;
-    for (const [field, index] of path) {
+    for (const [field, index] of path2) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5925,23 +5702,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
-    const field = path[path.length - 1][0];
+  visit.parentCollection = (cst, path2) => {
+    const parent = visit.itemAtPath(cst, path2.slice(0, -1));
+    const field = path2[path2.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path, item, visitor) {
-    let ctrl = visitor(item, path);
+  function _visit(path2, item, visitor) {
+    let ctrl = visitor(item, path2);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path2.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5952,10 +5729,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path);
+          ctrl = ctrl(item, path2);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path2) : ctrl;
   }
   exports.visit = visit;
 });
@@ -7224,14 +7001,14 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs3 = this.flowScalar(this.type);
+            const fs4 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map.items.push({ start, key: fs3, sep: [] });
+              map.items.push({ start, key: fs4, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs3);
+              this.stack.push(fs4);
             } else {
-              Object.assign(it, { key: fs3, sep: [] });
+              Object.assign(it, { key: fs4, sep: [] });
               this.onKeyLine = true;
             }
             return;
@@ -7359,13 +7136,13 @@ var require_parser = __commonJS((exports) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs3 = this.flowScalar(this.type);
+            const fs4 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs3, sep: [] });
+              fc.items.push({ start: [], key: fs4, sep: [] });
             else if (it.sep)
-              this.stack.push(fs3);
+              this.stack.push(fs4);
             else
-              Object.assign(it, { key: fs3, sep: [] });
+              Object.assign(it, { key: fs4, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -7667,67 +7444,266 @@ var init_dist = __esm(() => {
   $visitAsync = visit.visitAsync;
 });
 
-// src/workflows/schema.ts
-var WORKFLOW_SCHEMA_VERSION = 1;
+// src/core/asset/asset-serialize.ts
+var init_asset_serialize = __esm(() => {
+  init_dist();
+});
 
-// src/workflows/validator.ts
-function runSemanticChecks(draft, frontmatterData, frontmatterEndLine, errors2) {
-  checkFrontmatterKeys(frontmatterData, frontmatterEndLine, errors2);
-  checkStepIdFormat(draft, errors2);
-  checkDuplicateStepIds(draft, errors2);
-}
-function checkFrontmatterKeys(data, fmEndLine, errors2) {
-  for (const key of Object.keys(data)) {
-    if (ALLOWED_FRONTMATTER_KEYS.has(key))
-      continue;
-    errors2.push({
-      line: fmEndLine,
-      message: `Workflow frontmatter "${key}" is not supported. Use only: description, tags, params, when_to_use.`
-    });
+// src/core/asset/frontmatter.ts
+function parseFrontmatter(raw) {
+  const parsedBlock = parseFrontmatterBlock(raw);
+  if (!parsedBlock) {
+    return { data: {}, content: raw, frontmatter: null, bodyStartLine: 1 };
+  }
+  let data = {};
+  if (parsedBlock.frontmatter.trim()) {
+    try {
+      const parsed = $parse(parsedBlock.frontmatter);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        data = normalizeYamlValues(parsed);
+      }
+    } catch {
+      data = parseFrontmatterLenient(parsedBlock.frontmatter);
+    }
   }
+  return {
+    data,
+    content: parsedBlock.content,
+    frontmatter: parsedBlock.frontmatter,
+    bodyStartLine: parsedBlock.bodyStartLine
+  };
 }
-function checkStepIdFormat(draft, errors2) {
-  for (const step of draft.steps) {
-    if (STEP_ID_REGEX.test(step.id))
-      continue;
-    errors2.push({
-      line: step.source.start,
-      message: `Step ID "${step.id}" is invalid. Use letters, numbers, ".", "_" or "-" (e.g. "deploy-job").`
-    });
+function normalizeYamlValues(value) {
+  if (value instanceof Date) {
+    const y = value.getUTCFullYear();
+    const m = String(value.getUTCMonth() + 1).padStart(2, "0");
+    const d = String(value.getUTCDate()).padStart(2, "0");
+    return `${y}-${m}-${d}`;
+  }
+  if (value === null)
+    return "";
+  if (Array.isArray(value))
+    return value.map(normalizeYamlValues);
+  if (typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, normalizeYamlValues(v)]));
   }
+  return value;
 }
-function checkDuplicateStepIds(draft, errors2) {
-  const firstSeenLine = new Map;
-  for (const step of draft.steps) {
-    const previous = firstSeenLine.get(step.id);
-    if (previous !== undefined) {
-      errors2.push({
-        line: step.source.start,
-        message: `Step ID "${step.id}" is already used on line ${previous}. Step IDs must be unique within a workflow.`
-      });
+function parseFrontmatterLenient(frontmatter) {
+  const data = {};
+  for (const line of frontmatter.split(/\r?\n/)) {
+    const m = line.match(/^([\w][\w-]*):\s*(.*)$/);
+    if (!m)
       continue;
+    const key = m[1];
+    const rawValue = (m[2] ?? "").trim();
+    try {
+      const singleEntry = $parse(`k: ${rawValue}`);
+      if (singleEntry !== null && typeof singleEntry === "object" && !Array.isArray(singleEntry)) {
+        const v = singleEntry.k;
+        data[key] = v === null || v === undefined ? "" : v;
+      } else {
+        data[key] = rawValue;
+      }
+    } catch {
+      data[key] = rawValue;
     }
-    firstSeenLine.set(step.id, step.source.start);
   }
+  return data;
 }
-var STEP_ID_REGEX, ALLOWED_FRONTMATTER_KEYS;
-var init_validator = __esm(() => {
-  STEP_ID_REGEX = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-  ALLOWED_FRONTMATTER_KEYS = new Set(["description", "tags", "params", "name", "updated", "when_to_use"]);
+function parseFrontmatterBlock(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r\n|\r|\n|$)([\s\S]*)$/);
+  if (match) {
+    const frontmatter = match[1].replace(/\r/g, "");
+    const content = match[2];
+    return {
+      frontmatter,
+      content,
+      bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1
+    };
+  }
+  const emptyMatch = raw.match(/^---\r?\n---(?:\r\n|\r|\n)([\s\S]*)$/);
+  if (emptyMatch) {
+    return { frontmatter: "", content: emptyMatch[1], bodyStartLine: 3 };
+  }
+  return null;
+}
+function countLines(text) {
+  if (text.length === 0)
+    return 0;
+  return text.split(/\r?\n/).length - 1;
+}
+var init_frontmatter = __esm(() => {
+  init_dist();
+  init_asset_serialize();
 });
 
-// src/workflows/parser.ts
-function parseWorkflow(markdown, source) {
-  const errors2 = [];
-  const path = source.path;
-  const lines = markdown.split(/\r?\n/);
-  const totalLines = lines.length;
-  const fmBlock = parseFrontmatterBlock(markdown);
-  const frontmatterEndLine = fmBlock ? Math.max(1, fmBlock.bodyStartLine - 1) : 1;
+// src/core/asset/markdown.ts
+function parseMarkdownToc(content) {
+  const lines = content.split(/\r?\n/);
+  const headings = [];
+  const parsed = parseFrontmatter(content);
+  const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
+  let inFence = false;
+  for (let i = start;i < lines.length; i++) {
+    if (/^\s*(`{3,}|~{3,})/.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence)
+      continue;
+    const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
+    if (match) {
+      headings.push({
+        level: match[1].length,
+        text: match[2].replace(/\s+#+\s*$/, "").trim(),
+        line: i + 1
+      });
+    }
+  }
+  return { headings, totalLines: lines.length };
+}
+var init_markdown = __esm(() => {
+  init_frontmatter();
+});
+
+// src/indexer/walk/file-context.ts
+var renderers;
+var init_file_context = __esm(() => {
+  init_frontmatter();
+  init_common();
+  renderers = new Map;
+});
+
+// src/indexer/passes/metadata-contributors.ts
+function registerMetadataContributor(contributor) {
+  contributors.push(contributor);
+}
+var contributors;
+var init_metadata_contributors = __esm(() => {
+  contributors = [];
+});
+
+// src/indexer/passes/metadata.ts
+import fs4 from "node:fs";
+function extractDescriptionFromComments(filePath) {
+  let content;
+  try {
+    content = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = content.split(/\r?\n/).slice(0, 50);
+  const blockStart = lines.findIndex((l) => /^\s*\/\*\*/.test(l));
+  if (blockStart >= 0) {
+    const desc = [];
+    for (let i = blockStart;i < lines.length; i++) {
+      const line = lines[i];
+      if (i > blockStart && /\*\//.test(line))
+        break;
+      const cleaned = line.replace(/^\s*\/?\*\*?\s?/, "").replace(/\*\/\s*$/, "").trim();
+      if (cleaned)
+        desc.push(cleaned);
+    }
+    if (desc.length > 0)
+      return desc.join(" ");
+  }
+  let start = 0;
+  if (lines[0]?.startsWith("#!"))
+    start = 1;
+  const hashLines = [];
+  for (let i = start;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("#") && !line.startsWith("#!")) {
+      hashLines.push(line.replace(/^#+\s*/, "").trim());
+    } else if (line === "") {} else {
+      break;
+    }
+  }
+  if (hashLines.length > 0)
+    return hashLines.join(" ");
+  return null;
+}
+var KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, WIKI_INFRA_FILES;
+var init_metadata = __esm(() => {
+  init_asset_spec();
+  init_frontmatter();
+  init_common();
+  init_warn();
+  init_file_context();
+  init_metadata_contributors();
+  KNOWN_QUALITY_VALUES = new Set(["generated", "curated", "enriched", "proposed"]);
+  warnedUnknownQualityValues = new Set;
+  WIKI_INFRA_FILES = new Set(["schema.md", "index.md", "log.md"]);
+});
+
+// src/core/asset/asset-ref.ts
+var init_asset_ref = __esm(() => {
+  init_common();
+  init_errors();
+});
+
+// src/workflows/schema.ts
+var WORKFLOW_SCHEMA_VERSION = 1;
+
+// src/workflows/validator.ts
+function runSemanticChecks(draft, frontmatterData, frontmatterEndLine, errors2) {
+  checkFrontmatterKeys(frontmatterData, frontmatterEndLine, errors2);
+  checkStepIdFormat(draft, errors2);
+  checkDuplicateStepIds(draft, errors2);
+}
+function checkFrontmatterKeys(data, fmEndLine, errors2) {
+  for (const key of Object.keys(data)) {
+    if (ALLOWED_FRONTMATTER_KEYS.has(key))
+      continue;
+    errors2.push({
+      line: fmEndLine,
+      message: `Workflow frontmatter "${key}" is not supported. Use only: description, tags, params, name, updated, when_to_use.`
+    });
+  }
+}
+function checkStepIdFormat(draft, errors2) {
+  for (const step of draft.steps) {
+    if (STEP_ID_REGEX.test(step.id))
+      continue;
+    errors2.push({
+      line: step.source.start,
+      message: `Step ID "${step.id}" is invalid. Use letters, numbers, ".", "_" or "-" (e.g. "deploy-job").`
+    });
+  }
+}
+function checkDuplicateStepIds(draft, errors2) {
+  const firstSeenLine = new Map;
+  for (const step of draft.steps) {
+    const previous = firstSeenLine.get(step.id);
+    if (previous !== undefined) {
+      errors2.push({
+        line: step.source.start,
+        message: `Step ID "${step.id}" is already used on line ${previous}. Step IDs must be unique within a workflow.`
+      });
+      continue;
+    }
+    firstSeenLine.set(step.id, step.source.start);
+  }
+}
+var STEP_ID_REGEX, ALLOWED_FRONTMATTER_KEYS;
+var init_validator = __esm(() => {
+  STEP_ID_REGEX = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+  ALLOWED_FRONTMATTER_KEYS = new Set(["description", "tags", "params", "name", "updated", "when_to_use"]);
+});
+
+// src/workflows/parser.ts
+function parseWorkflow(markdown, source) {
+  const errors2 = [];
+  const path2 = source.path;
+  const lines = markdown.split(/\r?\n/);
+  const totalLines = lines.length;
+  const fmBlock = parseFrontmatterBlock(markdown);
+  const frontmatterEndLine = fmBlock ? Math.max(1, fmBlock.bodyStartLine - 1) : 1;
   const fmData = readFrontmatter(fmBlock?.frontmatter, errors2);
   const description = readDescription(fmData);
   const tags = readTags(fmData, errors2, frontmatterEndLine);
-  const parameters = readParameters(fmData, errors2, frontmatterEndLine, path);
+  const parameters = readParameters(fmData, errors2, frontmatterEndLine, path2);
   const toc = parseMarkdownToc(markdown);
   const { title, titleLine } = extractTitle(toc.headings, errors2);
   for (const h of toc.headings) {
@@ -7744,7 +7720,7 @@ function parseWorkflow(markdown, source) {
       });
     }
   }
-  const steps = extractSteps(toc.headings, lines, totalLines, path, errors2);
+  const steps = extractSteps(toc.headings, lines, totalLines, path2, errors2);
   if (steps.length === 0 && titleLine > 0) {
     errors2.push({
       line: titleLine,
@@ -7758,7 +7734,7 @@ function parseWorkflow(markdown, source) {
     ...tags ? { tags } : {},
     ...parameters ? { parameters } : {},
     steps,
-    source: { path, lineCount: totalLines }
+    source: { path: path2, lineCount: totalLines }
   };
   runSemanticChecks(draft, fmData, frontmatterEndLine, errors2);
   if (errors2.length > 0) {
@@ -7793,7 +7769,7 @@ function extractTitle(headings, errors2) {
   }
   return { title, titleLine: first.line };
 }
-function extractSteps(headings, lines, totalLines, path, errors2) {
+function extractSteps(headings, lines, totalLines, path2, errors2) {
   const steps = [];
   let sequenceIndex = 0;
   for (let i = 0;i < headings.length; i++) {
@@ -7809,11 +7785,11 @@ function extractSteps(headings, lines, totalLines, path, errors2) {
       continue;
     }
     const stepEnd = Math.min(findNextSiblingOrParentLine(headings, i, 2) - 1, totalLines);
-    const stepSource = { path, start: h.line, end: stepEnd };
+    const stepSource = { path: path2, 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, errors2);
-    const { instructions, completionCriteria } = collectStepBody(subsections, lines, path, stepTitle, errors2);
+    const { instructions, completionCriteria } = collectStepBody(subsections, lines, path2, stepTitle, errors2);
     if (!stepId)
       continue;
     if (!instructions) {
@@ -7853,7 +7829,7 @@ function collectSubsections(headings, stepIndex, stepEnd) {
   }
   return subs;
 }
-function collectStepBody(subsections, lines, path, stepTitle, errors2) {
+function collectStepBody(subsections, lines, path2, stepTitle, errors2) {
   let instructions;
   let completionCriteria;
   for (const sub of subsections) {
@@ -7875,7 +7851,7 @@ function collectStepBody(subsections, lines, path, stepTitle, errors2) {
       }
       instructions = {
         text,
-        source: { path, start: sub.bodyStart, end: sub.bodyEnd }
+        source: { path: path2, start: sub.bodyStart, end: sub.bodyEnd }
       };
       continue;
     }
@@ -7887,7 +7863,7 @@ function collectStepBody(subsections, lines, path, stepTitle, errors2) {
         });
         continue;
       }
-      const items = collectBullets(lines, sub.bodyStart, sub.bodyEnd, path);
+      const items = collectBullets(lines, sub.bodyStart, sub.bodyEnd, path2);
       if (items.length === 0) {
         errors2.push({
           line: sub.headingLine,
@@ -7900,7 +7876,7 @@ function collectStepBody(subsections, lines, path, stepTitle, errors2) {
     }
     errors2.push({
       line: sub.headingLine,
-      message: `Step "${stepTitle}" has an unknown "### ${sub.name}" section. Only "### Instructions" and "### Completion Criteria" are supported.`
+      message: `Step "${stepTitle}" has an unknown "### ${sub.name}" section. Supported sections: ` + `"### Instructions", "### Completion Criteria". For orchestrated workflows (runners, ` + `fan-out, routing), author a YAML workflow program instead — see \`akm workflow template --yaml\`.`
     });
   }
   return {
@@ -7936,7 +7912,7 @@ function scanStepId(lines, startLineInclusive, endLineInclusive, stepTitle, erro
   }
   return foundId;
 }
-function collectBullets(lines, startLineInclusive, endLineInclusive, path) {
+function collectBullets(lines, startLineInclusive, endLineInclusive, path2) {
   const items = [];
   for (let lineNum = startLineInclusive;lineNum <= endLineInclusive; lineNum++) {
     const trimmed = (lines[lineNum - 1] ?? "").trim();
@@ -7947,7 +7923,7 @@ function collectBullets(lines, startLineInclusive, endLineInclusive, path) {
       continue;
     items.push({
       text: match[1].trim(),
-      source: { path, start: lineNum, end: lineNum }
+      source: { path: path2, start: lineNum, end: lineNum }
     });
   }
   return items;
@@ -8016,7 +7992,7 @@ function readTags(data, errors2, fmEndLine) {
   }
   return v.map((tag) => tag.trim());
 }
-function readParameters(data, errors2, fmEndLine, path) {
+function readParameters(data, errors2, fmEndLine, path2) {
   const v = data.params;
   if (v === undefined || v === null)
     return;
@@ -8050,23 +8026,719 @@ function readParameters(data, errors2, fmEndLine, path) {
     out.push({
       name: trimmedName,
       description: desc.trim(),
-      source: { path, start: 1, end: fmEndLine }
+      source: { path: path2, start: 1, end: fmEndLine }
     });
   }
   return out.length > 0 ? out : undefined;
 }
-function sortErrors(errors2) {
-  return [...errors2].sort((a, b) => a.line - b.line);
+function sortErrors(errors2) {
+  return [...errors2].sort((a, b) => a.line - b.line);
+}
+var WORKFLOW_TITLE_PREFIX = "Workflow:", STEP_PREFIX = "Step:", STEP_ID_LINE, BULLET_LINE, SUBSECTION_INSTRUCTIONS = "Instructions", SUBSECTION_COMPLETION_CRITERIA = "Completion Criteria";
+var init_parser = __esm(() => {
+  init_dist();
+  init_frontmatter();
+  init_markdown();
+  init_validator();
+  STEP_ID_LINE = /^Step ID:\s+(.+?)\s*$/;
+  BULLET_LINE = /^[-*]\s+(.+)$/;
+});
+
+// src/workflows/program/schema.ts
+var PROGRAM_RUNNER_KINDS, PROGRAM_REDUCERS, PROGRAM_ON_ERROR, PROGRAM_ISOLATION_KINDS, RETRY_REASON_SET, PROGRAM_RETRY_REASONS, PROGRAM_STEP_ID_PATTERN, PROGRAM_PARAM_NAME_PATTERN;
+var init_schema = __esm(() => {
+  PROGRAM_RUNNER_KINDS = ["llm", "agent", "sdk", "inherit"];
+  PROGRAM_REDUCERS = ["collect", "vote"];
+  PROGRAM_ON_ERROR = ["fail", "continue"];
+  PROGRAM_ISOLATION_KINDS = ["none", "worktree"];
+  RETRY_REASON_SET = {
+    timeout: true,
+    spawn_failed: true,
+    non_zero_exit: true,
+    parse_error: true,
+    cooldown: true,
+    llm_rate_limit: true,
+    llm_content_filter: true,
+    llm_invalid_json: true,
+    content_policy_reject: true,
+    unsupported_type: true,
+    no_change: true,
+    aborted: true
+  };
+  PROGRAM_RETRY_REASONS = Object.keys(RETRY_REASON_SET);
+  PROGRAM_STEP_ID_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+  PROGRAM_PARAM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+});
+
+// src/workflows/program/parser.ts
+import { createRequire as createRequire4 } from "node:module";
+function parseWorkflowProgram(yamlText, source) {
+  const errors2 = [];
+  const lineCounter2 = new $LineCounter;
+  let doc;
+  try {
+    doc = $parseDocument(yamlText, { lineCounter: lineCounter2 });
+  } catch (cause) {
+    return { ok: false, errors: [{ line: 1, message: `YAML parse failed: ${describeError(cause)}` }] };
+  }
+  for (const problem of doc.errors) {
+    const offset = Array.isArray(problem.pos) ? problem.pos[0] : 0;
+    errors2.push({ line: Math.max(1, lineCounter2.linePos(offset).line), message: yamlErrorMessage(problem.message) });
+  }
+  if (errors2.length > 0)
+    return { ok: false, errors: errors2 };
+  let root;
+  try {
+    root = doc.toJS();
+  } catch (cause) {
+    return { ok: false, errors: [{ line: 1, message: `YAML expansion failed: ${describeError(cause)}` }] };
+  }
+  const lineAt = (path2) => {
+    for (let depth = path2.length;depth >= 0; depth--) {
+      const node = depth === 0 ? doc.contents : doc.getIn(path2.slice(0, depth), true);
+      const range = node?.range;
+      if (range)
+        return Math.max(1, lineCounter2.linePos(range[0]).line);
+    }
+    return 1;
+  };
+  const ctx = {
+    filePath: source.path,
+    errors: errors2,
+    lineAt,
+    lineAtOffset: (offset) => Math.max(1, lineCounter2.linePos(offset).line),
+    nodeAt: (path2) => path2.length === 0 ? doc.contents : doc.getIn(path2, true),
+    refAt: (path2) => {
+      for (let depth = path2.length;depth >= 0; depth--) {
+        const node = depth === 0 ? doc.contents : doc.getIn(path2.slice(0, depth), true);
+        const range = node?.range;
+        if (range) {
+          const start = Math.max(1, lineCounter2.linePos(range[0]).line);
+          const end = Math.max(start, lineCounter2.linePos(Math.max(range[0], range[1] - 1)).line);
+          return { path: source.path, start, end };
+        }
+      }
+      return { path: source.path, start: 1, end: 1 };
+    },
+    err: (path2, message) => errors2.push({ line: lineAt(path2), message }),
+    errAtLine: (line, message) => errors2.push({ line, message }),
+    checkTemplates: (text, path2, label) => checkTemplates(ctx, text, path2, label)
+  };
+  if (!isPlainRecord(root)) {
+    return {
+      ok: false,
+      errors: [
+        { line: 1, message: `A workflow program must be a YAML mapping with "version: 1", "name", and "steps".` }
+      ]
+    };
+  }
+  checkUnknownKeys(ctx, root, [], TOP_LEVEL_KEYS, "top-level");
+  if (root.version !== 1) {
+    const got = root.version === undefined ? "it is missing" : `got ${JSON.stringify(root.version)}`;
+    ctx.err(["version"], `"version: 1" is required at the top level (${got}). Only the number 1 is a valid version.`);
+  }
+  let name = "";
+  if (typeof root.name === "string" && root.name.trim() !== "") {
+    name = root.name.trim();
+    ctx.checkTemplates(root.name, ["name"], `"name"`);
+  } else {
+    ctx.err(["name"], `"name" is required and must be a non-empty string.`);
+  }
+  let description;
+  if (root.description !== undefined) {
+    if (typeof root.description === "string") {
+      description = root.description;
+      ctx.checkTemplates(root.description, ["description"], `"description"`);
+    } else {
+      ctx.err(["description"], `"description" must be a string.`);
+    }
+  }
+  const params = parseParams(ctx, root.params);
+  const defaults = parseDefaults(ctx, root.defaults);
+  const budget = parseBudget(ctx, root.budget);
+  const steps = parseSteps(ctx, root.steps);
+  if (errors2.length > 0)
+    return { ok: false, errors: errors2 };
+  const program = {
+    version: 1,
+    name,
+    ...description !== undefined ? { description } : {},
+    ...params !== undefined ? { params } : {},
+    ...defaults !== undefined ? { defaults } : {},
+    ...budget !== undefined ? { budget } : {},
+    steps,
+    source: { path: source.path }
+  };
+  return { ok: true, program };
+}
+function parseParams(ctx, raw) {
+  if (raw === undefined)
+    return;
+  if (!isPlainRecord(raw)) {
+    ctx.err(["params"], `"params" must be a mapping of param name to a JSON Schema object (e.g. changed_files: { type: array }).`);
+    return;
+  }
+  const params = {};
+  for (const [paramName, value] of Object.entries(raw)) {
+    if (!PROGRAM_PARAM_NAME_PATTERN.test(paramName)) {
+      ctx.err(["params", paramName], `Param name "${paramName}" is invalid. Use letters, digits, and underscores, starting with a letter or underscore, so "\${{ params.${paramName} }}" can address it.`);
+      continue;
+    }
+    if (!isPlainRecord(value)) {
+      ctx.err(["params", paramName], `Param "${paramName}" must be a JSON Schema object (e.g. { type: string }).`);
+      continue;
+    }
+    params[paramName] = value;
+  }
+  return Object.keys(params).length > 0 ? params : undefined;
+}
+function parseDefaults(ctx, raw) {
+  if (raw === undefined)
+    return;
+  const path2 = ["defaults"];
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `"defaults" must be a mapping with any of: ${DEFAULTS_KEYS.join(", ")}.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, DEFAULTS_KEYS, `"defaults"`);
+  const defaults = {};
+  const runner = parseEnumField(ctx, raw.runner, [...path2, "runner"], `"defaults.runner"`, PROGRAM_RUNNER_KINDS);
+  if (runner !== undefined)
+    defaults.runner = runner;
+  if (raw.model !== undefined) {
+    if (typeof raw.model === "string" && raw.model.trim() !== "")
+      defaults.model = raw.model.trim();
+    else
+      ctx.err([...path2, "model"], `"defaults.model" must be a non-empty string (a model alias or exact id).`);
+  }
+  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path2, "timeout"], `"defaults.timeout"`);
+  if (timeoutMs !== undefined)
+    defaults.timeoutMs = timeoutMs;
+  const onError = parseEnumField(ctx, raw.on_error, [...path2, "on_error"], `"defaults.on_error"`, PROGRAM_ON_ERROR);
+  if (onError !== undefined)
+    defaults.onError = onError;
+  return Object.keys(defaults).length > 0 ? defaults : undefined;
+}
+function parseBudget(ctx, raw) {
+  if (raw === undefined)
+    return;
+  const path2 = ["budget"];
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `"budget" must be a mapping with any of: ${BUDGET_KEYS.join(", ")}.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, 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([...path2, "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) {
+      budget.maxUnits = raw.max_units;
+    } else {
+      ctx.err([...path2, "max_units"], `"budget.max_units" must be an integer >= 1.`);
+    }
+  }
+  return Object.keys(budget).length > 0 ? budget : undefined;
+}
+function parseSteps(ctx, raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    ctx.err(["steps"], `"steps" is required and must be a list with at least one step.`);
+    return [];
+  }
+  const idIndex = new Map;
+  raw.forEach((rawStep, index) => {
+    if (isPlainRecord(rawStep) && typeof rawStep.id === "string" && !idIndex.has(rawStep.id)) {
+      idIndex.set(rawStep.id, index);
+    }
+  });
+  const steps = [];
+  const seenIds = new Map;
+  const routeChecks = [];
+  raw.forEach((rawStep, index) => {
+    const path2 = ["steps", index];
+    if (!isPlainRecord(rawStep)) {
+      ctx.err(path2, `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, path2, STEP_KEYS, label);
+    let id = "";
+    if (typeof rawStep.id !== "string" || rawStep.id === "") {
+      ctx.err([...path2, "id"], `${label} requires a non-empty string "id".`);
+    } else if (!PROGRAM_STEP_ID_PATTERN.test(rawStep.id)) {
+      ctx.err([...path2, "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([...path2, "id"], `Duplicate step id "${id}" (first used by step ${firstIndex + 1}). Step ids must be unique.`);
+      } else {
+        seenIds.set(id, index);
+      }
+    }
+    let title;
+    if (rawStep.title !== undefined) {
+      if (typeof rawStep.title === "string" && rawStep.title.trim() !== "") {
+        title = rawStep.title.trim();
+        ctx.checkTemplates(rawStep.title, [...path2, "title"], `${label} "title"`);
+      } else {
+        ctx.err([...path2, "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(path2, `${label} must declare exactly one of "unit", "map", or "route" (${found}).`);
+    }
+    const unit = rawStep.unit !== undefined ? parseUnit(ctx, rawStep.unit, [...path2, "unit"], label) : undefined;
+    const map = rawStep.map !== undefined ? parseMap(ctx, rawStep.map, [...path2, "map"], label) : undefined;
+    const route = rawStep.route !== undefined ? parseRoute(ctx, rawStep.route, [...path2, "route"], label, index, routeChecks) : undefined;
+    const output = parseSchemaObject(ctx, rawStep.output, [...path2, "output"], `${label} "output"`);
+    const gate = rawStep.gate !== undefined ? parseGate(ctx, rawStep.gate, [...path2, "gate"], label) : undefined;
+    const step = { id, source: ctx.refAt(path2) };
+    if (title !== undefined)
+      step.title = title;
+    if (declaredKinds.length === 1) {
+      if (unit)
+        step.unit = unit;
+      if (map)
+        step.map = map;
+      if (route)
+        step.route = route;
+    }
+    if (output !== undefined)
+      step.output = output;
+    if (gate !== undefined)
+      step.gate = gate;
+    steps.push(step);
+  });
+  for (const check of routeChecks) {
+    const targets = [...check.branches.map((b) => ({ stepId: b.stepId, line: b.line }))];
+    if (check.defaultTarget)
+      targets.push(check.defaultTarget);
+    for (const target of targets) {
+      const targetIndex = idIndex.get(target.stepId);
+      if (targetIndex === undefined) {
+        ctx.errAtLine(target.line, `${check.stepLabel} routes to unknown step "${target.stepId}". Route targets must name a step id in this workflow.`);
+      } else if (targetIndex === check.stepIndex) {
+        ctx.errAtLine(target.line, `${check.stepLabel} must not route to itself.`);
+      } else if (targetIndex < check.stepIndex) {
+        ctx.errAtLine(target.line, `${check.stepLabel} routes backward to "${target.stepId}" (step ${targetIndex + 1}). Route targets must come after the routing step.`);
+      }
+    }
+  }
+  return steps;
+}
+function parseUnit(ctx, raw, path2, stepLabel) {
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${stepLabel} "unit" must be a mapping with an "instructions" key.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, UNIT_KEYS, `${stepLabel} "unit"`);
+  const unit = { instructions: "", source: ctx.refAt(path2) };
+  if (typeof raw.instructions === "string" && raw.instructions.trim() !== "") {
+    unit.instructions = raw.instructions;
+    ctx.checkTemplates(raw.instructions, [...path2, "instructions"], `${stepLabel} "instructions"`);
+  } else {
+    ctx.err([...path2, "instructions"], `${stepLabel} "unit" requires non-empty string "instructions".`);
+  }
+  const runner = parseEnumField(ctx, raw.runner, [...path2, "runner"], `${stepLabel} "runner"`, PROGRAM_RUNNER_KINDS);
+  if (runner !== undefined)
+    unit.runner = runner;
+  if (raw.profile !== undefined) {
+    if (typeof raw.profile === "string" && raw.profile.trim() !== "")
+      unit.profile = raw.profile.trim();
+    else
+      ctx.err([...path2, "profile"], `${stepLabel} "profile" must be a non-empty string.`);
+  }
+  if (raw.model !== undefined) {
+    if (typeof raw.model === "string" && raw.model.trim() !== "")
+      unit.model = raw.model.trim();
+    else
+      ctx.err([...path2, "model"], `${stepLabel} "model" must be a non-empty string (a model alias or exact id).`);
+  }
+  const timeoutMs = parseTimeoutField(ctx, raw.timeout, [...path2, "timeout"], `${stepLabel} "timeout"`);
+  if (timeoutMs !== undefined)
+    unit.timeoutMs = timeoutMs;
+  const retry = parseRetry(ctx, raw.retry, [...path2, "retry"], stepLabel);
+  if (retry !== undefined)
+    unit.retry = retry;
+  const onError = parseEnumField(ctx, raw.on_error, [...path2, "on_error"], `${stepLabel} "on_error"`, PROGRAM_ON_ERROR);
+  if (onError !== undefined)
+    unit.onError = onError;
+  const output = parseSchemaObject(ctx, raw.output, [...path2, "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([...path2, "env"], `${stepLabel} "env" must be a list of non-empty env asset refs.`);
+    }
+  }
+  const isolation = parseEnumField(ctx, raw.isolation, [...path2, "isolation"], `${stepLabel} "isolation"`, PROGRAM_ISOLATION_KINDS);
+  if (isolation !== undefined)
+    unit.isolation = isolation;
+  return unit;
+}
+function parseMap(ctx, raw, path2, stepLabel) {
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${stepLabel} "map" must be a mapping with "over" and "unit" keys.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, MAP_KEYS, `${stepLabel} "map"`);
+  let over = "";
+  if (typeof raw.over === "string" && raw.over.trim() !== "") {
+    over = raw.over.trim();
+    ctx.checkTemplates(raw.over, [...path2, "over"], `${stepLabel} "over"`);
+  } else {
+    ctx.err([...path2, "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([...path2, "concurrency"], `${stepLabel} "concurrency" must be a positive integer.`);
+    }
+  }
+  const reducer = parseEnumField(ctx, raw.reducer, [...path2, "reducer"], `${stepLabel} "reducer"`, PROGRAM_REDUCERS);
+  const unit = raw.unit !== undefined ? parseUnit(ctx, raw.unit, [...path2, "unit"], stepLabel) : undefined;
+  if (raw.unit === undefined) {
+    ctx.err(path2, `${stepLabel} "map" requires a nested "unit" to fan out.`);
+  }
+  if (unit === undefined)
+    return;
+  const map = { over, unit };
+  if (concurrency !== undefined)
+    map.concurrency = concurrency;
+  if (reducer !== undefined)
+    map.reducer = reducer;
+  return map;
+}
+function parseRoute(ctx, raw, path2, stepLabel, stepIndex, routeChecks) {
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${stepLabel} "route" must be a mapping with "input" and "when" keys.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, ROUTE_KEYS, `${stepLabel} "route"`);
+  let input = "";
+  if (typeof raw.input === "string" && raw.input.trim() !== "") {
+    input = raw.input.trim();
+    ctx.checkTemplates(raw.input, [...path2, "input"], `${stepLabel} "route.input"`);
+  } else {
+    ctx.err([...path2, "input"], `${stepLabel} "route" requires "input": a \${{ … }} expression naming the value to route on.`);
+  }
+  const check = { stepIndex, stepLabel, branches: [] };
+  const whenPath = [...path2, "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 }).`);
+  } else if ($isMap(whenNode)) {
+    const seenMatches = new Map;
+    for (const pair of whenNode.items) {
+      const keyLine = rangedLine(ctx, pair.key, whenPath);
+      if (!$isScalar(pair.key)) {
+        ctx.errAtLine(keyLine, `${stepLabel} "when" match keys must be scalar values.`);
+        continue;
+      }
+      const match = String(pair.key.value);
+      const valueNode = pair.value;
+      const valueLine = rangedLine(ctx, valueNode, whenPath);
+      const target = $isScalar(valueNode) && typeof valueNode.value === "string" ? valueNode.value.trim() : "";
+      if (target === "") {
+        ctx.errAtLine(valueLine, `${stepLabel} "when: ${match}" must map to a step id string.`);
+        continue;
+      }
+      const firstLine = seenMatches.get(match);
+      if (firstLine !== undefined) {
+        ctx.errAtLine(keyLine, `${stepLabel} has a duplicate "when" match "${match}" (first declared on line ${firstLine}). Matches must be unique.`);
+        continue;
+      }
+      seenMatches.set(match, keyLine);
+      check.branches.push({ match, stepId: target, line: valueLine });
+    }
+    if (check.branches.length === 0 && whenNode.items.length === 0) {
+      ctx.err(whenPath, `${stepLabel} "when" must contain at least one match → step-id entry.`);
+    }
+  } else {
+    for (const [match, target] of Object.entries(raw.when)) {
+      if (typeof target === "string" && target.trim() !== "") {
+        check.branches.push({ match, stepId: target.trim(), line: ctx.lineAt(whenPath) });
+      } else {
+        ctx.err(whenPath, `${stepLabel} "when: ${match}" must map to a step id string.`);
+      }
+    }
+    if (Object.keys(raw.when).length === 0) {
+      ctx.err(whenPath, `${stepLabel} "when" must contain at least one match → step-id entry.`);
+    }
+  }
+  let defaultStepId;
+  if (raw.default !== undefined) {
+    if (typeof raw.default === "string" && raw.default.trim() !== "") {
+      defaultStepId = raw.default.trim();
+      check.defaultTarget = { stepId: defaultStepId, line: ctx.lineAt([...path2, "default"]) };
+    } else {
+      ctx.err([...path2, "default"], `${stepLabel} "route.default" must be a step id string.`);
+    }
+  }
+  routeChecks.push(check);
+  const route = { input, branches: check.branches.map(({ match, stepId }) => ({ match, stepId })) };
+  if (defaultStepId !== undefined)
+    route.defaultStepId = defaultStepId;
+  return route;
+}
+function parseGate(ctx, raw, path2, stepLabel) {
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${stepLabel} "gate" must be a mapping with a "criteria" list.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, 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, [...path2, "criteria", i], `${stepLabel} gate criterion ${i + 1}`);
+    }
+  } else {
+    ctx.err([...path2, "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([...path2, "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([...path2, "required"], `${stepLabel} "gate.required" must be a boolean (true or false).`);
+    }
+  }
+  return gate;
+}
+function parseRetry(ctx, raw, path2, stepLabel) {
+  if (raw === undefined)
+    return;
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${stepLabel} "retry" must be a mapping: { max: <n>, on: [<failure_reason>, …] }.`);
+    return;
+  }
+  checkUnknownKeys(ctx, raw, path2, RETRY_KEYS, `${stepLabel} "retry"`);
+  let ok = true;
+  if (!(typeof raw.max === "number" && Number.isInteger(raw.max) && raw.max >= 0)) {
+    ctx.err([...path2, "max"], `${stepLabel} "retry.max" is required and must be a non-negative integer.`);
+    ok = false;
+  }
+  const on = [];
+  if (Array.isArray(raw.on) && raw.on.length > 0) {
+    raw.on.forEach((reason, i) => {
+      if (typeof reason === "string" && PROGRAM_RETRY_REASONS.includes(reason)) {
+        on.push(reason);
+      } else {
+        ctx.err([...path2, "on", i], `${stepLabel} "retry.on" has unknown failure reason ${JSON.stringify(reason)}. Valid reasons: ${PROGRAM_RETRY_REASONS.join(", ")}.`);
+        ok = false;
+      }
+    });
+  } else {
+    ctx.err([...path2, "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, path2, label) {
+  if (raw === undefined)
+    return;
+  if (typeof raw === "number") {
+    if (Number.isInteger(raw) && raw > 0)
+      return raw;
+    ctx.err(path2, `${label} has a non-positive timeout ${JSON.stringify(raw)}. ${TIMEOUT_HINT}.`);
+    return;
+  }
+  if (typeof raw !== "string") {
+    ctx.err(path2, `${label} must be a duration string. ${TIMEOUT_HINT}.`);
+    return;
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "none")
+    return null;
+  const match = value.match(TIMEOUT_VALUE);
+  if (!match) {
+    ctx.err(path2, `${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(path2, `${label} has a non-positive timeout "${raw}". Use a positive duration or "none".`);
+    return;
+  }
+  return timeoutMs;
+}
+function parseEnumField(ctx, raw, path2, label, allowed) {
+  if (raw === undefined)
+    return;
+  if (typeof raw === "string" && allowed.includes(raw))
+    return raw;
+  ctx.err(path2, `${label} must be one of: ${allowed.join(" | ")} (got ${JSON.stringify(raw)}).`);
+  return;
+}
+function parseSchemaObject(ctx, raw, path2, label) {
+  if (raw === undefined)
+    return;
+  if (!isPlainRecord(raw)) {
+    ctx.err(path2, `${label} must be a JSON Schema object (e.g. { type: object, properties: { … } }).`);
+    return;
+  }
+  return raw;
+}
+function checkUnknownKeys(ctx, obj, path2, allowed, label) {
+  for (const key of Object.keys(obj)) {
+    if (!allowed.includes(key)) {
+      ctx.err([...path2, key], `Unknown ${label} key "${key}". Allowed keys: ${allowed.join(", ")}.`);
+    }
+  }
+}
+function rangedLine(ctx, node, fallbackPath) {
+  const range = node?.range;
+  return range ? ctx.lineAtOffset(range[0]) : ctx.lineAt(fallbackPath);
+}
+function checkTemplates(ctx, text, path2, label) {
+  let idx = 0;
+  while (true) {
+    const open = text.indexOf("${{", idx);
+    if (open === -1)
+      break;
+    const close = text.indexOf("}}", open + 3);
+    const nextOpen = text.indexOf("${{", open + 3);
+    if (close === -1 || nextOpen !== -1 && nextOpen < close) {
+      ctx.err(path2, `${label} contains an unterminated "\${{" expression. Close it with "}}".`);
+      return;
+    }
+    idx = close + 2;
+  }
+  const checker = loadExpressionChecker();
+  if (checker) {
+    const message = checker(text);
+    if (message !== null)
+      ctx.err(path2, `${label}: ${message}`);
+  }
+}
+function loadExpressionChecker() {
+  if (cachedExpressionChecker !== undefined)
+    return cachedExpressionChecker;
+  cachedExpressionChecker = null;
+  let candidate;
+  try {
+    const requireModule = createRequire4(import.meta.url);
+    const specifier = "./expressions";
+    const mod = requireModule(specifier);
+    candidate = [mod.parseTemplate, mod.compileTemplate, mod.parseTemplateString, mod.tokenizeTemplate].find((fn) => typeof fn === "function");
+  } catch {
+    return cachedExpressionChecker;
+  }
+  if (!candidate)
+    return cachedExpressionChecker;
+  const parseTemplate = candidate;
+  cachedExpressionChecker = (text) => {
+    try {
+      const result = parseTemplate(text);
+      if (isPlainRecord(result) && result.ok === false) {
+        const errs = result.errors;
+        if (Array.isArray(errs) && errs.length > 0) {
+          const first = errs[0];
+          if (typeof first === "string")
+            return first;
+          if (isPlainRecord(first) && typeof first.message === "string")
+            return first.message;
+        }
+        if (typeof result.error === "string")
+          return result.error;
+        return `malformed \${{ … }} expression`;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  };
+  return cachedExpressionChecker;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var WORKFLOW_TITLE_PREFIX = "Workflow:", STEP_PREFIX = "Step:", STEP_ID_LINE, BULLET_LINE, SUBSECTION_INSTRUCTIONS = "Instructions", SUBSECTION_COMPLETION_CRITERIA = "Completion Criteria";
-var init_parser = __esm(() => {
+function describeError(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+function yamlErrorMessage(message) {
+  const first = message.split(`
+`, 1)[0] ?? message;
+  return first.replace(/ at line \d+, column \d+:?\s*$/, "").trim();
+}
+var TOP_LEVEL_KEYS, DEFAULTS_KEYS, BUDGET_KEYS, STEP_KEYS, UNIT_KEYS, MAP_KEYS, ROUTE_KEYS, RETRY_KEYS, GATE_KEYS, STEP_KINDS, TIMEOUT_VALUE, TIMEOUT_HINT = `Use "<n>ms", "<n>s", "<n>m" (e.g. "10m"), or "none"`, cachedExpressionChecker;
+var init_parser2 = __esm(() => {
   init_dist();
-  init_markdown();
-  init_validator();
-  STEP_ID_LINE = /^Step ID:\s+(.+?)\s*$/;
-  BULLET_LINE = /^[-*]\s+(.+)$/;
+  init_schema();
+  TOP_LEVEL_KEYS = ["version", "name", "description", "params", "defaults", "budget", "steps"];
+  DEFAULTS_KEYS = ["runner", "model", "timeout", "on_error"];
+  BUDGET_KEYS = ["max_tokens", "max_units"];
+  STEP_KEYS = ["id", "title", "unit", "map", "route", "output", "gate"];
+  UNIT_KEYS = [
+    "runner",
+    "profile",
+    "model",
+    "timeout",
+    "retry",
+    "on_error",
+    "instructions",
+    "output",
+    "env",
+    "isolation"
+  ];
+  MAP_KEYS = ["over", "concurrency", "reducer", "unit"];
+  ROUTE_KEYS = ["input", "when", "default"];
+  RETRY_KEYS = ["max", "on"];
+  GATE_KEYS = ["criteria", "max_loops", "required"];
+  STEP_KINDS = ["unit", "map", "route"];
+  TIMEOUT_VALUE = /^(\d+)(ms|s|m)?$/;
 });
 
+// src/workflows/program/project.ts
+function programStepInstructions(step) {
+  if (step.unit)
+    return step.unit.instructions;
+  if (step.map)
+    return step.map.unit.instructions;
+  if (step.route) {
+    const branches = step.route.branches.map((b) => `"${b.match}" -> ${b.stepId}`);
+    if (step.route.defaultStepId !== undefined)
+      branches.push(`default -> ${step.route.defaultStepId}`);
+    return `Route on ${step.route.input}: ${branches.join(", ")}.`;
+  }
+  return "";
+}
+function projectProgramParameters(program) {
+  if (!program.params)
+    return;
+  const parameters = Object.entries(program.params).map(([name, schema]) => {
+    const description = schema.description;
+    return {
+      name,
+      ...typeof description === "string" && description !== "" ? { description } : {}
+    };
+  });
+  return parameters.length > 0 ? parameters : undefined;
+}
+var WORKFLOW_PROGRAM_RENDERER_NAME = "workflow-program-yaml";
+var init_project = () => {};
+
 // src/workflows/runtime/document-cache.ts
 function cacheWorkflowDocument(entry, doc) {
   cache.set(entry, doc);
@@ -8087,7 +8759,16 @@ function loadDocument(ctx) {
   const result = parseWorkflow(ctx.content(), { path: ctx.relPath });
   if (result.ok)
     return result.document;
-  const summary = result.errors.map((e) => `${ctx.relPath}:${e.line} \u2014 ${e.message}`).join(`
+  const summary = result.errors.map((e) => `${ctx.relPath}:${e.line} — ${e.message}`).join(`
+`);
+  throw new UsageError(`Workflow has errors:
+${summary}`);
+}
+function loadProgram(ctx) {
+  const result = parseWorkflowProgram(ctx.content(), { path: ctx.relPath });
+  if (result.ok)
+    return result.program;
+  const summary = result.errors.map((e) => `${ctx.relPath}:${e.line} — ${e.message}`).join(`
 `);
   throw new UsageError(`Workflow has errors:
 ${summary}`);
@@ -8097,6 +8778,8 @@ var init_renderer = __esm(() => {
   init_errors();
   init_metadata_contributors();
   init_parser();
+  init_parser2();
+  init_project();
   init_document_cache();
   registerMetadataContributor({
     name: "workflow-document-metadata",
@@ -8123,6 +8806,32 @@ var init_renderer = __esm(() => {
       cacheWorkflowDocument(entry, doc);
     }
   });
+  registerMetadataContributor({
+    name: "workflow-program-metadata",
+    appliesTo: ({ rendererName }) => rendererName === WORKFLOW_PROGRAM_RENDERER_NAME,
+    contribute(entry, { renderContext }) {
+      const program = loadProgram(renderContext);
+      const hints = new Set(entry.searchHints ?? []);
+      hints.add(program.name);
+      for (const step of program.steps) {
+        hints.add(step.id);
+        if (step.title)
+          hints.add(step.title);
+        hints.add(programStepInstructions(step));
+        for (const criterion of step.gate?.criteria ?? []) {
+          hints.add(criterion);
+        }
+      }
+      entry.searchHints = Array.from(hints).filter(Boolean);
+      if (!entry.description && program.description) {
+        entry.description = program.description;
+      }
+      const parameters = projectProgramParameters(program);
+      if (parameters?.length) {
+        entry.parameters = parameters;
+      }
+    }
+  });
 });
 
 // src/output/renderers.ts
@@ -8151,6 +8860,25 @@ function applyTocMetadata(entry, ctx) {
       entry.toc = toc.headings;
   } catch {}
 }
+function applyFactMetadata(entry, ctx) {
+  try {
+    const fm = applyFrontmatterDescriptionAndTags(entry, ctx);
+    const tags = new Set([...entry.tags ?? [], "fact"]);
+    const hints = new Set(entry.searchHints ?? []);
+    const category = asNonEmptyString(fm.category);
+    if (category) {
+      tags.add(category);
+      hints.add(`category:${category}`);
+    }
+    if (fm.pinned === true) {
+      tags.add("pinned");
+      hints.add("pinned");
+    }
+    entry.tags = Array.from(tags).filter(Boolean);
+    if (hints.size > 0)
+      entry.searchHints = Array.from(hints).filter(Boolean);
+  } catch {}
+}
 function applyFrontmatterDescriptionAndTags(entry, ctx) {
   const parsed = parseFrontmatter(ctx.content());
   const fm = parsed.data;
@@ -8216,12 +8944,7 @@ function applyScriptMetadata(entry, ctx) {
   }
 }
 function applyEnvMetadata(entry, ctx) {
-  const { keys, comments } = listKeys(ctx.absPath);
-  if (comments.length > 0 && !entry.description) {
-    entry.description = comments.join(" ").slice(0, 500);
-    entry.source = "comments";
-    entry.confidence = 0.7;
-  }
+  const { keys } = listKeys(ctx.absPath);
   if (keys.length > 0) {
     entry.searchHints = keys;
   }
@@ -8250,6 +8973,7 @@ function applyTaskMetadata(entry, ctx) {
 }
 var init_renderers = __esm(() => {
   init_env();
+  init_frontmatter();
   init_markdown();
   init_common();
   init_metadata();
@@ -8296,6 +9020,11 @@ var init_renderers = __esm(() => {
     appliesTo: ({ rendererName }) => rendererName === "session-md",
     contribute: (entry, ctx) => applySessionMetadata(entry, ctx.renderContext)
   });
+  registerMetadataContributor({
+    name: "fact-md-metadata",
+    appliesTo: ({ rendererName }) => rendererName === "fact-md",
+    contribute: (entry, ctx) => applyFactMetadata(entry, ctx.renderContext)
+  });
 });
 
 // src/core/asset/asset-registry.ts
@@ -8304,24 +9033,52 @@ var init_asset_registry = __esm(() => {
 });
 
 // src/core/asset/asset-spec.ts
-import path from "path";
+import fs5 from "node:fs";
+import path2 from "node:path";
+function toPosix2(input) {
+  return input.replace(/\\/g, "/");
+}
 function getAssetTypes() {
   return Object.keys(ASSET_SPECS_INTERNAL);
 }
-var buildTaskAction = (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`, markdownSpec, SCRIPT_EXTENSIONS, scriptSpec, ASSET_SPECS_INTERNAL, TYPE_DIRS;
+var buildTaskAction = (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`, WORKFLOW_EXTENSIONS, workflowSpec, markdownSpec, SCRIPT_EXTENSIONS, scriptSpec, ASSET_SPECS_INTERNAL, TYPE_DIRS;
 var init_asset_spec = __esm(() => {
   init_renderers();
-  init_common();
   init_asset_registry();
+  WORKFLOW_EXTENSIONS = [".md", ".yaml", ".yml"];
+  workflowSpec = {
+    isRelevantFile: (fileName) => WORKFLOW_EXTENSIONS.includes(path2.extname(fileName).toLowerCase()),
+    toCanonicalName: (typeRoot, filePath) => {
+      const rel = toPosix2(path2.relative(typeRoot, filePath));
+      for (const ext of WORKFLOW_EXTENSIONS) {
+        if (rel.toLowerCase().endsWith(ext))
+          return rel.slice(0, -ext.length);
+      }
+      return rel;
+    },
+    toAssetPath: (typeRoot, name) => {
+      const lower = name.toLowerCase();
+      for (const ext of WORKFLOW_EXTENSIONS) {
+        if (lower.endsWith(ext))
+          return path2.join(typeRoot, name);
+      }
+      for (const ext of WORKFLOW_EXTENSIONS) {
+        const candidate = path2.join(typeRoot, `${name}${ext}`);
+        if (fs5.existsSync(candidate))
+          return candidate;
+      }
+      return path2.join(typeRoot, `${name}.md`);
+    }
+  };
   markdownSpec = {
-    isRelevantFile: (fileName) => path.extname(fileName).toLowerCase() === ".md",
+    isRelevantFile: (fileName) => path2.extname(fileName).toLowerCase() === ".md",
     toCanonicalName: (typeRoot, filePath) => {
-      const rel = toPosix(path.relative(typeRoot, filePath));
+      const rel = toPosix2(path2.relative(typeRoot, filePath));
       return rel.endsWith(".md") ? rel.slice(0, -3) : rel;
     },
     toAssetPath: (typeRoot, name) => {
       const withExt = name.endsWith(".md") ? name : `${name}.md`;
-      return path.join(typeRoot, withExt);
+      return path2.join(typeRoot, withExt);
     }
   };
   SCRIPT_EXTENSIONS = new Set([
@@ -8343,28 +9100,28 @@ var init_asset_spec = __esm(() => {
     ".kts"
   ]);
   scriptSpec = {
-    isRelevantFile: (fileName) => SCRIPT_EXTENSIONS.has(path.extname(fileName).toLowerCase()),
-    toCanonicalName: (typeRoot, filePath) => toPosix(path.relative(typeRoot, filePath)),
-    toAssetPath: (typeRoot, name) => path.join(typeRoot, name)
+    isRelevantFile: (fileName) => SCRIPT_EXTENSIONS.has(path2.extname(fileName).toLowerCase()),
+    toCanonicalName: (typeRoot, filePath) => toPosix2(path2.relative(typeRoot, filePath)),
+    toAssetPath: (typeRoot, name) => path2.join(typeRoot, name)
   };
   ASSET_SPECS_INTERNAL = {
     skill: {
       stashDir: "skills",
       isRelevantFile: (fileName) => fileName === "SKILL.md",
       toCanonicalName: (typeRoot, filePath) => {
-        const relDir = toPosix(path.dirname(path.relative(typeRoot, filePath)));
+        const relDir = toPosix2(path2.dirname(path2.relative(typeRoot, filePath)));
         if (!relDir || relDir === ".")
           return;
         return relDir;
       },
-      toAssetPath: (typeRoot, name) => path.join(typeRoot, name, "SKILL.md")
+      toAssetPath: (typeRoot, name) => path2.join(typeRoot, name, "SKILL.md")
     },
     command: { stashDir: "commands", ...markdownSpec },
     agent: { stashDir: "agents", ...markdownSpec },
     knowledge: { stashDir: "knowledge", ...markdownSpec },
     workflow: {
       stashDir: "workflows",
-      ...markdownSpec,
+      ...workflowSpec,
       rendererName: "workflow-md",
       actionBuilder: (ref) => buildWorkflowAction(ref)
     },
@@ -8374,10 +9131,10 @@ var init_asset_spec = __esm(() => {
       stashDir: "env",
       isRelevantFile: (fileName) => fileName === ".env" || fileName.endsWith(".env"),
       toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix(path.relative(typeRoot, filePath));
-        const fileName = path.basename(rel);
+        const rel = toPosix2(path2.relative(typeRoot, filePath));
+        const fileName = path2.basename(rel);
         if (fileName === ".env") {
-          const dir = path.dirname(rel);
+          const dir = path2.dirname(rel);
           return dir === "." || dir === "" ? "default" : `${dir}/default`;
         }
         const stripped = rel.endsWith(".env") ? rel.slice(0, -4) : rel;
@@ -8385,17 +9142,17 @@ var init_asset_spec = __esm(() => {
       },
       toAssetPath: (typeRoot, name) => {
         if (name === "default")
-          return path.join(typeRoot, ".env");
-        return path.join(typeRoot, name.endsWith(".env") ? name : `${name}.env`);
+          return path2.join(typeRoot, ".env");
+        return path2.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 (values never reach stdout); akm env export ${ref} --out <file> -> write a sourceable script to a 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`
     },
     secret: {
       stashDir: "secrets",
       isRelevantFile: (fileName) => !fileName.endsWith(".lock") && !fileName.endsWith(".sensitive"),
-      toCanonicalName: (typeRoot, filePath) => toPosix(path.relative(typeRoot, filePath)),
-      toAssetPath: (typeRoot, name) => path.join(typeRoot, name),
+      toCanonicalName: (typeRoot, filePath) => toPosix2(path2.relative(typeRoot, filePath)),
+      toAssetPath: (typeRoot, name) => path2.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`
     },
@@ -8413,14 +9170,14 @@ var init_asset_spec = __esm(() => {
     },
     task: {
       stashDir: "tasks",
-      isRelevantFile: (fileName) => path.extname(fileName).toLowerCase() === ".yml",
+      isRelevantFile: (fileName) => path2.extname(fileName).toLowerCase() === ".yml",
       toCanonicalName: (typeRoot, filePath) => {
-        const rel = toPosix(path.relative(typeRoot, filePath));
+        const rel = toPosix2(path2.relative(typeRoot, filePath));
         return rel.endsWith(".yml") ? rel.slice(0, -4) : rel;
       },
       toAssetPath: (typeRoot, name) => {
         const withExt = name.endsWith(".yml") ? name : `${name}.yml`;
-        return path.join(typeRoot, withExt);
+        return path2.join(typeRoot, withExt);
       },
       rendererName: "task-yaml",
       actionBuilder: buildTaskAction
@@ -8430,15 +9187,18 @@ var init_asset_spec = __esm(() => {
       ...markdownSpec,
       rendererName: "session-md",
       actionBuilder: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``
+    },
+    fact: {
+      stashDir: "facts",
+      ...markdownSpec,
+      rendererName: "fact-md",
+      actionBuilder: (ref) => `akm show ${ref} -> read the stash fact and apply it as durable context`
     }
   };
   TYPE_DIRS = Object.fromEntries(Object.entries(ASSET_SPECS_INTERNAL).map(([type, spec]) => [type, spec.stashDir]));
 });
 
 // src/core/common.ts
-function toPosix(input) {
-  return input.replace(/\\/g, "/");
-}
 function asNonEmptyString(value) {
   if (typeof value !== "string")
     return;
@@ -8457,7 +9217,7 @@ var init_common = __esm(() => {
 });
 
 // src/core/paths.ts
-import path2 from "path";
+import path3 from "node:path";
 function isUnderBunTest(env) {
   return env.BUN_TEST === "1" || env.NODE_ENV === "test";
 }
@@ -8474,23 +9234,23 @@ function getDataDir(env = process.env, platform = process.platform) {
   if (platform === "win32") {
     const localAppData = env.LOCALAPPDATA?.trim();
     if (localAppData)
-      return path2.join(localAppData, "akm", "data");
+      return path3.join(localAppData, "akm", "data");
     const userProfile = env.USERPROFILE?.trim();
     if (userProfile)
-      return path2.join(userProfile, "AppData", "Local", "akm", "data");
+      return path3.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");
+    return path3.join(appData, "..", "Local", "akm", "data");
   }
   const xdgDataHome = env.XDG_DATA_HOME?.trim();
   if (xdgDataHome)
-    return path2.join(xdgDataHome, "akm");
+    return path3.join(xdgDataHome, "akm");
   const home = env.HOME?.trim();
   if (!home)
-    return path2.join("/tmp", "akm-data");
-  return path2.join(home, ".local", "share", "akm");
+    return path3.join("/tmp", "akm-data");
+  return path3.join(home, ".local", "share", "akm");
 }
 var init_paths = __esm(() => {
   init_common();
@@ -8498,22 +9258,40 @@ var init_paths = __esm(() => {
 });
 
 // scripts/migrations/import-fs-improve-runs-to-db.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/core/state-db.ts
-import fs3 from "fs";
-import path3 from "path";
+import path4 from "node:path";
+
+// src/storage/managed-db.ts
+import fs2 from "node:fs";
+import path from "node:path";
 
 // src/storage/database.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "node:module";
 var isBun = !!process.versions?.bun;
-var nodeRequire = createRequire(import.meta.url);
-function openDatabase(path, opts) {
-  if (isBun) {
-    return openBunDatabase(path, opts);
+var nodeRequire = createRequire2(import.meta.url);
+var bunSqliteProvider = {
+  name: "bun:sqlite",
+  supported: () => isBun,
+  open: openBunDatabase
+};
+var nodeSqliteProvider = {
+  name: "better-sqlite3",
+  supported: () => !isBun,
+  open: openNodeDatabase
+};
+var PROVIDERS = [bunSqliteProvider, nodeSqliteProvider];
+function selectProvider() {
+  const provider = PROVIDERS.find((p) => p.supported());
+  if (!provider) {
+    throw new Error(`No storage provider supports the current runtime (${isBun ? "Bun" : "Node"}).`);
   }
-  return openNodeDatabase(path, opts);
+  return provider;
+}
+function openDatabase(path, opts) {
+  return selectProvider().open(path, opts);
 }
 function openBunDatabase(path, opts) {
   const { Database: BunDatabase } = loadBunSqlite();
@@ -8538,7 +9316,16 @@ function loadBunSqlite() {
 var betterSqlite3Ctor;
 function loadBetterSqlite3() {
   if (!betterSqlite3Ctor) {
-    const mod = nodeRequire("better-sqlite3");
+    let mod;
+    try {
+      mod = nodeRequire("better-sqlite3");
+    } catch (err) {
+      throw new Error(`akm could not load 'better-sqlite3', the SQLite driver it needs on Node.js.
+` + `  • Reinstall akm with a working C/C++ build toolchain so its optional
+` + "    'better-sqlite3' native binding rebuilds (a global `npm i -g better-sqlite3`\n" + `    will NOT be resolved — Node loads it from akm's own node_modules).
+` + `  • Or run akm under Bun, which has a built-in SQLite driver and needs no native build.
+` + `  Underlying load error: ${err instanceof Error ? err.message : String(err)}`);
+    }
     betterSqlite3Ctor = mod.default ?? mod;
   }
   return betterSqlite3Ctor;
@@ -8554,6 +9341,109 @@ function openNodeDatabase(path, opts) {
   return db;
 }
 
+// src/storage/sqlite-pragmas.ts
+init_warn();
+
+// src/runtime.ts
+import { createWriteStream, statfsSync } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+var isBun2 = !!process.versions?.bun;
+var nodeRequire2 = createRequire3(import.meta.url);
+function statfsType(path) {
+  try {
+    return statfsSync(path).type;
+  } catch {
+    return;
+  }
+}
+var mainPath = isBun2 ? bunGlobal().main : process.argv[1];
+function bunGlobal() {
+  return globalThis.Bun;
+}
+
+// src/storage/sqlite-pragmas.ts
+var VALID_MODES = new Set(["WAL", "DELETE", "TRUNCATE"]);
+var warnedInvalid = false;
+var warnedNetworkFallback = false;
+function resolveJournalMode(raw) {
+  if (raw === undefined)
+    return "WAL";
+  const normalized = raw.trim().toUpperCase();
+  if (normalized === "")
+    return "WAL";
+  if (VALID_MODES.has(normalized)) {
+    return normalized;
+  }
+  warnInvalidJournalModeOnce(raw);
+  return "WAL";
+}
+function resolveConfiguredJournalMode(env = process.env) {
+  return resolveJournalMode(env.AKM_SQLITE_JOURNAL_MODE);
+}
+function warnInvalidJournalModeOnce(raw) {
+  if (warnedInvalid)
+    return;
+  warnedInvalid = true;
+  warn(`[akm] invalid AKM_SQLITE_JOURNAL_MODE=${JSON.stringify(raw)} — using WAL (valid: WAL, DELETE, TRUNCATE)`);
+}
+var FS_MAGIC_NFS = 26985;
+var FS_MAGIC_SMB = 20859;
+var FS_MAGIC_CIFS = 4283649346;
+var FS_MAGIC_SMB2 = 4266872130;
+var FS_MAGIC_FUSE = 1702057286;
+var NETWORK_FS_MAGICS = new Set([
+  FS_MAGIC_NFS,
+  FS_MAGIC_SMB,
+  FS_MAGIC_CIFS,
+  FS_MAGIC_SMB2,
+  FS_MAGIC_FUSE
+]);
+function isNetworkFilesystem(fsType) {
+  if (fsType === undefined)
+    return false;
+  return NETWORK_FS_MAGICS.has(fsType);
+}
+function applyStandardPragmas(db, opts = {}) {
+  let mode = resolveConfiguredJournalMode(opts.env);
+  if (mode === "WAL" && opts.dataDir) {
+    const probe = opts.fsTypeProbe ?? statfsType;
+    if (isNetworkFilesystem(probe(opts.dataDir))) {
+      mode = "DELETE";
+      warnNetworkFallbackOnce(opts.dataDir);
+    }
+  }
+  db.exec("PRAGMA busy_timeout = 30000");
+  db.exec(`PRAGMA journal_mode = ${mode}`);
+  if (opts.foreignKeys !== false) {
+    db.exec("PRAGMA foreign_keys = ON");
+  }
+  if (mode !== "WAL") {
+    db.exec("PRAGMA synchronous = FULL");
+  }
+  return mode;
+}
+function warnNetworkFallbackOnce(dataDir) {
+  if (warnedNetworkFallback)
+    return;
+  warnedNetworkFallback = true;
+  warn(`[akm] network filesystem detected at ${dataDir} — WAL unsupported, using DELETE journal mode`);
+}
+
+// src/storage/managed-db.ts
+function openManagedDatabase(spec) {
+  const dir = path.dirname(spec.path);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const db = openDatabase(spec.path);
+  applyStandardPragmas(db, spec.pragmas ?? { dataDir: dir });
+  spec.init?.(db);
+  return db;
+}
+
+// src/core/state-db.ts
+init_paths();
+
 // src/storage/engines/sqlite-migrations.ts
 function ensureMigrationsTable(db) {
   db.exec(`
@@ -8578,87 +9468,31 @@ function runMigrations(db, migrations, opts) {
   }
 }
 
-// src/core/assert.ts
-function assertNever(x, context) {
-  let serialized;
-  try {
-    serialized = JSON.stringify(x);
-  } catch {
-    serialized = String(x);
-  }
-  if (serialized === undefined) {
-    serialized = String(x);
-  }
-  const where = context ? ` (${context})` : "";
-  throw new Error(`Unexpected value reached assertNever${where}: ${serialized}`);
-}
-
-// src/core/improve-types.ts
-function classifyImproveAction(mode) {
-  switch (mode) {
-    case "reflect":
-    case "distill":
-    case "memory-inference":
-    case "graph-extraction":
-      return "accepted";
-    case "reflect-cooldown":
-    case "reflect-skipped":
-    case "distill-skipped":
-    case "reflect-guard-rejected":
-      return "rejected";
-    case "reflect-failed":
-    case "error":
-      return "error";
-    case "memory-prune":
-      return "noop";
-    default:
-      return assertNever(mode);
-  }
-}
-
-// src/core/state-db.ts
-init_paths();
-init_warn();
-function getStateDbPath() {
-  return path3.join(getDataDir(), "state.db");
-}
-function openStateDatabase(dbPath) {
-  const resolvedPath = dbPath ?? getStateDbPath();
-  const dir = path3.dirname(resolvedPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  const db = openDatabase(resolvedPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec("PRAGMA busy_timeout = 30000");
-  runMigrations2(db);
-  return db;
-}
+// src/core/state/migrations.ts
 var MIGRATIONS = [
   {
     id: "001-initial-schema",
     up: `
-      -- \u2500\u2500 events \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      -- ── events ──────────────────────────────────────────────────────────────
       --
       -- Replaces events.jsonl. Indexed (query) columns:
-      --   id          INTEGER PK \u2014 monotonic rowid; replaces byte-offset cursor.
+      --   id          INTEGER PK — monotonic rowid; replaces byte-offset cursor.
       --                            Callers store this as "sinceId" for resume.
-      --   event_type  TEXT        \u2014 indexed; replaces the type filter in readEvents().
-      --   ts          TEXT        \u2014 ISO-8601 UTC ms; indexed for range queries.
-      --   ref         TEXT        \u2014 nullable asset ref; indexed for ref-scoped queries.
+      --   event_type  TEXT        — indexed; replaces the type filter in readEvents().
+      --   ts          TEXT        — ISO-8601 UTC ms; indexed for range queries.
+      --   ref         TEXT        — nullable asset ref; indexed for ref-scoped queries.
       --
       -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      \u2014 JSON object storing all non-indexed payload
+      --   metadata_json TEXT      — JSON object storing all non-indexed payload
       --                             fields (tags, any future structured fields).
       --                             Maps directly to EventEnvelope.metadata.
       --
-      -- schema_version mirrors EventEnvelope.schemaVersion \u2014 always 1 for v1
+      -- schema_version mirrors EventEnvelope.schemaVersion — always 1 for v1
       -- rows. Stored as a column (not in the JSON blob) so future schema
       -- changes can be detected and migrated row-by-row if ever needed.
       --
       -- TTL: rows where ts < NOW() - 90 days can be deleted by a maintenance job.
-      -- No automatic deletion occurs here \u2014 callers call purgeOldEvents().
+      -- No automatic deletion occurs here — callers call purgeOldEvents().
       --
       -- ADD COLUMN extension points (future migrations):
       --   ALTER TABLE events ADD COLUMN stash_dir TEXT DEFAULT NULL;
@@ -8674,38 +9508,38 @@ var MIGRATIONS = [
       );
 
       -- Query patterns supported by these indexes:
-      --   SELECT \u2026 WHERE event_type = ?                 \u2192 idx_events_type
-      --   SELECT \u2026 WHERE ref = ?                        \u2192 idx_events_ref
-      --   SELECT \u2026 WHERE ts >= ? AND ts <= ?            \u2192 idx_events_ts
-      --   SELECT \u2026 WHERE event_type = ? AND ref = ?     \u2192 idx_events_type (prefix scan) + filter
-      --   SELECT \u2026 WHERE id > ?                         \u2192 PK (rowid) \u2014 no extra index needed
+      --   SELECT … WHERE event_type = ?                 → idx_events_type
+      --   SELECT … WHERE ref = ?                        → idx_events_ref
+      --   SELECT … WHERE ts >= ? AND ts <= ?            → idx_events_ts
+      --   SELECT … WHERE event_type = ? AND ref = ?     → idx_events_type (prefix scan) + filter
+      --   SELECT … WHERE id > ?                         → PK (rowid) — no extra index needed
       CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
       CREATE INDEX IF NOT EXISTS idx_events_ref  ON events(ref);
       CREATE INDEX IF NOT EXISTS idx_events_ts   ON events(ts);
 
-      -- \u2500\u2500 proposals \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      -- ── proposals ────────────────────────────────────────────────────────────
       --
       -- Replaces per-uuid JSON directories under <stashDir>/.akm/proposals/.
       --
       -- Indexed (query) columns:
-      --   id          TEXT PK     \u2014 UUID (crypto.randomUUID()); stable directory name.
-      --   stash_dir   TEXT        \u2014 absolute stash root; multi-stash installs need
+      --   id          TEXT PK     — UUID (crypto.randomUUID()); stable directory name.
+      --   stash_dir   TEXT        — absolute stash root; multi-stash installs need
       --                             this to partition proposal lists per stash.
-      --   ref         TEXT        \u2014 target asset ref (e.g. "lesson:alpha");
+      --   ref         TEXT        — target asset ref (e.g. "lesson:alpha");
       --                             indexed for ref-scoped queue views.
-      --   status      TEXT        \u2014 "pending" | "accepted" | "rejected"; indexed
+      --   status      TEXT        — "pending" | "accepted" | "rejected"; indexed
       --                             so pending-queue queries are fast.
-      --   source      TEXT        \u2014 human-readable origin tag (e.g. "reflect").
-      --   created_at  TEXT        \u2014 ISO-8601; used for ORDER BY created_at ASC.
-      --   updated_at  TEXT        \u2014 ISO-8601; updated on accept/reject.
+      --   source      TEXT        — human-readable origin tag (e.g. "reflect").
+      --   created_at  TEXT        — ISO-8601; used for ORDER BY created_at ASC.
+      --   updated_at  TEXT        — ISO-8601; updated on accept/reject.
       --
       -- Large payload columns (NOT indexed):
-      --   content     TEXT        \u2014 full markdown text; the proposal payload body.
-      --   frontmatter_json TEXT   \u2014 JSON of parsed frontmatter (may be NULL when
+      --   content     TEXT        — full markdown text; the proposal payload body.
+      --   frontmatter_json TEXT   — JSON of parsed frontmatter (may be NULL when
       --                             the content has no frontmatter block).
       --
       -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      \u2014 JSON object for future proposal fields.
+      --   metadata_json TEXT      — JSON object for future proposal fields.
       --                             Current fields stored here: sourceRun,
       --                             review, confidence, gateDecision (#577),
       --                             backupContent, eligibilitySource.
@@ -8731,38 +9565,38 @@ var MIGRATIONS = [
       );
 
       -- Query patterns:
-      --   SELECT \u2026 WHERE stash_dir = ? AND status = ?   \u2192 idx_proposals_stash_status
-      --   SELECT \u2026 WHERE ref = ? AND status = ?         \u2192 idx_proposals_ref_status
-      --   SELECT \u2026 WHERE id = ?                         \u2192 PK
+      --   SELECT … WHERE stash_dir = ? AND status = ?   → idx_proposals_stash_status
+      --   SELECT … WHERE ref = ? AND status = ?         → idx_proposals_ref_status
+      --   SELECT … WHERE id = ?                         → PK
       CREATE INDEX IF NOT EXISTS idx_proposals_stash_status
         ON proposals(stash_dir, status);
       CREATE INDEX IF NOT EXISTS idx_proposals_ref_status
         ON proposals(ref, status);
 
-      -- \u2500\u2500 task_history \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      -- ── task_history ─────────────────────────────────────────────────────────
       --
       -- Replaces per-task JSONL files under <cacheDir>/tasks/history/.
       --
       -- Indexed (query) columns:
-      --   task_id     TEXT PK     \u2014 stable task identifier string.
-      --   status      TEXT        \u2014 terminal status (e.g. "completed", "failed",
+      --   task_id     TEXT PK     — stable task identifier string.
+      --   status      TEXT        — terminal status (e.g. "completed", "failed",
       --                             "cancelled"); indexed for status-scoped queries.
-      --   started_at  TEXT        \u2014 ISO-8601; indexed for time-range queries.
-      --   target_kind TEXT        \u2014 kind of the target entity (e.g. "issue",
+      --   started_at  TEXT        — ISO-8601; indexed for time-range queries.
+      --   target_kind TEXT        — kind of the target entity (e.g. "issue",
       --                             "workflow", "agent"); indexed for kind-scoped queries.
-      --   target_ref  TEXT        \u2014 stable ref of the target entity; indexed for
+      --   target_ref  TEXT        — stable ref of the target entity; indexed for
       --                             per-target history lookups.
       --
       -- Non-indexed time columns:
-      --   completed_at TEXT       \u2014 ISO-8601 or NULL if still running.
-      --   failed_at    TEXT       \u2014 ISO-8601 or NULL.
+      --   completed_at TEXT       — ISO-8601 or NULL if still running.
+      --   failed_at    TEXT       — ISO-8601 or NULL.
       --
       -- Non-indexed diagnostic columns:
-      --   log_path     TEXT       \u2014 absolute path to the task log file, if any.
+      --   log_path     TEXT       — absolute path to the task log file, if any.
       --
       -- Extensible (metadata_json) columns:
-      --   metadata_json TEXT      \u2014 JSON object for future task fields (exit_code,
-      --                             runner, priority, parent_task_id, \u2026).
+      --   metadata_json TEXT      — JSON object for future task fields (exit_code,
+      --                             runner, priority, parent_task_id, …).
       --
       -- ADD COLUMN extension points (future migrations):
       --   ALTER TABLE task_history ADD COLUMN exit_code INTEGER DEFAULT NULL;
@@ -8783,10 +9617,10 @@ var MIGRATIONS = [
       );
 
       -- Query patterns:
-      --   SELECT \u2026 WHERE task_id = ?                    \u2192 PK
-      --   SELECT \u2026 WHERE started_at >= ? AND started_at <= ? \u2192 idx_task_history_started
-      --   SELECT \u2026 WHERE target_kind = ? AND target_ref = ?  \u2192 idx_task_history_target
-      --   SELECT \u2026 WHERE status = ?                     \u2192 idx_task_history_status
+      --   SELECT … WHERE task_id = ?                    → PK
+      --   SELECT … WHERE started_at >= ? AND started_at <= ? → idx_task_history_started
+      --   SELECT … WHERE target_kind = ? AND target_ref = ?  → idx_task_history_target
+      --   SELECT … WHERE status = ?                     → idx_task_history_status
       CREATE INDEX IF NOT EXISTS idx_task_history_started
         ON task_history(started_at);
       CREATE INDEX IF NOT EXISTS idx_task_history_target
@@ -8855,12 +9689,12 @@ var MIGRATIONS = [
       );
 
       -- Query patterns supported:
-      --   SELECT \u2026 WHERE started_at >= ? AND started_at <= ?
-      --     \u2192 idx_improve_runs_started
-      --   SELECT \u2026 WHERE dry_run = 0
-      --     \u2192 idx_improve_runs_dry_run (productivity audits filter trap)
-      --   SELECT \u2026 WHERE stash_dir = ? AND scope_mode = ?
-      --     \u2192 idx_improve_runs_stash_scope
+      --   SELECT … WHERE started_at >= ? AND started_at <= ?
+      --     → idx_improve_runs_started
+      --   SELECT … WHERE dry_run = 0
+      --     → idx_improve_runs_dry_run (productivity audits filter trap)
+      --   SELECT … WHERE stash_dir = ? AND scope_mode = ?
+      --     → idx_improve_runs_stash_scope
       CREATE INDEX IF NOT EXISTS idx_improve_runs_started
         ON improve_runs(started_at);
       CREATE INDEX IF NOT EXISTS idx_improve_runs_dry_run
@@ -8887,9 +9721,9 @@ var MIGRATIONS = [
       );
 
       -- Query patterns:
-      --   SELECT \u2026 WHERE harness = ?                       \u2192 idx_extract_sessions_harness
-      --   SELECT \u2026 WHERE processed_at >= ?                 \u2192 idx_extract_sessions_processed
-      --   SELECT \u2026 WHERE harness = ? AND session_id = ?    \u2192 PK
+      --   SELECT … WHERE harness = ?                       → idx_extract_sessions_harness
+      --   SELECT … WHERE processed_at >= ?                 → idx_extract_sessions_processed
+      --   SELECT … WHERE harness = ? AND session_id = ?    → PK
       CREATE INDEX IF NOT EXISTS idx_extract_sessions_harness
         ON extract_sessions_seen(harness);
       CREATE INDEX IF NOT EXISTS idx_extract_sessions_processed
@@ -8912,17 +9746,215 @@ var MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_proposals_stash_status_ref_source
         ON proposals(stash_dir, status, ref, source);
     `
+  },
+  {
+    id: "007-consolidation-judged",
+    up: `
+      CREATE TABLE IF NOT EXISTS consolidation_judged (
+        entry_key    TEXT    PRIMARY KEY,
+        content_hash TEXT    NOT NULL,
+        judged_at    TEXT    NOT NULL,
+        outcome      TEXT    NOT NULL
+      );
+    `
+  },
+  {
+    id: "008-body-embeddings",
+    up: `
+      CREATE TABLE IF NOT EXISTS body_embeddings (
+        content_hash TEXT    PRIMARY KEY,
+        embedding    BLOB    NOT NULL,
+        model_id     TEXT    NOT NULL,
+        created_at   INTEGER NOT NULL
+      );
+    `
+  },
+  {
+    id: "009-asset-salience",
+    up: `
+      CREATE TABLE IF NOT EXISTS asset_salience (
+        asset_ref          TEXT    PRIMARY KEY,
+        encoding_salience  REAL    NOT NULL DEFAULT 0.5,
+        outcome_salience   REAL    NOT NULL DEFAULT 0.0,
+        retrieval_salience REAL    NOT NULL DEFAULT 0.0,
+        rank_score         REAL    NOT NULL DEFAULT 0.0,
+        consecutive_no_ops INTEGER NOT NULL DEFAULT 0,
+        updated_at         INTEGER NOT NULL DEFAULT 0
+      );
+
+      -- Hot path: sort / filter by rank_score for selector queries.
+      CREATE INDEX IF NOT EXISTS idx_asset_salience_rank
+        ON asset_salience(rank_score DESC);
+    `
+  },
+  {
+    id: "010-asset-outcome",
+    up: `
+      CREATE TABLE IF NOT EXISTS asset_outcome (
+        asset_ref                TEXT    PRIMARY KEY,
+        last_retrieved_at        INTEGER NOT NULL DEFAULT 0,
+        retrieval_count          INTEGER NOT NULL DEFAULT 0,
+        expected_retrieval_rate  REAL    NOT NULL DEFAULT 0.0,
+        negative_feedback_count  INTEGER NOT NULL DEFAULT 0,
+        accepted_change_count    INTEGER NOT NULL DEFAULT 0,
+        review_pressure          INTEGER NOT NULL DEFAULT 0,
+        outcome_score            REAL    NOT NULL DEFAULT 0.0,
+        updated_at               INTEGER NOT NULL DEFAULT 0
+      );
+
+      -- Hot path: sort assets by review_pressure DESC for #613 admission.
+      CREATE INDEX IF NOT EXISTS idx_asset_outcome_review_pressure
+        ON asset_outcome(review_pressure DESC);
+
+      -- Secondary: sort by outcome_score DESC for outcomeSalience reads.
+      CREATE INDEX IF NOT EXISTS idx_asset_outcome_score
+        ON asset_outcome(outcome_score DESC);
+    `
+  },
+  {
+    id: "011-asset-salience-homeostatic-demoted-at",
+    up: `
+      ALTER TABLE asset_salience ADD COLUMN homeostatic_demoted_at INTEGER DEFAULT NULL;
+    `
+  },
+  {
+    id: "012-improve-gate-thresholds",
+    up: `
+      CREATE TABLE IF NOT EXISTS improve_gate_thresholds (
+        phase       TEXT    NOT NULL PRIMARY KEY,
+        threshold   INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
+    `
+  },
+  {
+    id: "013-extract-sessions-content-hash",
+    up: `
+      ALTER TABLE extract_sessions_seen ADD COLUMN content_hash TEXT DEFAULT NULL;
+    `
+  },
+  {
+    id: "014-recombine-hypotheses",
+    up: `
+      CREATE TABLE IF NOT EXISTS recombine_hypotheses (
+        hypothesis_ref    TEXT PRIMARY KEY,
+        signature         TEXT NOT NULL,
+        member_key        TEXT NOT NULL,
+        consecutive_count INTEGER NOT NULL DEFAULT 0,
+        first_seen_at     TEXT NOT NULL,
+        last_seen_at      TEXT NOT NULL,
+        last_run          TEXT,
+        promoted_at       TEXT,
+        metadata_json     TEXT NOT NULL DEFAULT '{}'
+      );
+      CREATE INDEX IF NOT EXISTS idx_recombine_hypotheses_last_seen
+        ON recombine_hypotheses(last_seen_at);
+    `
+  },
+  {
+    id: "015-asset-salience-encoding-source",
+    up: `
+      ALTER TABLE asset_salience ADD COLUMN encoding_source TEXT DEFAULT NULL;
+    `
+  },
+  {
+    id: "016-collapse-churn-detector",
+    up: `
+      CREATE TABLE IF NOT EXISTS canary_queries (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        canary_set_id TEXT    NOT NULL,
+        anchor_ref    TEXT    NOT NULL,
+        query         TEXT    NOT NULL,
+        source        TEXT    NOT NULL DEFAULT 'auto',
+        active        INTEGER NOT NULL DEFAULT 1,
+        created_at    TEXT    NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_canary_queries_active
+        ON canary_queries(active, canary_set_id);
+
+      CREATE TABLE IF NOT EXISTS improve_cycle_metrics (
+        id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id                  TEXT    NOT NULL,
+        ts                      TEXT    NOT NULL,
+        pass                    TEXT    NOT NULL,
+        canary_set_id           TEXT    NOT NULL,
+        mean_recall             REAL    NOT NULL,
+        mean_ndcg               REAL    NOT NULL,
+        mean_mrr                REAL    NOT NULL,
+        canary_ranks_json       TEXT    NOT NULL,
+        store_total             INTEGER NOT NULL,
+        store_by_type_json      TEXT    NOT NULL,
+        distinct_content_ratio  REAL    NOT NULL,
+        mean_bigram_diversity   REAL    NOT NULL,
+        over_generation_count   INTEGER NOT NULL,
+        accepted_actions        INTEGER NOT NULL,
+        merge_floor_violations  INTEGER NOT NULL DEFAULT 0,
+        alerts_json             TEXT    NOT NULL DEFAULT '[]'
+      );
+      CREATE INDEX IF NOT EXISTS idx_improve_cycle_metrics_ts
+        ON improve_cycle_metrics(ts);
+    `
   }
 ];
 function runMigrations2(db) {
   runMigrations(db, MIGRATIONS);
 }
+
+// src/core/state-db.ts
+function getStateDbPath() {
+  return path4.join(getDataDir(), "state.db");
+}
+function openStateDatabase(dbPath) {
+  return openManagedDatabase({ path: dbPath ?? getStateDbPath(), init: runMigrations2 });
+}
+
+// src/core/assert.ts
+function assertNever(x, context) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(x);
+  } catch {
+    serialized = String(x);
+  }
+  if (serialized === undefined) {
+    serialized = String(x);
+  }
+  const where = context ? ` (${context})` : "";
+  throw new Error(`Unexpected value reached assertNever${where}: ${serialized}`);
+}
+
+// src/core/improve-types.ts
+function classifyImproveAction(mode) {
+  switch (mode) {
+    case "reflect":
+    case "distill":
+    case "memory-inference":
+    case "graph-extraction":
+      return "accepted";
+    case "reflect-cooldown":
+    case "reflect-skipped":
+    case "distill-skipped":
+      return "skipped";
+    case "reflect-guard-rejected":
+      return "rejected";
+    case "reflect-failed":
+    case "error":
+      return "error";
+    case "memory-prune":
+      return "noop";
+    default:
+      return assertNever(mode);
+  }
+}
+
+// src/storage/repositories/improve-runs-repository.ts
 function computeImproveRunMetrics(result) {
   const plannedCount = Array.isArray(result.plannedRefs) ? result.plannedRefs.length : 0;
   const actions = Array.isArray(result.actions) ? result.actions : [];
   const actionsCount = actions.length;
   let acceptedCount = 0;
   let rejectedCount = 0;
+  let skippedCount = 0;
   let autoAcceptedCount = 0;
   let errorCount = 0;
   for (const action of actions) {
@@ -8933,6 +9965,9 @@ function computeImproveRunMetrics(result) {
       case "rejected":
         rejectedCount++;
         break;
+      case "skipped":
+        skippedCount++;
+        break;
       case "error":
         errorCount++;
         break;
@@ -8944,7 +9979,17 @@ function computeImproveRunMetrics(result) {
       autoAcceptedCount++;
   }
   autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
-  return { plannedCount, actionsCount, acceptedCount, rejectedCount, autoAcceptedCount, errorCount };
+  const distillSkippedTotal = result.distillSkipped?.total ?? 0;
+  skippedCount += distillSkippedTotal;
+  return {
+    plannedCount,
+    actionsCount: actionsCount + distillSkippedTotal,
+    acceptedCount,
+    rejectedCount,
+    skippedCount,
+    autoAcceptedCount,
+    errorCount
+  };
 }
 function recordImproveRun(db, input) {
   const metricsObj = input.metrics ?? computeImproveRunMetrics(input.result);
@@ -8960,7 +10005,7 @@ function recordImproveRun(db, input) {
 function parseArgs(argv) {
   const stashFromEnv = process.env.AKM_STASH_DIR;
   const out = {
-    stashDir: stashFromEnv ?? path4.join(process.env.HOME ?? "", "akm"),
+    stashDir: stashFromEnv ?? path5.join(process.env.HOME ?? "", "akm"),
     dryRun: false,
     archive: true
   };
@@ -9019,12 +10064,12 @@ function inferScope(envelope) {
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const runsRoot = path4.join(args.stashDir, ".akm", "runs");
-  if (!fs4.existsSync(runsRoot)) {
+  const runsRoot = path5.join(args.stashDir, ".akm", "runs");
+  if (!fs6.existsSync(runsRoot)) {
     console.log(`[import] no legacy runs directory at ${runsRoot}; nothing to do`);
     return;
   }
-  const entries = fs4.readdirSync(runsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const entries = fs6.readdirSync(runsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   if (entries.length === 0) {
     console.log(`[import] ${runsRoot} is empty; nothing to do`);
     return;
@@ -9038,8 +10083,8 @@ async function main() {
   let skippedParseFailed = 0;
   let skippedNoTimestamp = 0;
   for (const id of entries) {
-    const resultPath = path4.join(runsRoot, id, "improve-result.json");
-    if (!fs4.existsSync(resultPath)) {
+    const resultPath = path5.join(runsRoot, id, "improve-result.json");
+    if (!fs6.existsSync(resultPath)) {
       skippedNoResult++;
       continue;
     }
@@ -9049,7 +10094,7 @@ async function main() {
     }
     let envelope;
     try {
-      envelope = JSON.parse(fs4.readFileSync(resultPath, "utf8"));
+      envelope = JSON.parse(fs6.readFileSync(resultPath, "utf8"));
     } catch (err) {
       console.warn(`[import] skipping ${id}: parse failed (${err instanceof Error ? err.message : String(err)})`);
       skippedParseFailed++;
@@ -9114,8 +10159,8 @@ async function main() {
     return;
   }
   const ts = new Date().toISOString().replace(/[:.]/g, "-");
-  const archiveTarget = path4.join(args.stashDir, ".akm", `runs.archived-${ts}`);
-  fs4.renameSync(runsRoot, archiveTarget);
+  const archiveTarget = path5.join(args.stashDir, ".akm", `runs.archived-${ts}`);
+  fs6.renameSync(runsRoot, archiveTarget);
   console.log(`[import] archived ${runsRoot} \u2192 ${archiveTarget}`);
 }
 main().catch((err) => {