akm-cli 0.10.261016-beta → 0.10.261018-beta

package/dist/scripts/akm-migrate.js

@@ -30475,6 +30475,7 @@ function modelWorkConfig() {
   }
   const config2 = {
     ...user,
+    plugins: [...Array.isArray(user?.plugins) ? user.plugins : [], WITHOUT_BROWSER_PLUGIN],
     agents: { ...asRecord(user?.agents), [MODEL_WORK_AGENT]: MODEL_WORK_AGENT_DEFINITION }
   };
   const legacy = asRecord(user?.agent);
@@ -30507,7 +30508,7 @@ function withEnvReferences(content) {
     return replaced(true);
   }
 }
-var MODEL_WORK_AGENT = "akm-model-work", MODEL_WORK_AGENT_DEFINITION, CONFIG_CONTENT_ENV = "OPENCODE_CONFIG_CONTENT", NO_FREE_MODELS, opencodeBuilder;
+var MODEL_WORK_AGENT = "akm-model-work", MODEL_WORK_AGENT_DEFINITION, CONFIG_CONTENT_ENV = "OPENCODE_CONFIG_CONTENT", WITHOUT_BROWSER_PLUGIN = "-opencode.browser", NO_FREE_MODELS, opencodeBuilder;
 var init_agent_builder = __esm(() => {
   init_common();
   init_warn();
@@ -32113,13 +32114,22 @@ function improveStrategyDefault(out, defaults, improve) {
   out.improve = { ...isRecord(improve) ? improve : {} };
   out.improve.strategy ??= defaults.improveStrategy;
 }
-function dropJudgeEngine(out, conversion) {
+function dropJudgeEngine(out, conversion, target, defaultEngine, judge) {
   const workflow = out.workflow;
-  if (!isRecord(workflow) || !("judgeEngine" in workflow))
-    return;
-  delete workflow.judgeEngine;
-  conversion.changed = true;
-  conversion.notes.push("workflow.judgeEngine: a gate's judge is the default connection or harness now; it is dropped.");
+  const named = isRecord(workflow) && "judgeEngine" in workflow;
+  const engine = named ? str(workflow.judgeEngine) : defaultEngine;
+  if (named) {
+    delete workflow.judgeEngine;
+    conversion.changed = true;
+  }
+  const became = engine === undefined ? undefined : target(engine);
+  const stays = became !== undefined && judge !== undefined && isDeepStrictEqual(became, judge);
+  const kind = judge === undefined ? undefined : ("connection" in judge) ? "connection" : "harness";
+  if (named) {
+    conversion.notes.push(stays ? `workflow.judgeEngine: "${engine}" is the default ${kind}, where a gate's judge runs now; the setting is dropped.` : `workflow.judgeEngine${engine === undefined ? "" : ` "${engine}"`}: dropped. A gate's judge runs on the default connection, else the default harness, so a judge that ran on another engine has moved; to keep it, make that engine the default.`);
+  } else if (became !== undefined && judge !== undefined && !stays) {
+    conversion.notes.push(`workflow: with no workflow.judgeEngine, a gate's judge ran on the default engine "${engine}"; it is model work now and runs on the default ${kind}, "${"connection" in judge ? judge.connection : judge.harness}".`);
+  }
 }
 function convertIndexEngines(out, conversion, retarget) {
   const index = out.index;
@@ -32186,6 +32196,8 @@ function foldModelsOverlay(modelsOverlay, fold) {
   const writtenHarnesses = written.harnesses;
   const configNames = (own2, base, name, alias) => hasModel(own2[name], alias) || hasModel(base[name], alias);
   const platformOf = (name) => String((mergedHarnesses[name] ?? inheritedHarnesses[name])?.platform ?? name);
+  const columnOf = (name) => renamed.sdkHarness.includes(name) ? "opencode-sdk" : platformOf(name);
+  const notedOwn = new Set;
   let folded = false;
   for (const { alias, column, profile } of overlayRows(modelsOverlay)) {
     const p = typeof profile === "string" ? { model: profile } : isRecord(profile) ? profile : {};
@@ -32197,13 +32209,18 @@ function foldModelsOverlay(modelsOverlay, fold) {
       continue;
     }
     const candidates = column === "*" ? [...new Set([...Object.keys(mergedConnections), ...Object.keys(inheritedConnections)])] : column === "opencode-sdk" ? [...renamed.runtime] : renamed.connection(column) !== undefined ? [renamed.connection(column)] : (column in writtenConnections) || (column in inheritedConnections) ? [column] : [];
-    const harnessNamed = [...new Set([...Object.keys(mergedHarnesses), ...Object.keys(inheritedHarnesses)])].filter((name) => platformOf(name) === column);
+    const harnessNamed = [...new Set([...Object.keys(mergedHarnesses), ...Object.keys(inheritedHarnesses)])].filter((name) => columnOf(name) === column);
     if (candidates.length === 0 && harnessNamed.length === 0) {
       notes2.push(`${where}: names no configured connection or harness, so it is not carried over.`);
       continue;
     }
     const connectionNames = candidates.filter((name) => !configNames(writtenConnections, inheritedConnections, name, alias) && !(column === "*" && hasModel(mergedConnections[name], alias)));
-    const harnessNames = harnessNamed.filter((name) => !configNames(writtenHarnesses, inheritedHarnesses, name, alias));
+    const unnamed = harnessNamed.filter((name) => !configNames(writtenHarnesses, inheritedHarnesses, name, alias));
+    const harnessNames = unnamed.filter((name) => !ownModels.harnesses.has(name));
+    for (const name of unnamed.filter((n) => ownModels.harnesses.has(n) && !notedOwn.has(`${column}:${n}`))) {
+      notedOwn.add(`${column}:${name}`);
+      notes2.push(`models.json (${column === "*" ? "all" : column}): harness "${name}" has a model of its own, which names every alias, so the column is not carried over.`);
+    }
     if (connectionNames.length === 0 && harnessNames.length === 0) {
       const keptByConfig = candidates.some((name) => configNames(writtenConnections, inheritedConnections, name, alias)) || harnessNamed.some((name) => configNames(writtenHarnesses, inheritedHarnesses, name, alias));
       if (keptByConfig)
@@ -32263,15 +32280,23 @@ function implicitKeyVariables(name, defaults) {
   const own2 = `AKM_ENGINE_${name.toUpperCase().replaceAll("-", "_")}_API_KEY`;
   return name === str(defaults.llmEngine) ? [own2, "AKM_LLM_API_KEY"] : [own2];
 }
-function runtimeEngine(name, engine, converted, conversion) {
-  converted.runtimes.set(name, str(engine.llmEngine));
-  conversion.notes.push(`engines.${name}: opencode-sdk is akm's own runtime now, with no entry of its own; its model, timeout and workspace are dropped.`);
-}
-function agentEngineToHarness(name, engine, converted) {
-  const harness = { platform: engine.platform };
+function runtimeEngine(name, engine, llmEngine, converted, conversion) {
+  converted.runtimes.set(name, llmEngine);
+  const dropped = ["model", "timeoutMs", "workspace", "bin", "agent"].filter((key) => engine[key] !== undefined);
+  const gone = dropped.length === 0 ? "" : `; its ${dropped.join(", ")} ${dropped.length === 1 ? "is" : "are"} dropped`;
+  conversion.notes.push(`engines.${name}: opencode-sdk over llmEngine "${llmEngine}" is akm's own runtime over connection "${llmEngine}" now, with no entry of its own${gone}.`);
+}
+function agentEngineToHarness(name, engine, converted, conversion) {
+  const sdk = engine.platform === "opencode-sdk";
+  const harness = { platform: sdk ? "opencode" : engine.platform };
+  if (sdk)
+    converted.sdkHarnesses.add(name);
   for (const key of ["bin", "args", "workspace", "agent", "timeoutMs"])
-    if (engine[key] !== undefined)
+    if (engine[key] !== undefined && !(sdk && key === "args"))
       harness[key] = engine[key];
+  if (sdk && engine.args !== undefined) {
+    conversion.notes.push(`engines.${name}: args is dropped. 0.9 did not pass it to OpenCode, and the opencode harness would pass it in place of \`run\`.`);
+  }
   const model = str(engine.model);
   if (model !== undefined)
     converted.ownModelOf.push({ kind: "harnesses", engine: name, model });
@@ -32322,6 +32347,7 @@ function convertEngines(engines, defaults, env, conversion) {
     connections: {},
     harnesses: {},
     runtimes: new Map,
+    sdkHarnesses: new Set,
     keyHolders: [],
     ownModelOf: []
   };
@@ -32331,12 +32357,13 @@ function convertEngines(engines, defaults, env, conversion) {
     const unknown2 = Object.keys(engine).filter((k) => !(engine.kind === "agent" ? AGENT_ENGINE_KEYS : LLM_ENGINE_KEYS).has(k));
     if (unknown2.length > 0)
       conversion.notes.push(`engines.${name}: dropped ${unknown2.join(", ")}, which akm does not read.`);
+    const llmEngine = str(engine.llmEngine);
     if (engine.kind !== "agent")
       llmEngineToConnection(name, engine, defaults, env, converted, conversion);
-    else if (engine.platform === "opencode-sdk")
-      runtimeEngine(name, engine, converted, conversion);
+    else if (engine.platform === "opencode-sdk" && llmEngine !== undefined)
+      runtimeEngine(name, engine, llmEngine, converted, conversion);
     else
-      agentEngineToHarness(name, engine, converted);
+      agentEngineToHarness(name, engine, converted, conversion);
   }
   return converted;
 }
@@ -32354,11 +32381,21 @@ function renameMap(names, taken, from) {
   }
   return (name) => moved.get(name) ?? name;
 }
+function agentWorkMoved(defaultEngine, runtimes, harness) {
+  if (defaultEngine !== undefined) {
+    return runtimes.has(defaultEngine) && harness !== undefined ? `Agent work ran on akm's own runtime (engines.${defaultEngine}); with the harness "${harness}" configured it now runs there. Remove that harness to keep agent work on akm's runtime.` : undefined;
+  }
+  const ran = "Without defaults.engine, agent work ran on your own OpenCode (the implicit fallback), when it was installed";
+  return harness !== undefined ? `${ran}; with the harness "${harness}" configured it now runs there.` : `${ran}; it now runs on akm's own runtime. To keep it on your OpenCode, enable the harness: \`akm setup --harness opencode\`.`;
+}
 function nameDefaults(defaults, converted, conversion, written) {
-  const { connections, harnesses, runtimes, keyHolders } = converted;
-  const defaultEngine = str(defaults.engine);
+  const { connections, harnesses, runtimes, sdkHarnesses, keyHolders } = converted;
+  const implicit = sdkHarnesses.has(IMPLICIT_AGENT_ENGINE) || runtimes.has(IMPLICIT_AGENT_ENGINE);
+  const defaultEngine = str(defaults.engine) ?? (implicit ? IMPLICIT_AGENT_ENGINE : undefined);
+  const modelWorkEngine = str(defaults.llmEngine);
   const runtimeLlm = defaultEngine === undefined ? undefined : runtimes.get(defaultEngine);
-  const defaultConnection = [str(defaults.llmEngine), defaultEngine, runtimeLlm].find((n) => n !== undefined && (n in connections));
+  const modelWorkRuntimeLlm = modelWorkEngine === undefined ? undefined : runtimes.get(modelWorkEngine);
+  const defaultConnection = [modelWorkEngine, modelWorkRuntimeLlm, defaultEngine, runtimeLlm].find((n) => n !== undefined && (n in connections));
   const defaultHarness = defaultEngine !== undefined && defaultEngine in harnesses && Object.keys(harnesses).length > 1 ? defaultEngine : undefined;
   const connectionName = renameMap(Object.keys(connections), Object.keys(written.connections), defaultConnection);
   const harnessName = renameMap(Object.keys(harnesses), Object.keys(written.harnesses), defaultHarness);
@@ -32367,9 +32404,16 @@ function nameDefaults(defaults, converted, conversion, written) {
     connections: renamed(connections, connectionName),
     harnesses: renamed(harnesses, harnessName)
   };
-  const defaultHarnessName = "default" in named.harnesses ? "default" : Object.keys(named.harnesses).length === 1 ? Object.keys(named.harnesses)[0] : undefined;
-  if (defaultHarnessName !== undefined && (defaultEngine === undefined || runtimes.has(defaultEngine))) {
-    conversion.notes.push(`Agent work ran on akm's own runtime${defaultEngine === undefined ? "" : ` (engines.${defaultEngine})`}; with the harness "${defaultHarnessName}" configured it now runs there. Remove that harness to keep agent work on akm's runtime.`);
+  const defaultHarnessName = defaultName(named.harnesses);
+  const hasEngines = Object.keys(connections).length + Object.keys(harnesses).length + runtimes.size > 0;
+  const moved = hasEngines ? agentWorkMoved(defaultEngine, runtimes, defaultHarnessName) : undefined;
+  if (moved !== undefined)
+    conversion.notes.push(moved);
+  if (modelWorkEngine !== undefined && modelWorkEngine in harnesses) {
+    const now = harnessName(modelWorkEngine);
+    if (defaultName({ ...named.connections, ...written.connections }) !== undefined || defaultHarnessName !== now) {
+      conversion.notes.push(`defaults.llmEngine "${modelWorkEngine}" named an agent engine, which ran akm's model work. Model work now runs on the default connection, else the default harness; to keep it on the harness "${now}", set improve.harness to it.`);
+    }
   }
   for (const [kind, rename] of [
     ["connections", connectionName],
@@ -32381,10 +32425,9 @@ function nameDefaults(defaults, converted, conversion, written) {
     conversion.notes.push(`engines.default is now ${kind}.${aside}, and "default" names another engine: an engine: default key is rewritten by \`akm migrate apply\` where it can be, but a script or scheduled command that passes --engine default now reaches the new "default"; change it to the name ${aside}.`);
   }
   const target = (engine) => {
-    if (runtimes.has(engine)) {
-      const runtime = runtimes.get(engine);
-      return runtime !== undefined && runtime in connections ? { connection: connectionName(runtime) } : undefined;
-    }
+    const runtime = runtimes.get(engine);
+    if (runtime !== undefined)
+      return runtime in connections ? { connection: connectionName(runtime) } : undefined;
     if (engine in harnesses)
       return { harness: harnessName(engine) };
     if (engine in connections)
@@ -32396,7 +32439,7 @@ function nameDefaults(defaults, converted, conversion, written) {
     connection: connectionName(engine),
     field
   }));
-  return { defaultConnection, defaultHarness, connectionName, harnessName, ...named, keys, target };
+  return { defaultEngine, defaultConnection, defaultHarness, connectionName, harnessName, ...named, keys, target };
 }
 function mergeWritten(out, naming) {
   for (const [name, harness] of Object.entries(naming.harnesses)) {
@@ -32415,6 +32458,19 @@ function ownModelsOf(converted, naming) {
   }
   return ownModels;
 }
+function modelWorkTarget(defaults, naming, merged, inherited, conversion) {
+  const connection = defaultName({ ...inherited?.connections, ...merged.connections });
+  if (connection !== undefined)
+    return { connection };
+  const harness = defaultName({ ...inherited?.harnesses, ...merged.harnesses });
+  const entry = harness === undefined ? undefined : merged.harnesses[harness];
+  if (harness === undefined || !isRecord(entry))
+    return;
+  if (str(defaults.llmEngine) === undefined && harness in naming.harnesses && entry.modelWork === undefined) {
+    conversion.notes.push(`harnesses.${harness}: akm's own model work (improve, index passes, extraction, judges) now runs on this harness, the default for it with no connection. Without defaults.llmEngine, 0.9 ran none of it unless a setting named an engine (a workflow gate's judge ran on defaults.engine). To keep the 0.9 behaviour, set \`modelWork: false\` on this harness: a call that names it still runs there, but a workflow gate's judge then needs a connection (\`akm setup --endpoint URL\`).`);
+  }
+  return entry.modelWork === false ? undefined : { harness };
+}
 function convertEngineConfig(raw, options = {}) {
   const out = structuredClone(raw);
   const engines = asDict(out.engines);
@@ -32437,7 +32493,8 @@ function convertEngineConfig(raw, options = {}) {
     written: { connections: asDict(out.connections), harnesses: asDict(out.harnesses) },
     inherited: { connections: options.inherited?.connections ?? {}, harnesses: options.inherited?.harnesses ?? {} },
     renamed: {
-      runtime: [...converted.runtimes.values()].filter((name) => name !== undefined && (name in converted.connections)).map((name) => naming.connectionName(name)),
+      runtime: [...converted.runtimes.values()].filter((name) => (name in converted.connections)).map((name) => naming.connectionName(name)),
+      sdkHarness: [...converted.sdkHarnesses].map((name) => naming.harnessName(name)),
       connection: (engine) => (engine in converted.connections) ? naming.connectionName(engine) : undefined
     }
   });
@@ -32447,7 +32504,8 @@ function convertEngineConfig(raw, options = {}) {
   if (isRecord(improve))
     moveStrategyExecution(improve, conversion, retarget);
   improveStrategyDefault(out, defaults, improve);
-  dropJudgeEngine(out, conversion);
+  const judge = modelWorkTarget(defaults, naming, merged, options.inherited, conversion);
+  dropJudgeEngine(out, conversion, naming.target, naming.defaultEngine, judge);
   convertIndexEngines(out, conversion, retarget);
   const config2 = {};
   let placed = false;
@@ -32478,7 +32536,7 @@ function convertEngineConfig(raw, options = {}) {
     targets
   };
 }
-var LLM_ENGINE_KEYS, AGENT_ENGINE_KEYS, CARRIED;
+var LLM_ENGINE_KEYS, AGENT_ENGINE_KEYS, CARRIED, defaultName = (entries) => ("default" in entries) ? "default" : Object.keys(entries).length === 1 ? Object.keys(entries)[0] : undefined, IMPLICIT_AGENT_ENGINE = "opencode-sdk";
 var init_convert_engines = __esm(() => {
   init_common();
   init_convert_engine_references();
@@ -34567,6 +34625,27 @@ function isMarkdownFenceClosing(line, fence) {
     return false;
   return /^[\t ]*$/.test(line.slice(cursor));
 }
+function fencedCodeIdentifiers(line) {
+  const cleaned = line.replace(/(["'`])((?:\\.|(?!\1).)*)\1(\s*:)?/g, (match, _quote, body, colon, offset) => {
+    if (colon)
+      return /^\s*["'`]/.test(line.slice(offset + match.length)) ? ` ${body} ` : ` ${body}: `;
+    return /^\/[\w./-]+$/.test(body) ? ` ${body} ` : " ";
+  }).replace(/([A-Za-z_][A-Za-z0-9_.-]*\s*[:=]\s*)((?:[Bb]earer|[Bb]asic|[Tt]oken|[Dd]igest)\s+\S+|\S+)/g, (_match, name, value) => /^[!(]*[A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)+[()\]}]*[,;]?$/.test(value) ? `${name} ${value}` : name).replace(/(?<![\w.-])[A-Za-z0-9+/=]{20,}(?![\w.-])/g, (run) => /[a-z]/.test(run) && /[A-Z]/.test(run) && /\d/.test(run) ? " " : run);
+  const words = [];
+  for (let token of cleaned.match(/--?[A-Za-z][A-Za-z0-9-]*|[A-Za-z_][A-Za-z0-9_.-]*/g) ?? []) {
+    token = token.replace(/[.-]+$/, "");
+    const bare = token.replace(/^-+/, "");
+    if (bare.length < 2)
+      continue;
+    if (bare.length >= TOKEN_LIKE_MIN_LENGTH && /\d/.test(bare))
+      continue;
+    words.push(token);
+    const parts = bare.split(/[_.-]|(?<=[a-z0-9])(?=[A-Z])/).filter((part) => part.length > 1);
+    if (parts.length > 1)
+      words.push(...parts);
+  }
+  return words.join(" ");
+}
 function stripMarkdownHtmlComments(line, state) {
   let cursor = 0;
   let visible = "";
@@ -34732,6 +34811,7 @@ function projectMarkdownContent(body, truncationInfo) {
   const innerBlock = findInnerFrontmatterBlock(lines);
   const start = innerBlock && isFrontmatterShaped(lines, innerBlock) ? innerBlock.close + 1 : 0;
   const projected = [];
+  const fenced = [];
   forEachVisibleMarkdownLine(lines, start, (_index, visible) => {
     let trimmed = visible.trim();
     if (!trimmed || /^(-{3,}|\*{3,}|_{3,}|=+)$/.test(trimmed))
@@ -34749,15 +34829,19 @@ function projectMarkdownContent(body, truncationInfo) {
     trimmed = trimmed.replace(/\s+/g, " ").trim();
     if (trimmed)
       projected.push(trimmed);
+  }, (_index, fencedLine) => {
+    const identifiers = fencedCodeIdentifiers(fencedLine);
+    if (identifiers)
+      fenced.push(identifiers);
   });
-  const text2 = projected.join(" ").replace(/\s+/g, " ").trim();
+  const text2 = [...projected, ...fenced].join(" ").replace(/\s+/g, " ").trim();
   if (!text2)
     return;
   if (truncationInfo)
     truncationInfo.truncated = text2.length > MARKDOWN_CONTENT_MAX_CHARS;
   return truncateUnicodeSafe(text2, MARKDOWN_CONTENT_MAX_CHARS);
 }
-function forEachVisibleMarkdownLine(lines, start, visit3) {
+function forEachVisibleMarkdownLine(lines, start, visit3, visitFenced) {
   let fence;
   const htmlComment = { inComment: false };
   for (let index = start;index < lines.length; index += 1) {
@@ -34765,6 +34849,8 @@ function forEachVisibleMarkdownLine(lines, start, visit3) {
     if (fence) {
       if (isMarkdownFenceClosing(rawLine, fence))
         fence = undefined;
+      else
+        visitFenced?.(index, rawLine);
       continue;
     }
     const leadingFence = htmlComment.inComment ? undefined : parseMarkdownFenceOpening(rawLine);
@@ -34935,7 +35021,7 @@ function extractDirTagsFromName(name) {
   }
   return Array.from(tags);
 }
-var SCOPE_KEYS, KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, COMMENT_TAGS, MARKDOWN_CONTENT_MAX_CHARS = 1e6, MAX_MARKDOWN_LINK_NESTING = 32, markdownFragmentContentByEntry, markdownFragmentProjectionEntries;
+var SCOPE_KEYS, KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, COMMENT_TAGS, MARKDOWN_CONTENT_MAX_CHARS = 1e6, TOKEN_LIKE_MIN_LENGTH = 20, MAX_MARKDOWN_LINK_NESTING = 32, markdownFragmentContentByEntry, markdownFragmentProjectionEntries;
 var init_metadata = __esm(() => {
   init_asset_ref();
   init_frontmatter();

package/dist/sources/providers/git-provider.js

@@ -154,10 +154,8 @@ function hasExtractedRepo(repoDir) {
     try {
         if (!fs.statSync(repoDir).isDirectory())
             return false;
-        // WI-3.1: the "any type dir present" test is now sourced from the `akm`
-        // adapter's directoryList() — behavior-identical to the placement
-        // stash-subdir names, with `stashDirNames()` kept live as the fallback. The
-        // content/ subdir check above is preserved verbatim.
+        // The "any type dir present" test is sourced from the `akm`
+        // adapter's directoryList(), with `stashDirNames()` as the fallback.
         const ownedDirs = akmAdapter.directoryList?.({ id: "akm", adapter: "akm", root: repoDir, writable: false }) ?? stashDirNames();
         return ownedDirs.some((dirName) => fs.existsSync(path.join(repoDir, dirName)));
     }

package/dist/sources/providers/provider-utils.js

@@ -37,22 +37,16 @@ function looksLikeAnyBundleRoot(root) {
 }
 /**
  * Find the directory inside `extractedDir` that should be treated as the
- * bundle/stash root. Probes the top-level dir via the ordered §1.2 registry
+ * bundle/stash root. Probes the top-level dir via the ordered registry
  * probe; if nothing claims it, BFS for the shallowest nested candidate.
  */
 export function detectStashRoot(extractedDir) {
     const root = path.resolve(extractedDir);
-    // WI-3.1 → wired to the static registry: the top-level root check now routes
-    // through the ordered §1.2 `looksLikeRoot` probe over ALL built-in adapters
-    // (`registry.getAdapters()`), not the single hardcoded `akm` probe. This is
-    // BEHAVIOR-IDENTICAL for akm roots — `akm.looksLikeRoot` reproduces the former
-    // `.stash`-marker + immediate-stash-subdir (`hasStashDirs`) checks VERBATIM
-    // (akm-adapter.looksLikeRoot) and `akm` is in the probe set — so those two
-    // local checks are now subsumed and were removed. It additionally recognizes
-    // NON-akm bundle roots (okf root index / llm-wiki / `.claude` / …) at the top
-    // level, which the single-adapter probe missed but the old final `return root`
-    // fallback also happened to yield. The shallowest-BFS nested-layout discovery
-    // is unchanged.
+    // The top-level root check routes through the ordered `looksLikeRoot` probe
+    // over ALL built-in adapters (`registry.getAdapters()`). `akm.looksLikeRoot`
+    // covers the `.stash` marker and immediate stash subdirs; the other adapters
+    // recognize NON-akm bundle roots (okf root index / llm-wiki / `.claude` / …).
+    // Otherwise fall through to the shallowest-BFS nested-layout discovery.
     if (looksLikeAnyBundleRoot(root)) {
         return root;
     }
@@ -161,7 +155,8 @@ function countStashDirs(dirPath) {
  * (scripts/, skills/, etc.), so nested layouts like `project/my-stash/scripts/`
  * are discovered even without a `.stash` marker.
  *
- * Skips `root` itself since the caller already checked it via `hasStashDirs`.
+ * Skips `root` itself since the caller already checked it via
+ * `looksLikeAnyBundleRoot`.
  */
 const BFS_MAX_DEPTH = 5;
 function findShallowestStashRoot(root) {

package/dist/sources/snapshot-fetchers/website-ingest.js

@@ -90,7 +90,7 @@ export async function ensureWebsiteMirror(config, options) {
                 crawlTimeoutMs: resolveCrawlTimeoutMs(config.options?.crawlTimeoutMs),
                 resolveSecret: options?.resolveSecret,
                 // As-supplied, pre-normalization start URL (see crawlWebsite's
-                // `rawStartUrl` doc comment): threaded through purely for the C-02
+                // `rawStartUrl` doc comment): threaded through purely for the start-URL
                 // robots.txt check, which must see the trailing slash the user
                 // actually typed before `normalizeSiteUrl` strips it.
                 rawStartUrl: rawUrl,
@@ -461,7 +461,7 @@ async function resolveCrawlRobotsDecision(robots, normalizedUrl, rawUrl) {
 /**
  * Fail fast, before any page fetch, when the start URL itself is
  * off-limits per an actually-parsed robots.txt rule. A 5xx on robots.txt
- * itself no longer reaches this as `disallowAll`: `loadRobotsTxt` reports it the same way a
+ * itself does not reach this as `disallowAll`: `loadRobotsTxt` reports it the same way a
  * 4xx is reported (`ALLOW_ALL_RULES`), with its own warning, rather than
  * treating the site's own transient error as a Disallow. The check below
  * stays as defense-in-depth for a `RobotsPolicy` built over some other
@@ -594,7 +594,7 @@ async function crawlWebsite(startUrl, options) {
     }
     // Counts actual `fetchWebsitePage` invocations (regardless of outcome) so
     // Crawl-delay pacing skips the first fetch and never charges a delay slot
-    // to a URL that robots.txt skipped without ever being fetched (C-11).
+    // to a URL that robots.txt skipped without ever being fetched.
     let fetchAttempts = 0;
     // URLs pushed back because their Crawl-delay would not fit in the remaining
     // budget, and URLs that ran out of retries entirely. Reported at the end so
@@ -827,8 +827,7 @@ async function fetchWebsiteResponse(pageUrl, redirectCount = 0, options) {
                 // origin is the literal string "null", and re-resolving against it
                 // throws an unhandled TypeError that aborts the whole crawl. Refuse
                 // the hop outright instead of ever handing such a URL to the policy —
-                // `fetchWebsitePage` maps this to a graceful skip. Regression
-                // introduced by a67412c, which fell back to the raw `nextUrl` here.
+                // `fetchWebsitePage` maps this to a graceful skip.
                 warnVerbose("[akm] website crawl: skipping redirect to %s (not an http(s) URL)", nextUrl);
                 throw new RobotsDisallowedRedirectError(nextUrl);
             }
@@ -990,7 +989,7 @@ export function parseLlmsTxtLinks(text, baseUrl) {
  * content legitimately contains `##` headings too — so recovered page
  * boundaries can't be trusted, whereas per-page fetches through the existing
  * pipeline are cheap, bounded by this author-curated list, and produce
- * cleanly addressable assets. See the issue's "alternatives considered".
+ * cleanly addressable assets.
  */
 async function fetchLlmsManifest(start, robots, options) {
     const manifestUrl = new URL("/llms.txt", start.origin).toString();
@@ -1043,7 +1042,7 @@ function normalizeCrawlUrl(rawUrl) {
     }
 }
 /**
- * D-R6: `index.md`/`log.md` are OKF reserved structural filenames at every
+ * `index.md`/`log.md` are OKF reserved structural filenames at every
  * depth — no adapter indexes them, so a crawled page must never land on one.
  * Same remap convention as the content migration (`index.md` →
  * `index-content.md`). Segments are already lowercased by slugifySegment.

package/dist/storage/repositories/events-repository.js

@@ -147,3 +147,18 @@ export function purgeOldEvents(db, retentionDays = 90) {
     const changes = result.changes ?? 0;
     return typeof changes === "bigint" ? Number(changes) : changes;
 }
+/**
+ * Rewrite every `events.ref` naming `oldBundleId` to `newBundleId` (`akm bundle
+ * rename`). Improve reads an asset's feedback events by this ref, and
+ * `insertEventOnce` finds a journal event by it under the proposal or workflow
+ * ref the rename also rewrites, so an event left under the old prefix stops
+ * counting for the renamed bundle. A legacy unqualified ref is not matched by
+ * the `<old>//` prefix and is left alone; refs inside `metadata_json` are
+ * history and stay as written. Returns the number of rows rewritten.
+ */
+export function renameEventRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${oldBundleId}//`;
+    return Number(db
+        .prepare(`UPDATE events SET ref = ? || substr(ref, length(?) + 1) WHERE substr(ref, 1, length(?)) = ?`)
+        .run(newBundleId, oldBundleId, prefix, prefix).changes);
+}

package/dist/storage/repositories/improve-ledger-repository.js

@@ -269,3 +269,16 @@ export function listImproveLedgerRows(db, stashDir, sources) {
         .all(stashDir, ...(sources && sources.length > 0 ? sources : []));
     return rows.map((row) => toRow(withHash ? row : { ...row, content_hash: null }));
 }
+/**
+ * Rewrite every `improve_ledger.ref` naming `oldBundleId` to `newBundleId`
+ * (`akm bundle rename`), so improve keeps the renamed bundle's attempts and
+ * back-off windows next to its feedback events. A row already at the new key
+ * can only be an orphan of a removed bundle by that name; the renamed bundle's
+ * row replaces it. Returns the number of rows rewritten.
+ */
+export function renameImproveLedgerRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${oldBundleId}//`;
+    return Number(db
+        .prepare(`UPDATE OR REPLACE improve_ledger SET ref = ? || substr(ref, length(?) + 1) WHERE substr(ref, 1, length(?)) = ?`)
+        .run(newBundleId, oldBundleId, prefix, prefix).changes);
+}

package/dist/storage/repositories/index-entries-repository.js

@@ -18,6 +18,7 @@ import { getStateDbPath, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { getMarkdownFragmentContent, hasMarkdownFragmentContent, } from "../../indexer/passes/metadata.js";
 import { buildSearchText } from "../../indexer/search/search-fields.js";
+import { capEmbeddingText, DEFAULT_MAX_INPUT_TOKENS } from "../../llm/embedders/remote.js";
 import { sha256Hex } from "../../runtime.js";
 import { ENTRY_COLUMNS, rowToIndexedEntry } from "./index-entry-mapper.js";
 import { deleteFtsEntries, replaceFtsEntry } from "./index-fts-repository.js";
@@ -26,13 +27,21 @@ import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
 import { deleteEntryVectors } from "./index-vec-repository.js";
 // ── Entry operations ────────────────────────────────────────────────────────
 /**
- * Hash of the text an entry's vector is embedded from (`buildSearchText`),
- * stored as `entries.embed_hash`: a change deletes the entry's vector, and the
- * next embedding pass re-embeds it.
+ * Hash of an entry's whole search text (`buildSearchText`), stored as
+ * `entries.embed_hash`: text that hashes the same cannot change what the
+ * entry's vector is embedded from.
  */
 function embedHash(entry) {
     return sha256Hex(buildSearchText(entry));
 }
+/**
+ * The text an entry's vector is embedded from: its search text cut to the
+ * embedding cap (`embedding.maxInputTokens`). Text past the cut never reaches
+ * the embedder, so a change there leaves the vector as it is.
+ */
+function embeddedInput(entry, maxInputTokens) {
+    return capEmbeddingText(buildSearchText(entry), maxInputTokens).text;
+}
 /**
  * Insert or update one canonical entry and all synchronously derived search
  * state. Returns the stable row id.
@@ -40,8 +49,13 @@ function embedHash(entry) {
  * The entries row, FTS projection, declared links, and stale-vector
  * invalidation commit as one SQLite transaction. Callers therefore cannot
  * publish an entry and forget a second FTS or links maintenance step.
+ *
+ * The entry's vector is deleted when the text it is embedded from changes,
+ * that is when the search text cut to `maxInputTokens` (the embedding cap,
+ * `embedding.maxInputTokens`) differs from the cut of the stored document. A
+ * change past the cut rewrites the keyword rows and keeps the vector.
  */
-export function upsertEntry(db, filePath, entry, provenance, contentHash) {
+export function upsertEntry(db, filePath, entry, provenance, contentHash, maxInputTokens = DEFAULT_MAX_INPUT_TOKENS) {
     // Hot path during indexing — cache prepared statements per database
     // connection so we don't pay the SQL parse/compile cost on every call.
     const stmts = getUpsertStmts(db);
@@ -54,10 +68,14 @@ export function upsertEntry(db, filePath, entry, provenance, contentHash) {
     // writer's current value.
     const apply = () => {
         const previous = stmts.findByItemRef.get(provenance.itemRef);
+        // Decided before the upsert overwrites the stored document it compares against.
+        const vectorStale = previous != null &&
+            previous.embed_hash !== hash &&
+            !storedDocumentEmbedsAs(stmts, previous, embeddedInput(entry, maxInputTokens), maxInputTokens);
         const result = stmts.upsert.get(provenance.itemRef, provenance.bundleId, provenance.componentId, provenance.conceptId, provenance.adapterId, entry.type, filePath, contentHash ?? null, JSON.stringify(entry), derivedFrom, hash);
         if (!result)
             throw new Error("upsertEntry: item_ref not found after upsert");
-        if (previous?.id === result.id && previous.embed_hash !== hash)
+        if (previous?.id === result.id && vectorStale)
             deleteEntryVectors(db, result.id);
         replaceFtsEntry(db, result.id, entry, hasMarkdownFragmentContent(entry) ? (getMarkdownFragmentContent(entry) ?? null) : undefined);
         replaceEntryLinks(db, result.id, entry, provenance);
@@ -69,6 +87,25 @@ export function upsertEntry(db, filePath, entry, provenance, contentHash) {
     // partial entries row through its outer transaction.
     return db.transaction(apply)();
 }
+/**
+ * Whether the stored document of `previous` embeds as `input`. The stored
+ * document is what the entry's current vector was embedded from, so the
+ * previous input is derived from it and needs no column of its own. The stored
+ * hash vouches for that: a document that cannot be read, or whose search text
+ * no longer hashes to `embed_hash`, has no known input, and its vector goes.
+ */
+function storedDocumentEmbedsAs(stmts, previous, input, maxInputTokens) {
+    const row = stmts.documentById.get(previous.id);
+    if (!row)
+        return false;
+    try {
+        const text = buildSearchText(JSON.parse(row.document_json));
+        return sha256Hex(text) === previous.embed_hash && capEmbeddingText(text, maxInputTokens).text === input;
+    }
+    catch {
+        return false;
+    }
+}
 const upsertStmtsByDb = new WeakMap();
 // item_ref is the sole durable conflict target. `content_hash` COALESCEs so
 // an upsert that omits it (`contentHash` is optional) cannot wipe a scan hash.
@@ -101,6 +138,7 @@ function getUpsertStmts(db) {
       RETURNING id
     `),
         findByItemRef: db.prepare("SELECT id, embed_hash FROM entries WHERE item_ref = ?"),
+        documentById: db.prepare("SELECT document_json FROM entries WHERE id = ?"),
     };
     upsertStmtsByDb.set(db, stmts);
     return stmts;

package/dist/storage/repositories/outcome-repository.js

@@ -118,3 +118,15 @@ export function countAssetOutcomeMissing(db) {
     const row = db.prepare(`SELECT COUNT(*) AS n FROM asset_outcome WHERE missing_since IS NOT NULL`).get();
     return row.n;
 }
+/**
+ * Rewrite every `asset_outcome.asset_ref` naming `oldBundleId` to
+ * `newBundleId` (`akm bundle rename`). Same prefix match and orphan-replacing
+ * collision policy as `renameAssetSalienceRefs`. Returns the number of rows
+ * rewritten.
+ */
+export function renameAssetOutcomeRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${oldBundleId}//`;
+    return Number(db
+        .prepare(`UPDATE OR REPLACE asset_outcome SET asset_ref = ? || substr(asset_ref, length(?) + 1) WHERE substr(asset_ref, 1, length(?)) = ?`)
+        .run(newBundleId, oldBundleId, prefix, prefix).changes);
+}

package/dist/storage/repositories/proposals-repository.js

@@ -504,8 +504,8 @@ export function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
  * rename --dry-run`: the same two `WHERE` predicates, read-only.
  */
 export function countProposalsForBundleRename(db, oldBundleId) {
-    const prefix = `${escapeLikePattern(oldBundleId)}//`;
-    const refs = db.prepare(`SELECT COUNT(*) AS n FROM proposals WHERE ref LIKE ? ESCAPE '\\'`).get(`${prefix}%`).n;
+    const prefix = `${oldBundleId}//`;
+    const refs = db.prepare(`SELECT COUNT(*) AS n FROM proposals WHERE substr(ref, 1, length(?)) = ?`).get(prefix, prefix).n;
     const targets = db
         .prepare(`SELECT COUNT(*) AS n FROM proposals WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)
         .get(oldBundleId).n;
@@ -522,11 +522,11 @@ export function countProposalsForBundleRename(db, oldBundleId) {
  * rewritten.
  */
 export function renameProposalsBundleRef(db, oldBundleId, newBundleId) {
-    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    const prefix = `${oldBundleId}//`;
     return db.transaction(() => {
         const refs = Number(db
-            .prepare(`UPDATE proposals SET ref = ? || substr(ref, length(?) + 1) WHERE ref LIKE ? ESCAPE '\\'`)
-            .run(newBundleId, oldBundleId, `${prefix}%`).changes);
+            .prepare(`UPDATE proposals SET ref = ? || substr(ref, length(?) + 1) WHERE substr(ref, 1, length(?)) = ?`)
+            .run(newBundleId, oldBundleId, prefix, prefix).changes);
         const targets = Number(db
             .prepare(`UPDATE proposals SET metadata_json = json_set(metadata_json, '$.proposedTarget.source', ?)
            WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)

package/dist/storage/repositories/salience-repository.js

@@ -153,3 +153,16 @@ export function countAssetSalienceMissing(db) {
     const row = db.prepare(`SELECT COUNT(*) AS n FROM asset_salience WHERE missing_since IS NOT NULL`).get();
     return row.n;
 }
+/**
+ * Rewrite every `asset_salience.asset_ref` naming `oldBundleId` to
+ * `newBundleId` (`akm bundle rename`). A legacy unqualified ref is not matched
+ * by the `<old>//` prefix and is left alone. A row already at the new ref can only
+ * be an orphan of a removed bundle by that name; the renamed bundle's row
+ * replaces it. Returns the number of rows rewritten.
+ */
+export function renameAssetSalienceRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${oldBundleId}//`;
+    return Number(db
+        .prepare(`UPDATE OR REPLACE asset_salience SET asset_ref = ? || substr(asset_ref, length(?) + 1) WHERE substr(asset_ref, 1, length(?)) = ?`)
+        .run(newBundleId, oldBundleId, prefix, prefix).changes);
+}