akm-cli 0.9.0-beta.36 → 0.9.0-beta.37

package/dist/commands/improve/improve.js

@@ -54,7 +54,7 @@ import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, filterProactiveDue, selectProact
 import { akmProcedural } from "./procedural.js";
 import { akmRecombine } from "./recombine.js";
 import { akmReflect } from "./reflect.js";
-import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, recordNoOp, resetConsecutiveNoOps, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
+import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, isContentEncodingRow, recordNoOp, resetConsecutiveNoOps, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
 // #607 Lock Decomposition: fine-grained per-process locks replace the single
 // `improve.lock`. Three independent locks allow concurrent improve runs when
 // they touch different subsystems (e.g. quick-shredder consolidate can run
@@ -2733,6 +2733,37 @@ async function runImprovePreparationStage(args) {
     const outcomeWeightEnabled = salienceConfig?.outcomeWeightEnabled === true;
     const salienceMap = new Map();
     const nowForSalience = Date.now();
+    // #644 — preserve content-derived encoding scores across runs.
+    //
+    // Before computing the salience vector, load each ref's stored encoding score
+    // and its provenance. When the stored row carries a genuine content-derived
+    // score (written by the distill path via `scoreEncodingSalience`), pass that
+    // value back in as `inputs.encodingSalience` so `computeSalience` does NOT fall
+    // back to the type-weight stub — keeping both the persisted `encoding_salience`
+    // AND the derived `rank_score` keyed on real novelty/magnitude/prediction-error.
+    // Refs that have never been content-scored keep the type-weight stub fallback.
+    const storedEncodingByRef = new Map();
+    {
+        let dbForStoredEncoding;
+        try {
+            dbForStoredEncoding = openStateDatabase(eventsCtx?.dbPath);
+            for (const r of mergedRefs) {
+                const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
+                const row = getAssetSalience(dbForStoredEncoding, r.ref);
+                if (row && isContentEncodingRow(row, type)) {
+                    storedEncodingByRef.set(r.ref, row.encoding_salience);
+                }
+            }
+        }
+        catch (err) {
+            rethrowIfTestIsolationError(err);
+            // best-effort: if DB unavailable, fall back to type-weight stub (prior behaviour)
+        }
+        finally {
+            if (dbForStoredEncoding)
+                dbForStoredEncoding.close();
+        }
+    }
     for (const r of mergedRefs) {
         const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
         const sizeBytes = (() => {
@@ -2746,9 +2777,13 @@ async function runImprovePreparationStage(args) {
                 return undefined;
             }
         })();
+        const storedEncoding = storedEncodingByRef.get(r.ref);
         const vector = computeSalience({
             ref: r.ref,
             type,
+            // #644: pass the stored content-derived score (if any) so the type-weight
+            // stub is NOT re-asserted over a real distill-written encoding score.
+            ...(storedEncoding !== undefined ? { encodingSalience: storedEncoding } : {}),
             retrievalFreq: retrievalCounts.get(r.ref) ?? 0,
             lastUseMs: lastUseMsByRef.get(r.ref),
             utilityScore: utilityMap.get(r.ref),

package/dist/commands/improve/salience.js

@@ -126,6 +126,7 @@ export function computeSalience(inputs) {
     // Fall back to the type-importance stub only when the caller has not yet
     // computed a content-based score (e.g. on older assets before the first
     // staleness refresh runs).
+    const encodingSource = inputs.encodingSalience !== undefined ? "content" : "type-stub";
     const encoding = inputs.encodingSalience !== undefined
         ? Math.min(1, Math.max(0, inputs.encodingSalience))
         : (DEFAULT_TYPE_ENCODING_WEIGHTS[inputs.type] ?? DEFAULT_ENCODING_SALIENCE);
@@ -213,24 +214,75 @@ export function computeSalience(inputs) {
     }
     const rawRankScore = (we * encoding + wo * outcome + wr * retrieval) * sizePenalty;
     const rankScore = Math.min(1, Math.max(0, rawRankScore));
-    return { encoding, outcome, retrieval, rankScore };
+    return { encoding, outcome, retrieval, rankScore, encodingSource };
+}
+/**
+ * Does this row carry a genuine content-derived `encoding_salience` (#644)?
+ *
+ * Returns true when the provenance flag is `"content"`. For legacy rows
+ * (`encoding_source === null`, written before migration 015) we apply a
+ * conservative heuristic: treat the stored value as content-derived only when it
+ * does NOT equal the pure type-weight stub for the asset's type — because before
+ * the #644 fix every run overwrote real scores with the stub, a value that still
+ * differs from the stub must have been content-written and never re-clobbered.
+ * When the type cannot be determined (no `type` given) a null-provenance row is
+ * treated as a stub (the safe default).
+ */
+export function isContentEncodingRow(row, type) {
+    if (row.encoding_source === "content")
+        return true;
+    if (row.encoding_source === "type-stub")
+        return false;
+    // Legacy NULL provenance: differ-from-stub heuristic.
+    if (!type)
+        return false;
+    const stub = DEFAULT_TYPE_ENCODING_WEIGHTS[type] ?? DEFAULT_ENCODING_SALIENCE;
+    return Math.abs(row.encoding_salience - stub) > 1e-9;
 }
 /**
  * Upsert salience scores for one asset into state.db.
  *
- * Idempotent: safe to call every run; updates all columns on conflict.
+ * Idempotent: safe to call every run; updates the outcome / retrieval / rank
+ * columns on conflict.
+ *
+ * #644 — encoding provenance guard: the `encoding_salience` + `encoding_source`
+ * columns are NOT lowered from a real content-derived score to a type-weight
+ * stub. When the stored row is `encoding_source = 'content'` and the incoming
+ * vector is a `type-stub` fallback, the stored encoding score and its provenance
+ * are preserved (only the other sub-scores and `rank_score` advance). A `content`
+ * write always wins; a `type-stub` write only seeds a row that has no content
+ * score yet. This stops the improve loop's type-weight fallback re-asserting the
+ * stub over a distill-written score on every run.
+ *
+ * NOTE: when the guard preserves the stored encoding score, the incoming
+ * `vector.rankScore` (computed from the stub encoding) is still written. Callers
+ * that want the rank_score to reflect the preserved content score should pass the
+ * stored content score back in as `inputs.encodingSalience` to `computeSalience`
+ * — which the improve loop does. The guard here is the defensive backstop.
  */
 export function upsertAssetSalience(db, ref, vector, now) {
     const ts = now ?? Date.now();
     db.prepare(`INSERT INTO asset_salience
-       (asset_ref, encoding_salience, outcome_salience, retrieval_salience, rank_score, consecutive_no_ops, updated_at)
-     VALUES (?, ?, ?, ?, ?, 0, ?)
+       (asset_ref, encoding_salience, outcome_salience, retrieval_salience, rank_score, consecutive_no_ops, updated_at, encoding_source)
+     VALUES (?, ?, ?, ?, ?, 0, ?, ?)
      ON CONFLICT(asset_ref) DO UPDATE SET
-       encoding_salience  = excluded.encoding_salience,
+       -- #644: never lower a real content-derived score to a type-weight stub.
+       -- Keep the stored encoding score + provenance when the stored row is
+       -- 'content' and the incoming write is a 'type-stub' fallback.
+       encoding_salience  = CASE
+         WHEN asset_salience.encoding_source = 'content' AND excluded.encoding_source = 'type-stub'
+           THEN asset_salience.encoding_salience
+           ELSE excluded.encoding_salience
+       END,
+       encoding_source    = CASE
+         WHEN asset_salience.encoding_source = 'content' AND excluded.encoding_source = 'type-stub'
+           THEN asset_salience.encoding_source
+           ELSE excluded.encoding_source
+       END,
        outcome_salience   = excluded.outcome_salience,
        retrieval_salience = excluded.retrieval_salience,
        rank_score         = excluded.rank_score,
-       updated_at         = excluded.updated_at`).run(ref, vector.encoding, vector.outcome, vector.retrieval, vector.rankScore, ts);
+       updated_at         = excluded.updated_at`).run(ref, vector.encoding, vector.outcome, vector.retrieval, vector.rankScore, ts, vector.encodingSource ?? "type-stub");
 }
 /**
  * Load the salience row for one asset, or undefined if not yet computed.
@@ -238,7 +290,7 @@ export function upsertAssetSalience(db, ref, vector, now) {
 export function getAssetSalience(db, ref) {
     const row = db
         .prepare(`SELECT asset_ref, encoding_salience, outcome_salience, retrieval_salience,
-              rank_score, consecutive_no_ops, updated_at
+              rank_score, consecutive_no_ops, updated_at, encoding_source
        FROM asset_salience WHERE asset_ref = ?`)
         .get(ref);
     // Bun SQLite returns null (not undefined) when no row found.

package/dist/core/state-db.js

@@ -791,6 +791,31 @@ const MIGRATIONS = [
         ON recombine_hypotheses(last_seen_at);
     `,
     },
+    // ── Migration 015 — asset_salience: encoding_source provenance column (#644) ──
+    //
+    // Records HOW the stored `encoding_salience` was derived so an improve run's
+    // type-weight fallback can no longer clobber a real content-derived score:
+    //
+    //   "content"   — written by the distill path from `scoreEncodingSalience`
+    //                 (novelty·0.40 + magnitude·0.35 + predictionError·0.25).
+    //   "type-stub" — written by `computeSalience`'s `DEFAULT_TYPE_ENCODING_WEIGHTS`
+    //                 fallback (no content-based score available for this ref yet).
+    //   NULL        — legacy row written before this migration; provenance unknown.
+    //                 Treated as a stub by readers UNLESS its stored value differs
+    //                 from the pure type-weight (best-effort heuristic for old data).
+    //
+    // Why a column rather than inference: before #644, every improve run overwrote
+    // the distill-written content score with the type-weight stub, so the stored
+    // value alone cannot distinguish a real score from a stub. The provenance flag
+    // is the single source of truth going forward; `upsertAssetSalience` refuses to
+    // lower a "content" row to a "type-stub" so the high-salience gate (#608) keys
+    // on genuine novelty/magnitude/prediction-error, not the asset type.
+    {
+        id: "015-asset-salience-encoding-source",
+        up: `
+      ALTER TABLE asset_salience ADD COLUMN encoding_source TEXT DEFAULT NULL;
+    `,
+    },
 ];
 /**
  * Apply every pending migration in a single transaction per migration.

package/dist/scripts/migrate-storage.js

@@ -9978,6 +9978,12 @@ var init_state_db = __esm(() => {
       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;
+    `
     }
   ];
 });

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

@@ -9108,6 +9108,12 @@ var MIGRATIONS = [
       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;
+    `
   }
 ];
 function runMigrations2(db) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.36",
+  "version": "0.9.0-beta.37",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [