akm-cli 0.10.261016-beta → 0.10.261018-beta

package/dist/core/bundle-rename.js

@@ -6,7 +6,9 @@
  * bundle's key. A bundle id is a mass identity prefix: every durable ref this
  * tool minted (`entries.item_ref`/`bundle_id`, `proposals.ref`, a pending
  * proposal's `proposedTarget.source`, a workflow task_history row's
- * `target_ref`, a `workflow_runs.workflow_ref`, `scheduler.enabled[].ref`) carries it, and a hand-edited
+ * `target_ref`, a `workflow_runs.workflow_ref`, a `usage_events.entry_ref`, an
+ * `events.ref`, an `asset_salience`/`asset_outcome` `asset_ref`, an
+ * `improve_ledger.ref`, `scheduler.enabled[].ref`) carries it, and a hand-edited
  * `bundles` key strands all of it (see `src/indexer/bundle-identity-guard.ts`
  * §11.5). This module is the rekey transaction that guard's docstring points
  * to.
@@ -20,17 +22,17 @@
  * `akm mv`/editing territory, not a config-identity rename. `--dry-run`
  * (and every real run) lists the indexed files that still spell the old
  * `<old>//` prefix so the operator can follow up.
- *
- * Left behind on purpose: `usage_events`/`asset_salience`/`asset_outcome`
- * keyed by the old bundle prefix (learned utility/outcome history) — outside
- * this item's scope; `warnOnBundleRenameDrift` already documents this class
- * of gap and `akm index --full` re-mints under the new id.
  */
 import fs from "node:fs";
+import { renameUsageEventRefs } from "../indexer/usage/usage-events.js";
 import { readLockfile, renameLockEntry } from "../integrations/lockfile.js";
+import { renameEventRefs } from "../storage/repositories/events-repository.js";
+import { renameImproveLedgerRefs } from "../storage/repositories/improve-ledger-repository.js";
 import { closeDatabase, openIndexDatabase, openReadonlyExistingDatabase, } from "../storage/repositories/index-connection.js";
 import { getFilePathsByBundle, renameEntriesBundleId } from "../storage/repositories/index-entries-repository.js";
+import { renameAssetOutcomeRefs } from "../storage/repositories/outcome-repository.js";
 import { countProposalsForBundleRename, renameProposalsBundleRef } from "../storage/repositories/proposals-repository.js";
+import { renameAssetSalienceRefs } from "../storage/repositories/salience-repository.js";
 import { countTaskHistoryTargetRefs, renameTaskHistoryTargetRefs, } from "../storage/repositories/task-history-repository.js";
 import { countWorkflowRunRefsForRename, renameWorkflowRunRefs } from "../storage/repositories/workflow-runs-repository.js";
 import { selectBackend } from "../tasks/backends/index.js";
@@ -262,12 +264,20 @@ export async function renameBundle(oldId, newId, options = {}, deps) {
         }
     }
     // State: proposals.ref, a pending proposal's proposedTarget.source,
-    // workflow task_history.target_ref, and workflow_runs.workflow_ref.
+    // workflow task_history.target_ref, workflow_runs.workflow_ref, and the
+    // learned history keyed by item ref: usage_events.entry_ref (search ranking
+    // counts feedback by it), events.ref and improve_ledger.ref (improve reads
+    // feedback and its own attempts by them), and asset_salience/asset_outcome.asset_ref.
     if (fs.existsSync(getStateDbPath())) {
         withStateDb((db) => {
             renameProposalsBundleRef(db, oldId, newId);
             renameTaskHistoryTargetRefs(db, oldId, newId);
             renameWorkflowRunRefs(db, oldId, newId);
+            renameUsageEventRefs(db, oldId, newId);
+            renameEventRefs(db, oldId, newId);
+            renameImproveLedgerRefs(db, oldId, newId);
+            renameAssetSalienceRefs(db, oldId, newId);
+            renameAssetOutcomeRefs(db, oldId, newId);
         });
     }
     // Scheduler: remove native rows still naming `<old>//` (see

package/dist/core/config/convert-engine-references.js

@@ -85,14 +85,30 @@ export function improveStrategyDefault(out, defaults, improve) {
     out.improve = { ...(isRecord(improve) ? improve : {}) };
     out.improve.strategy ??= defaults.improveStrategy;
 }
-/** `workflow.judgeEngine`: a gate's judge is the default connection or harness now. */
-export function dropJudgeEngine(out, conversion) {
+/**
+ * `workflow.judgeEngine`, else `defaults.engine`, is where 0.9 ran a gate's judge. It is model work now and runs where
+ * model work does, `judge`: the default connection, else the default harness. `workflow.judgeEngine` is dropped, and
+ * a note says whether the judge moves.
+ */
+export 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}".`);
+    }
 }
 /** `index.defaults.*` and `index.<pass>.engine`: `index.*` and `connection`; a harness cannot run an index pass. */
 export function convertIndexEngines(out, conversion, retarget) {

package/dist/core/config/convert-engines.js

@@ -55,17 +55,32 @@ function implicitKeyVariables(name, defaults) {
     return name === str(defaults.llmEngine) ? [own, "AKM_LLM_API_KEY"] : [own];
 }
 // ── engines → connections / harnesses ────────────────────────────────────────
-/** `engines.<name>` with `kind: "agent"` and `platform: "opencode-sdk"`: akm's own runtime has no entry of its own. */
-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.`);
+/**
+ * `engines.<name>` with `kind: "agent"` and `platform: "opencode-sdk"` over an `llmEngine`: OpenCode ran over
+ * akm's own connection, which is what akm's own runtime is now, so it has no entry of its own.
+ */
+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}.`);
 }
-/** `engines.<name>` with `kind: "agent"`, any other platform: `harnesses.<name>`. */
-function agentEngineToHarness(name, engine, converted) {
-    const harness = { platform: engine.platform };
+/**
+ * `engines.<name>` with `kind: "agent"`: `harnesses.<name>`. An `opencode-sdk` engine with no `llmEngine` ran the
+ * user's own OpenCode (provider, model and login from its configuration), which the `opencode` harness runs now.
+ */
+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);
+    // 0.9 started `opencode serve` without an engine's `args`; the harness would pass them in place of `run`.
     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 });
@@ -123,6 +138,7 @@ function convertEngines(engines, defaults, env, conversion) {
         connections: {},
         harnesses: {},
         runtimes: new Map(),
+        sdkHarnesses: new Set(),
         keyHolders: [],
         ownModelOf: [],
     };
@@ -132,12 +148,13 @@ function convertEngines(engines, defaults, env, conversion) {
         const unknown = Object.keys(engine).filter((k) => !(engine.kind === "agent" ? AGENT_ENGINE_KEYS : LLM_ENGINE_KEYS).has(k));
         if (unknown.length > 0)
             conversion.notes.push(`engines.${name}: dropped ${unknown.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;
 }
@@ -161,12 +178,37 @@ function renameMap(names, taken, from) {
     }
     return (name) => moved.get(name) ?? name;
 }
+/** The entry the loader reads as the default: the one called `default`, else the only one. */
+const defaultName = (entries) => "default" in entries ? "default" : Object.keys(entries).length === 1 ? Object.keys(entries)[0] : undefined;
+/**
+ * The engine 0.9 ran agent work on when `defaults.engine` named none and OpenCode was installed: the one called
+ * `opencode-sdk`, else a bare OpenCode of the user's own.
+ */
+const IMPLICIT_AGENT_ENGINE = "opencode-sdk";
+/**
+ * Where agent work ran when `defaults.engine` named no harness, if that is not where it runs now. A runtime was akm's
+ * own; with no `defaults.engine` it was the user's OpenCode, whenever it was installed.
+ */
+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\`.`;
+}
 /** `defaults.llmEngine`, else `defaults.engine`: that connection is `default`; `defaults.engine` naming one of several harnesses: that harness is. */
 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;
@@ -177,13 +219,18 @@ 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);
+    // `defaults.llmEngine` could name an agent engine, which then ran akm's model work; model work runs on the default
+    // connection, else the default harness, whichever engine that was.
+    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],
@@ -195,10 +242,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)
@@ -210,7 +256,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 };
 }
 /** What the file writes under `connections` / `harnesses` itself, read with the converted entries: the written entry wins field by field. */
 function mergeWritten(out, naming) {
@@ -230,6 +276,24 @@ function ownModelsOf(converted, naming) {
     }
     return ownModels;
 }
