akm-cli 0.9.16 → 0.9.17-alpha.10

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

@@ -107,7 +107,7 @@ const GATE_OUTCOMES = {
     "auto-rejected": true,
 };
 function validatePresentMetadata(meta) {
-    const stringFields = ["sourceRun", "beforeHash", "backupContent"];
+    const stringFields = ["sourceRun", "beforeHash", "beforeHashNormalized", "backupContent"];
     for (const field of stringFields) {
         if (Object.hasOwn(meta, field) && typeof meta[field] !== "string")
             invalidPresentField(field);
@@ -168,6 +168,50 @@ function validatePresentMetadata(meta) {
     if (Object.hasOwn(meta, "eligibilitySource") && typeof meta.eligibilitySource !== "string") {
         invalidPresentField("eligibilitySource");
     }
+    if (Object.hasOwn(meta, "promotionSource") && typeof meta.promotionSource !== "string") {
+        invalidPresentField("promotionSource");
+    }
+    if (Object.hasOwn(meta, "promotionSourceHash") && typeof meta.promotionSourceHash !== "string") {
+        invalidPresentField("promotionSourceHash");
+    }
+    if (Object.hasOwn(meta, "retirement")) {
+        const retirement = meta.retirement;
+        if (typeof retirement !== "object" ||
+            retirement === null ||
+            typeof retirement.retiredRef !== "string" ||
+            typeof retirement.successorRef !== "string" ||
+            typeof retirement.cosine !== "number" ||
+            !Number.isFinite(retirement.cosine) ||
+            (retirement.judgeLabel !== "duplicate" &&
+                retirement.judgeLabel !== "subsumed" &&
+                retirement.judgeLabel !== "supersedes") ||
+            typeof retirement.judgeReason !== "string" ||
+            typeof retirement.retiredContentHash !== "string" ||
+            typeof retirement.successorContentHash !== "string" ||
+            (retirement.reason !== "duplicate" && retirement.reason !== "subsumed" && retirement.reason !== "superseded")) {
+            invalidPresentField("retirement");
+        }
+    }
+    if (Object.hasOwn(meta, "retiredArchive")) {
+        const archive = meta.retiredArchive;
+        if (typeof archive !== "object" ||
+            archive === null ||
+            !Array.isArray(archive.dirs) ||
+            archive.dirs.length === 0 ||
+            archive.dirs.some((dir) => typeof dir !== "string" || dir.length === 0)) {
+            invalidPresentField("retiredArchive");
+        }
+    }
+    if (Object.hasOwn(meta, "retireAcceptIntent")) {
+        const intent = meta.retireAcceptIntent;
+        if (typeof intent !== "object" ||
+            intent === null ||
+            typeof intent.assetPath !== "string" ||
+            intent.assetPath.length === 0 ||
+            typeof intent.backupContent !== "string") {
+            invalidPresentField("retireAcceptIntent");
+        }
+    }
 }
 /**
  * Convert a raw `ProposalRow` to the public `Proposal` shape.
@@ -224,6 +268,7 @@ export function proposalRowToProposal(row) {
         changes,
         ...(proposedTarget !== undefined ? { proposedTarget } : {}),
         ...(typeof meta.beforeHash === "string" ? { beforeHash: meta.beforeHash } : {}),
+        ...(typeof meta.beforeHashNormalized === "string" ? { beforeHashNormalized: meta.beforeHashNormalized } : {}),
         ...(meta.review !== undefined ? { review: meta.review } : {}),
         ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
         ...(meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {}),
@@ -232,6 +277,13 @@ export function proposalRowToProposal(row) {
         ...(typeof meta.eligibilitySource === "string"
             ? { eligibilitySource: meta.eligibilitySource }
             : {}),
+        ...(typeof meta.promotionSource === "string" ? { promotionSource: meta.promotionSource } : {}),
+        ...(typeof meta.promotionSourceHash === "string" ? { promotionSourceHash: meta.promotionSourceHash } : {}),
+        ...(meta.retirement !== undefined ? { retirement: meta.retirement } : {}),
+        ...(meta.retiredArchive !== undefined ? { retiredArchive: meta.retiredArchive } : {}),
+        ...(meta.retireAcceptIntent !== undefined
+            ? { retireAcceptIntent: meta.retireAcceptIntent }
+            : {}),
     };
 }
 /**
@@ -274,6 +326,8 @@ export function proposalToRowValues(proposal, stashDir) {
         metaObj.proposedTarget = currentProposalTarget(proposal.proposedTarget);
     if (proposal.beforeHash !== undefined)
         metaObj.beforeHash = proposal.beforeHash;
+    if (proposal.beforeHashNormalized !== undefined)
+        metaObj.beforeHashNormalized = proposal.beforeHashNormalized;
     if (proposal.sourceRun !== undefined)
         metaObj.sourceRun = proposal.sourceRun;
     if (proposal.review !== undefined)
@@ -288,6 +342,16 @@ export function proposalToRowValues(proposal, stashDir) {
         metaObj.acceptedTarget = proposal.acceptedTarget;
     if (proposal.eligibilitySource !== undefined)
         metaObj.eligibilitySource = proposal.eligibilitySource;
+    if (proposal.promotionSource !== undefined)
+        metaObj.promotionSource = proposal.promotionSource;
+    if (proposal.promotionSourceHash !== undefined)
+        metaObj.promotionSourceHash = proposal.promotionSourceHash;
+    if (proposal.retirement !== undefined)
+        metaObj.retirement = proposal.retirement;
+    if (proposal.retiredArchive !== undefined)
+        metaObj.retiredArchive = proposal.retiredArchive;
+    if (proposal.retireAcceptIntent !== undefined)
+        metaObj.retireAcceptIntent = proposal.retireAcceptIntent;
     validatePresentMetadata(metaObj);
     return {
         id: proposal.id,
@@ -382,6 +446,10 @@ export function getStateProposal(db, id, stashDir) {
     const row = (stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id));
     return row ? proposalRowToProposal(row) : undefined;
 }
+/** `(ref, source)` of every proposal, any status, in one stash: no payload is read. */
+export function listProposalRefSources(db, stashDir) {
+    return db.prepare("SELECT ref, source FROM proposals WHERE stash_dir = ?").all(stashDir);
+}
 /**
  * Find PENDING proposal ids in one stash whose id starts with `idPrefix`.
  * Backs the UUID-prefix form of `akm proposal show/accept/... <prefix>` —
@@ -399,3 +467,38 @@ export function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
         .all(stashDir, `${escaped}%`);
     return rows.map((r) => r.id);
 }
+/**
+ * Preview counterpart of {@link renameProposalsBundleRef} for `akm bundle
+ * 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 targets = db
+        .prepare(`SELECT COUNT(*) AS n FROM proposals WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)
+        .get(oldBundleId).n;
+    return { refs, targets };
+}
+/**
+ * Rewrite every proposal that names `oldBundleId` from `akm bundle rename`
+ * (D6): the fully-qualified `ref` column (`<bundle>//conceptId` — an
+ * unqualified legacy `ref` resolves against `defaultBundle` at use time and
+ * never names a bundle explicitly, so it is left alone), and
+ * `metadata_json.proposedTarget.source`, which names the write-target bundle
+ * a still-pending proposal would apply to (`resolveRecordedProposalTarget`,
+ * `commands/proposal/repository.ts`). Returns how many rows of each were
+ * rewritten.
+ */
+export function renameProposalsBundleRef(db, oldBundleId, newBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    return db.transaction(() => {
+        const refs = Number(db
+            .prepare(`UPDATE proposals SET ref = ? || substr(ref, ?) WHERE ref LIKE ? ESCAPE '\\'`)
+            .run(newBundleId, oldBundleId.length + 1, `${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') = ?`)
+            .run(newBundleId, oldBundleId).changes);
+        return { refs, targets };
+    })();
+}

package/dist/storage/repositories/registry-index-cache-repository.js

@@ -1,6 +1,10 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // 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/.
+import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { formatRegistryError } from "../../core/registry-url.js";
+import { warn } from "../../core/warn.js";
+import { closeDatabase, openIndexDatabase } from "./index-connection.js";
 /**
  * Upsert a registry index cache entry in index.db.
  *
@@ -44,3 +48,99 @@ export function getRegistryIndexCache(db, registryUrl, maxAgeMs = 3_600_000 /* 1
         return undefined;
     return { indexJson: row.index_json, etag: row.etag, lastModified: row.last_modified };
 }
+/**
+ * Open the cache DB (a failed open yields `db = undefined`; the bun-test
+ * isolation guard is re-thrown), run `fn`, and close the DB only after `fn`
+ * has fully settled — the callbacks are async, and closing earlier would tear
+ * the DB down mid-write.
+ */
+export async function withRegistryCacheDb(fn) {
+    let db;
+    try {
+        db = openIndexDatabase();
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        db = undefined;
+    }
+    try {
+        return await fn(db);
+    }
+    finally {
+        if (db) {
+            try {
+                closeDatabase(db);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+/**
+ * Returns a fresh cache hit when present, otherwise fetches live (writing the
+ * result back best-effort), and falls back to a stale cache row when the
+ * fetch fails.
+ */
+export async function fetchCachedJson(opts) {
+    const { cacheKey, ttlMs, parseCache, fetchFresh } = opts;
+    return withRegistryCacheDb(async (db) => {
+        let dbCacheResult;
+        try {
+            if (db) {
+                dbCacheResult = getRegistryIndexCache(db, cacheKey, ttlMs);
+            }
+        }
+        catch (err) {
+            // Never mask the bun-test isolation guard as "DB unavailable" — see
+            // rethrowIfTestIsolationError in src/core/errors.ts.
+            rethrowIfTestIsolationError(err);
+            // index.db read failed (pre-migration install or test env) — fall through
+        }
+        if (dbCacheResult) {
+            const cached = parseCache(dbCacheResult.indexJson, { stale: false });
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+        try {
+            const { value, cacheJson } = await fetchFresh();
+            if (db) {
+                try {
+                    upsertRegistryIndexCache(db, cacheKey, cacheJson);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            return value;
+        }
+        catch (err) {
+            // Fetch failed — use stale DB cache if available.
+            if (dbCacheResult) {
+                const stale = parseCache(dbCacheResult.indexJson, { stale: true });
+                if (stale !== undefined)
+                    return stale;
+            }
+            // No in-TTL row — consult the cache PAST its TTL before giving up: a
+            // briefly unreachable registry should degrade to the last-known index,
+            // loudly, not hard-fail the command.
+            try {
+                const expiredRow = db ? getRegistryIndexCache(db, cacheKey, Number.POSITIVE_INFINITY) : undefined;
+                if (expiredRow) {
+                    const stale = parseCache(expiredRow.indexJson, { stale: true });
+                    if (stale !== undefined) {
+                        warn(`Registry fetch failed (${formatRegistryError(err)}); ` +
+                            "serving the last cached index, which is past its refresh interval.");
+                        return stale;
+                    }
+                }
+            }
+            catch (cacheErr) {
+                rethrowIfTestIsolationError(cacheErr);
+                // cache read failed — fall through to the original fetch error
+            }
+            throw err;
+        }
+    });
+}

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

@@ -58,23 +58,6 @@ export function getAssetSalience(db, ref) {
     // Bun SQLite returns null (not undefined) when no row found.
     return row == null ? undefined : row;
 }
-/**
- * Load ALL rank scores from the asset_salience table (full-stash query).
- *
- * Used by the forgetting-safety report (plan §WS-1 step 7) to compute stash-wide
- * rank positions rather than pool-relative positions. Returns an empty Map when the
- * table is empty (first WS-1 run = no pre-existing rows).
- *
- * Order is unspecified; callers must sort before assigning 1-indexed positions.
- */
-export function getAllRankScores(db) {
-    const rows = db.prepare("SELECT asset_ref, rank_score FROM asset_salience").all();
-    const result = new Map();
-    for (const row of rows) {
-        result.set(row.asset_ref, row.rank_score);
-    }
-    return result;
-}
 // ── Plasticity helpers ────────────────────────────────────────────────────────
 /**
  * Increment `consecutive_no_ops` for an asset. Called after a no-op reflect/distill.
@@ -84,8 +67,7 @@ export function getAllRankScores(db) {
  * Invariant: recordNoOp must never originate rank_score semantics. If the asset has
  * no salience row yet (persistence's best-effort try/catch may have swallowed an
  * error), we do nothing — a no-op counter is meaningless without a rank_score row,
- * and a synthetic INSERT would fabricate a rank_score=0 entry that could produce
- * false catastrophic-forgetting signals in buildRankChangeReport.
+ * and a synthetic INSERT would fabricate a rank_score=0 entry with nothing behind it.
  */
 export function recordNoOp(db, ref) {
     db.prepare(`UPDATE asset_salience SET consecutive_no_ops = consecutive_no_ops + 1, updated_at = ? WHERE asset_ref = ?`).run(Date.now(), ref);

package/dist/storage/repositories/task-history-repository.js

@@ -11,6 +11,7 @@
  */
 import { isRecord } from "../../core/common.js";
 import { warnOnce } from "../../core/warn.js";
+import { escapeLikePattern } from "../like-pattern.js";
 function metadataError(message) {
     throw new Error(`invalid task_history metadata_json: ${message}`);
 }
@@ -63,9 +64,9 @@ export function decodeTaskHistoryMetadata(input) {
     if (typeof parsed.durationMs !== "number")
         metadataError("durationMs must be a number");
     const detail = "detail" in parsed ? parsed.detail : null;
-    if (parsed.engine !== undefined && parsed.engine !== null && typeof parsed.engine !== "string") {
-        metadataError("engine must be a string or null");
-    }
+    // A malformed `engine` (wrong type) is dropped like any other unrecognized
+    // field rather than rejecting the whole row over a non-essential value.
+    const engine = parsed.engine === null || typeof parsed.engine === "string" ? parsed.engine : undefined;
     if (parsed.targetVocab !== undefined && parsed.targetVocab !== 2) {
         warnOnce(`task-history-target-vocab:${String(parsed.targetVocab)}`, `task_history row has targetVocab ${String(parsed.targetVocab)}, newer than this akm's 2 — falling back to ` +
             "the legacy target_kind mapping rather than rejecting the row.");
@@ -83,7 +84,7 @@ export function decodeTaskHistoryMetadata(input) {
         metadataVersion: 2,
         durationMs: parsed.durationMs,
         detail: cleanDetail,
-        ...(parsed.engine !== undefined ? { engine: parsed.engine } : {}),
+        ...(engine !== undefined ? { engine } : {}),
         ...(parsed.targetVocab === 2 ? { targetVocab: 2 } : {}),
     };
 }
@@ -207,3 +208,24 @@ export function queryCompletedTaskIntervals(db, since, until) {
         : "SELECT started_at, completed_at FROM task_history WHERE task_id = 'akm-improve' AND started_at >= ? AND completed_at IS NOT NULL ORDER BY started_at";
     return (until ? db.prepare(sql).all(since, until) : db.prepare(sql).all(since));
 }
+/**
+ * Preview counterpart of {@link renameTaskHistoryTargetRefs} for `akm bundle
+ * rename --dry-run`: the same `WHERE` predicate, read-only.
+ */
+export function countTaskHistoryTargetRefs(db, oldBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    return db.prepare(`SELECT COUNT(*) AS n FROM task_history WHERE target_ref LIKE ? ESCAPE '\\'`).get(`${prefix}%`).n;
+}
+/**
+ * Rewrite every `task_history.target_ref` naming `oldBundleId` (a workflow
+ * run's fully-qualified `<bundle>//conceptId` target) to `newBundleId`
+ * (`akm bundle rename`, D6). A row whose `target_ref` is unset or not
+ * bundle-qualified is not matched by the `LIKE` prefix and is left alone.
+ * Returns the number of rows rewritten.
+ */
+export function renameTaskHistoryTargetRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    return Number(db
+        .prepare(`UPDATE task_history SET target_ref = ? || substr(target_ref, ?) WHERE target_ref LIKE ? ESCAPE '\\'`)
+        .run(newBundleId, oldBundleId.length + 1, `${prefix}%`).changes);
+}