+/**
+ * Where a gate's judge and akm's other model work run now when nothing names a place: the default connection, else
+ * the default harness. With no `defaults.llmEngine`, 0.9 ran none of that work unless a setting named an engine, so
+ * a default harness that takes it now gets a note saying so and how to turn it off.
+ */
+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 undefined;
+    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 };
+}
 // ── the whole conversion ─────────────────────────────────────────────────────
 export function convertEngineConfig(raw, options = {}) {
     const out = structuredClone(raw);
@@ -254,8 +318,9 @@ export function convertEngineConfig(raw, options = {}) {
         inherited: { connections: options.inherited?.connections ?? {}, harnesses: options.inherited?.harnesses ?? {} },
         renamed: {
             runtime: [...converted.runtimes.values()]
-                .filter((name) => name !== undefined && name in converted.connections)
+                .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),
         },
     });
@@ -265,7 +330,8 @@ export 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);
     // Assemble, keeping the file's key order.
     const config = {};

package/dist/core/config/convert-models-overlay.js

@@ -44,6 +44,7 @@ function overlayRows(modelsOverlay) {
 /**
  * `models.json`: an alias is set by, nearest first, the config's own `models`, models.json's column for that
  * connection or harness, models.json's `*` column (and the flat shorthand, which is that), the engine's own model.
+ * The exception is a harness engine's own model: it ran when a request named none, so it stands over every column.
  */
 export function foldModelsOverlay(modelsOverlay, fold) {
     const { conversion, merged, written, inherited, ownModels, renamed } = fold;
@@ -57,6 +58,10 @@ export function foldModelsOverlay(modelsOverlay, fold) {
     /** Whether the config itself, the file or its base, already names a model for the alias. */
     const configNames = (own, base, name, alias) => hasModel(own[name], alias) || hasModel(base[name], alias);
     const platformOf = (name) => String((mergedHarnesses[name] ?? inheritedHarnesses[name])?.platform ?? name);
+    /** The column of models.json that named a harness: an `opencode-sdk` engine's was `opencode-sdk`, not its platform's. */
+    const columnOf = (name) => (renamed.sdkHarness.includes(name) ? "opencode-sdk" : platformOf(name));
+    /** Harnesses whose engine had a `model` of its own, which names every alias and so stands over the column (noted once each). */
+    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 : {};
@@ -76,7 +81,7 @@ export function foldModelsOverlay(modelsOverlay, fold) {
                     : 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) {
             notes.push(`${where}: names no configured connection or harness, so it is not carried over.`);
             continue;
@@ -84,7 +89,14 @@ export function foldModelsOverlay(modelsOverlay, fold) {
         // The config's own choice stands, and `*` leaves what an explicit column already set.
         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));
+        // The model a harness engine named is what ran when a request named none, and a harness runs its first model then,
+        // so it stands over the column, which would put the column's models first.
+        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}`);
+            notes.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) {
             // Only the config's own choice is worth a note; an explicit column that came first is the overlay's own.
             const keptByConfig = candidates.some((name) => configNames(writtenConnections, inheritedConnections, name, alias)) ||

package/dist/indexer/bundle-identity-guard.js

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * §11.5 bundle-rename startup guard.
+ * Bundle-rename startup guard.
  *
  * Renaming a workspace bundle id is a mass identity migration (every ref in the
  * bundle changes without any file moving) and MUST go through the
@@ -10,13 +10,13 @@
  * every ref-keyed state table atomically. If a user instead hand-edits the
  * `bundles` KEY in config.json, the durable index/state rows still carry the OLD
  * bundle prefix while the config names the NEW id. Silently re-minting fresh
- * state under the new id would strand the old rows; §11.5 requires we detect this
- * and refuse-or-warn.
+ * state under the new id would strand the old rows, so this guard detects it
+ * and warns.
  *
  * This guard implements the cheap heuristic form (WARN, never silently re-mint):
  * it compares the configured bundle ids against the DISTINCT `bundle_id`
- * (item_ref bundle prefix) values already persisted in the index — and, by
- * cutover construction, the same prefixes key the state.db usage/salience rows.
+ * (item_ref bundle prefix) values already persisted in the index — the same
+ * prefixes key the state.db usage/salience rows.
  * The hand-rename signature is: a configured bundle id with NO indexed rows
  * co-existing with indexed rows under a bundle id that is no longer configured.
  *
@@ -70,7 +70,7 @@ function indexedBundlePaths(dbPath) {
 }
 /**
  * Warn (once per process) when the config's bundle ids and the index's bundle
- * prefixes show the hand-rename signature (§11.5). No-op for an old-shape config
+ * prefixes show the hand-rename signature. No-op for an old-shape config
  * (no `bundles`), an absent/empty index, or when the guard already settled.
  */
 export function warnOnBundleRenameDrift(config = loadConfig()) {

package/dist/indexer/index-written-assets.js

@@ -31,7 +31,7 @@ import { warn, warnVerbose } from "../core/warn.js";
 import { closeDatabase, openExistingDatabase } from "../storage/repositories/index-connection.js";
 import { deleteEntriesByIds, getEntryCount, upsertEntry } from "../storage/repositories/index-entries-repository.js";
 import { deriveEntryProvenance, deriveInstallations } from "./installations.js";
-import { generateEmbeddingsForDb, publishTargetedEmbeddingMeta } from "./materialize-embeddings.js";
+import { embeddingInputCap, generateEmbeddingsForDb, publishTargetedEmbeddingMeta } from "./materialize-embeddings.js";
 import { withFileSize } from "./passes/metadata.js";
 import { drainDirDocuments } from "./scan/drain-dir.js";
 import { buildFileContext } from "./walk/file-context.js";
@@ -153,6 +153,7 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
             db.exec(`PRAGMA busy_timeout = ${WRITE_PATH_INDEX_BUSY_TIMEOUT_MS}`);
             if (getEntryCount(db) === 0)
                 return true;
+            const config = loadConfig();
             const targetEntryIds = new Set();
             let mutated = false;
             db.transaction(() => {
@@ -194,12 +195,11 @@ export async function indexWrittenAssets(stashDir, filePaths, options = {}) {
                         .prepare("SELECT id FROM entries WHERE file_path = ? AND item_ref <> ?")
                         .all(file, provenance.itemRef);
                     deleteEntriesByIds(db, supersededIds.map((row) => row.id));
-                    targetEntryIds.add(upsertEntry(db, file, entryWithSize, provenance, contentHash));
+                    targetEntryIds.add(upsertEntry(db, file, entryWithSize, provenance, contentHash, embeddingInputCap(config)));
                     mutated = true;
                 }
             })();
             if (mutated) {
-                const config = loadConfig();
                 await generateEmbeddingsForDb(db, config, () => { }, undefined, [...targetEntryIds]);
                 publishTargetedEmbeddingMeta(db, config);
             }

package/dist/indexer/indexer.js

@@ -28,9 +28,9 @@ import { assertIndexedWorkflowSourceIdentity, WorkflowSourceIdentityError } from
 import { reclassifyIndexDbContention } from "./index-db-contention.js";
 import { deriveEntryProvenance, deriveInstallations } from "./installations.js";
 import { indexedPathMatchesOwner, resolveConceptOwner } from "./lookup/adapter-concept-owner.js";
-import { generateEmbeddingsForDb } from "./materialize-embeddings.js";
+import { embeddingInputCap, generateEmbeddingsForDb } from "./materialize-embeddings.js";
 import { canUseIncrementalSkip, computeDirFingerprint, getCachedDirState, getDirIndexState, inferZeroRowReason, } from "./passes/dir-staleness.js";
-import { isWorkflowSkipWarning, withFileSize } from "./passes/metadata.js";
+import { CONTENT_PROJECTION_VERSION, isWorkflowSkipWarning, withFileSize, } from "./passes/metadata.js";
 import { drainDirDocuments } from "./scan/drain-dir.js";
 import { purgeOldUsageEvents, USAGE_EVENT_RETENTION_DAYS } from "./usage/usage-events.js";
 import { SEMANTIC_SEARCH_META_KEY, } from "./walk/index-context.js";
@@ -446,7 +446,7 @@ async function akmIndexReal(options) {
         // …then write it in one transaction: `item_ref = <bundle>//<conceptId>`
         // plus canonical component/adapter provenance per source root.
         const bundleByRoot = buildIndexedSourceOwners(sources);
-        persistDirRecords(db, dirRecords, warnings, bundleByRoot);
+        persistDirRecords(db, dirRecords, warnings, bundleByRoot, embeddingInputCap(config));
         onProgress({
             phase: "scan",
             message: `Scanned ${scannedDirs} ${scannedDirs === 1 ? "directory" : "directories"} and skipped ${skippedDirs}.`,
@@ -819,7 +819,9 @@ async function scanSourceDirs(db, allSourceEntries, isIncremental, builtAtMs, ha
             warn(`Skipping component "${component.id}": unknown adapter id "${component.adapter}".`);
             continue;
         }
-        const indexVariant = `${adapter.id}@${adapter.version}`;
+        // The content projection's version is part of the variant: a change to what Markdown bodies index re-projects
+        // every directory once instead of keeping the old text for unchanged files.
+        const indexVariant = `${adapter.id}@${adapter.version}+content${CONTENT_PROJECTION_VERSION}`;
         for (const removal of removals) {
             dirRecords.push(removal);
             scannedDirs++;
@@ -938,7 +940,7 @@ function requiresWorkflowSourcePreflight(ctxs) {
     });
 }
 /** Phase 2 (sync): write all pre-generated scan records inside a single transaction. */
-function persistDirRecords(db, dirRecords, warnings, bundleByRoot) {
+function persistDirRecords(db, dirRecords, warnings, bundleByRoot, maxInputTokens) {
     const deletedUsageEntryIds = new Set();
     const findPersisted = db.prepare("SELECT id, content_hash, file_path, adapter_id FROM entries WHERE item_ref = ?");
     const insertTransaction = db.transaction(() => {
@@ -1038,7 +1040,7 @@ function persistDirRecords(db, dirRecords, warnings, bundleByRoot) {
                     if (unchanged) {
                         continue;
                     }
-                    upsertEntry(db, entryPath, withFileSize(entry, entryPath), provenance, contentHash);
+                    upsertEntry(db, entryPath, withFileSize(entry, entryPath), provenance, contentHash, maxInputTokens);
                 }
             }
             // Prune the departed rows: everything under this dir NOT re-upserted above
@@ -1332,8 +1334,10 @@ export function recomputeUtilityScores(db, stateDb, onlyEntryId) {
     // (Chunk-8 WI-8.3); its table is created by state migration 020.
     if (!scoped)
         purgeOldUsageEvents(stateDb, USAGE_EVENT_RETENTION_DAYS);
-    // Time-proportional decay: apply one round of EMA per elapsed day so
-    // indexing frequency doesn't affect how fast scores decay.
+    // Decay is raised to the days since the last run, floored at one day. Every
+    // run therefore applies at least one full round of EMA decay (so runs less
+    // than a day apart each decay a full round), and a longer gap applies
+    // proportionally more rounds. The first run counts as one day.
     const lastComputedAt = getMeta(db, "last_utility_computed_at");
     let elapsedDays = 1; // default for first run
     if (lastComputedAt) {

package/dist/indexer/materialize-embeddings.js

@@ -32,6 +32,13 @@ export function deriveSemanticProviderFingerprint(embedding) {
     }
     return `local:${embedding?.localModel ?? DEFAULT_LOCAL_MODEL}${template}`;
 }
+/**
+ * The most estimated tokens of an entry's search text that are embedded
+ * (`embedding.maxInputTokens`); the rest of the text never reaches the embedder.
+ */
+export function embeddingInputCap(config) {
+    return effectiveEmbedding(config)?.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
+}
 /**
  * The heartbeat text emitted every 15s while a provider request is in
  * flight, and by default (not `--verbose`-only) since silence indistinguishable
@@ -103,7 +110,7 @@ export async function generateEmbeddingsForDb(db, config, onProgress, signal, en
     let targetEntryIds = entryIds;
     /** Set only when every entry is (re)embedded, so the up-front "Re-embedding N entries" line names why. */
     let rebuildReason;
-    const maxInputTokens = embedding?.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
+    const maxInputTokens = embeddingInputCap(config);
     if (opts?.forceReembed) {
         // The explicit operator override: purge and re-embed everything. The model
         // is recorded in the SAME transaction as the purge, before any embedding
@@ -171,9 +178,12 @@ export async function generateEmbeddingsForDb(db, config, onProgress, signal, en
             const message = `[embed] Re-embedding ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"} because ${rebuildReason}`;
             onProgress({ phase: "embeddings", message });
         }
+        // Names the size of the work before the first request, so a first index after an upgrade that
+        // re-embeds part of the corpus is not mistaken for a hang.
+        const unchangedCount = Math.max(0, getEmbeddableEntryCount(db) - pendingEntries.length);
         onProgress({
             phase: "embeddings",
-            message: `Generating embeddings for ${pendingEntries.length} entr${pendingEntries.length === 1 ? "y" : "ies"}.`,
+            message: `Embedding ${pendingEntries.length.toLocaleString()} changed entr${pendingEntries.length === 1 ? "y" : "ies"} (${unchangedCount.toLocaleString()} unchanged)`,
         });
         // Per-document sizes; the provider's actual request grouping is reported
         // per batch below (and each skipped document is listed at the end).