akm-cli 0.9.0-beta.52 → 0.9.0-beta.54

package/dist/commands/tasks/default-tasks.js

@@ -76,12 +76,19 @@ const DEFAULT_DEPS = {
     list: akmTasksList,
     add: akmTasksAdd,
 };
+let defaultTasksOverrides;
+/** TEST-ONLY. Swap the CI/server/register functions; pass undefined to restore. */
+export function _setDefaultTasksForTests(fakes) {
+    defaultTasksOverrides = fakes;
+}
 /**
  * Decide whether `akm setup` is running in a CI environment, where it must
  * register NO scheduled tasks. Mirrors the common `CI=true` convention used by
  * GitHub Actions, GitLab CI, CircleCI, etc.
  */
 export function isCiEnvironment(env = process.env) {
+    if (defaultTasksOverrides?.isCiEnvironment)
+        return defaultTasksOverrides.isCiEnvironment(env);
     const ci = env.CI;
     if (ci === undefined || ci === null)
         return false;
@@ -95,6 +102,8 @@ export function isCiEnvironment(env = process.env) {
  * Used as the default when setup is non-interactive (no TTY / --yes / CI).
  */
 export function detectServerDefault() {
+    if (defaultTasksOverrides?.detectServerDefault)
+        return defaultTasksOverrides.detectServerDefault();
     if (os.platform() !== "linux")
         return false;
     // A laptop exposes a battery under /sys/class/power_supply/BAT*. Absence of
@@ -121,6 +130,9 @@ export function detectServerDefault() {
  *   never re-disable a user-enabled task).
  */
 export async function registerDefaultTasks(options = {}) {
+    if (defaultTasksOverrides?.registerDefaultTasks) {
+        return defaultTasksOverrides.registerDefaultTasks(options);
+    }
     if (isCiEnvironment()) {
         return { skipped: true, reason: "ci", created: [], existing: [], toggled: [] };
     }

package/dist/core/asset/asset-spec.js

@@ -69,8 +69,9 @@ const ASSET_SPECS_INTERNAL = {
     script: { stashDir: "scripts", ...scriptSpec },
     memory: { stashDir: "memories", ...markdownSpec },
     // Environment assets — whole `.env` files sourced/injected wholesale. Replaced
-    // the deprecated `vault` type (removed in 0.9.0). Key NAMES + start-of-line
-    // comments are surfaced as metadata; values are never read for indexing.
+    // the deprecated `vault` type (removed in 0.9.0). Only key NAMES are surfaced
+    // as metadata; values and comment text are never read for indexing (comments
+    // routinely contain commented-out credentials).
     env: {
         stashDir: "env",
         isRelevantFile: (fileName) => fileName === ".env" || fileName.endsWith(".env"),

package/dist/core/config/config-schema.js

@@ -171,6 +171,9 @@ export const ImproveProcessConfigSchema = z
     // byte-identically to today (the incrementalSince path is unaffected). Only
     // meaningful on the `consolidate` process.
     judgedCache: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
+    // Distill process: LLM-as-judge lesson quality gate. Default ON (R3);
+    // fail-open — judge failure/timeout/parse errors pass through. Set
+    // `enabled: false` on the distill process to opt out.
     qualityGate: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
     contradictionDetection: z.object({ enabled: z.boolean().optional() }).passthrough().optional(),
     // Extract process config (only meaningful for extract process)
@@ -250,24 +253,13 @@ export const ImproveProcessConfigSchema = z
     // once sufficient history accumulates; this value is only used on the very
     // first run. Default 30 s. Only meaningful on the `consolidate` process.
     p90ChunkSecondsDefault: z.number().finite().positive().optional(),
-    // WS-3b: Homeostatic demotion (step 0a). Before any LLM merge, demote
-    // retrievalSalience for stale/low-value assets so the merge pool is bounded
-    // and high-SNR. Demotion is state.db-only (file content untouched);
-    // re-promotable on re-retrieval. Default OFF. Only meaningful on the
-    // `consolidate` process.
-    homeostaticDemotion: z
-        .object({
-        enabled: z.boolean().optional(),
-        // Minimum days since last retrieval to consider an asset stale (default 30).
-        staleDays: z.number().int().min(0).optional(),
-        // Demotion factor: multiply retrievalSalience by this when stale (default 0.5).
-        demotionFactor: z.number().min(0).max(1).optional(),
-    })
-        .passthrough()
-        .optional(),
+    // (WS-3b step 0a `homeostaticDemotion` was removed — R4. The key is
+    // tolerated via passthrough if an old config still carries it; continuous
+    // decay is now part of the always-applied salience recency term.)
     // WS-3b: Schema-similarity gate (step 0b). At intake, if a new candidate's
     // body embedding is within epsilon of an existing derived-layer lesson/knowledge
-    // node, mark it schema-consistent and lower its priority. Default OFF.
+    // node, mark it schema-consistent and lower its priority. Default ON for
+    // the `extract` process since R3 (fail-open; set `enabled: false` to opt out).
     // Only meaningful on the `consolidate` and `extract` processes.
     schemaSimilarity: z
         .object({
@@ -297,13 +289,19 @@ export const ImproveProcessConfigSchema = z
     //   - maxGeneration: refuse to merge two assets both above this generation (default 2).
     //   - lexicalDiversityCheck: low n-gram diversity ⇒ raise merge threshold.
     //   - randomClusterFraction: occasional random (non-similar) cluster in pool (default 0.05).
-    // Default OFF. Only meaningful on the `consolidate` process.
+    //   - mergeInformationFloor: measure that merges keep provenance + specificity
+    //     (R5 §4.2; ADVISORY in v1 — counted, never refused).
+    //   - minSpecificityRetention: distinct-token retention floor for merges (default 0.6).
+    // Default ON since R5 (opt out via enabled: false). Only meaningful on the
+    // `consolidate` process.
     antiCollapse: z
         .object({
         enabled: z.boolean().optional(),
         maxGeneration: z.number().int().min(1).optional(),
         lexicalDiversityCheck: z.boolean().optional(),
         randomClusterFraction: z.number().min(0).max(1).optional(),
+        mergeInformationFloor: z.boolean().optional(),
+        minSpecificityRetention: z.number().min(0).max(1).optional(),
     })
         .passthrough()
         .optional(),
@@ -633,6 +631,29 @@ const ImproveSalienceSchema = z
     replayBudget: z.number().int().min(0).optional(),
 })
     .passthrough();
+// R5 — longitudinal collapse/churn detector (observe-only in v1; deterministic,
+// fail-open, runs only on cycles where consolidate/recombine did work).
+// Default ON; opt out via `improve.collapseDetector.enabled: false`.
+// See docs/design/improve-collapse-churn-detector-design.md.
+const ImproveCollapseDetectorSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    // Canary set size minted on first run (owner-approved 30–50 range; default 40).
+    canaryCount: z.number().int().min(3).max(200).optional(),
+    // Top-K cutoff for canary recall/nDCG (default 10).
+    k: z.number().int().min(1).max(100).optional(),
+    // Trend window in qualifying cycles (default 5).
+    windowCycles: z.number().int().min(2).max(50).optional(),
+    // Absolute mean-recall drop vs window median that fires collapse (default 0.15).
+    recallDropThreshold: z.number().min(0).max(1).optional(),
+    // distinct-content-ratio decline over the window that fires collapse (default 0.05).
+    entropyDropThreshold: z.number().min(0).max(1).optional(),
+    // Accepted-action volume over the window below which churn never fires (default 25).
+    churnMinAcceptedActions: z.number().int().min(1).optional(),
+    // improve_cycle_metrics retention (default 365 days, owner-approved).
+    retentionDays: z.number().int().min(1).optional(),
+})
+    .passthrough();
 export const ImproveConfigSchema = z
     .object({
     utilityDecay: ImproveUtilityDecaySchema.optional(),
@@ -640,6 +661,7 @@ export const ImproveConfigSchema = z
     calibration: ImproveCalibrationSchema.optional(),
     exploration: ImproveExplorationSchema.optional(),
     salience: ImproveSalienceSchema.optional(),
+    collapseDetector: ImproveCollapseDetectorSchema.optional(),
 })
     .passthrough();
 // ── Index / per-pass ────────────────────────────────────────────────────────

package/dist/core/config/config.js

@@ -278,7 +278,19 @@ export function loadConfig() {
     warnIfProjectConfigPresent(process.cwd());
     return loadUserConfig();
 }
+let saveConfigOverride;
+/** TEST-ONLY. Swap the implementation of `saveConfig`; pass undefined to restore. */
+export function _setSaveConfigForTests(fake) {
+    saveConfigOverride = fake;
+}
 export function saveConfig(config) {
+    if (saveConfigOverride) {
+        saveConfigOverride(config);
+        return;
+    }
+    saveConfigReal(config);
+}
+function saveConfigReal(config) {
     cachedConfig = undefined;
     const configPath = getConfigPath();
     const dir = path.dirname(configPath);

package/dist/core/eval/rank-metrics.js

@@ -0,0 +1,113 @@
+// 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/.
+export const DEFAULT_CURATE_WEIGHTS = {
+    ndcg: 0.5,
+    recall: 0.2,
+    mrr: 0.1,
+    noBannedAboveRequired: 0.2,
+};
+/** nDCG@k with binary relevance: gain 1 for relevant refs, 0 otherwise. */
+export function ndcgAtK(returned, relevant, k) {
+    const top = returned.slice(0, k);
+    let dcg = 0;
+    for (let i = 0; i < top.length; i++) {
+        if (relevant.has(top[i]))
+            dcg += 1 / Math.log2(i + 2);
+    }
+    const idealCount = Math.min(k, relevant.size);
+    let idcg = 0;
+    for (let i = 0; i < idealCount; i++)
+        idcg += 1 / Math.log2(i + 2);
+    return idcg === 0 ? 1 : dcg / idcg;
+}
+export function recallAtK(returned, relevant, k) {
+    if (relevant.size === 0)
+        return 1;
+    const top = new Set(returned.slice(0, k));
+    let hit = 0;
+    for (const r of relevant)
+        if (top.has(r))
+            hit += 1;
+    return hit / relevant.size;
+}
+export function mrr(returned, relevant) {
+    for (let i = 0; i < returned.length; i++) {
+        if (relevant.has(returned[i]))
+            return 1 / (i + 1);
+    }
+    return 0;
+}
+/**
+ * Leapfrog gate. A banned ref "leapfrogs" when it appears ABOVE at least one
+ * present relevant ref. Returns the fraction of present banned refs that do
+ * NOT leapfrog (1.0 when no banned ref is present, or none leapfrog), plus the
+ * raw violation count.
+ */
+export function noBannedAboveRequired(returned, relevant, banned) {
+    const rankOf = new Map();
+    returned.forEach((ref, i) => {
+        if (!rankOf.has(ref))
+            rankOf.set(ref, i);
+    });
+    const relevantRanks = returned.map((ref, i) => (relevant.has(ref) ? i : -1)).filter((i) => i >= 0);
+    if (relevantRanks.length === 0) {
+        // No relevant ref present to be leapfrogged — gate is vacuously satisfied.
+        return { score: 1, leapfrogCount: 0 };
+    }
+    const worstRelevantRank = Math.max(...relevantRanks);
+    const bannedPresent = returned.filter((ref) => banned.has(ref));
+    if (bannedPresent.length === 0)
+        return { score: 1, leapfrogCount: 0 };
+    let leapfrog = 0;
+    for (const b of bannedPresent) {
+        const rb = rankOf.get(b);
+        if (rb !== undefined && rb < worstRelevantRank)
+            leapfrog += 1;
+    }
+    return { score: 1 - leapfrog / bannedPresent.length, leapfrogCount: leapfrog };
+}
+/** Score a single curate result (ordered refs) against its judgment. */
+export function scoreCurateCase(returned, judgment, weights = DEFAULT_CURATE_WEIGHTS) {
+    const k = judgment.limit;
+    const relevant = new Set(judgment.relevant);
+    const banned = new Set(judgment.banned);
+    const ndcg = ndcgAtK(returned, relevant, k);
+    const recall = recallAtK(returned, relevant, k);
+    const rr = mrr(returned, relevant);
+    const gate = noBannedAboveRequired(returned, relevant, banned);
+    const score = ndcg * weights.ndcg + recall * weights.recall + rr * weights.mrr + gate.score * weights.noBannedAboveRequired;
+    return {
+        ndcg,
+        recall,
+        mrr: rr,
+        noBannedAboveRequired: gate.score,
+        bannedLeapfrogCount: gate.leapfrogCount,
+        score,
+    };
+}
+/** Aggregate per-case metrics into a suite summary. */
+export function summarizeCurateMetrics(metrics) {
+    const n = metrics.length;
+    if (n === 0) {
+        return {
+            caseCount: 0,
+            meanScore: 0,
+            meanNdcg: 0,
+            meanRecall: 0,
+            meanMrr: 0,
+            meanNoBannedAboveRequired: 1,
+            totalBannedLeapfrog: 0,
+        };
+    }
+    const sum = (sel) => metrics.reduce((a, m) => a + sel(m), 0);
+    return {
+        caseCount: n,
+        meanScore: sum((m) => m.score) / n,
+        meanNdcg: sum((m) => m.ndcg) / n,
+        meanRecall: sum((m) => m.recall) / n,
+        meanMrr: sum((m) => m.mrr) / n,
+        meanNoBannedAboveRequired: sum((m) => m.noBannedAboveRequired) / n,
+        totalBannedLeapfrog: sum((m) => m.bannedLeapfrogCount),
+    };
+}

package/dist/core/state/migrations.js

@@ -700,6 +700,62 @@ const MIGRATIONS = [
       ALTER TABLE asset_salience ADD COLUMN encoding_source TEXT DEFAULT NULL;
     `,
     },
+    // ── Migration 016 — collapse/churn detector (R5) ─────────────────────────────
+    //
+    // Longitudinal store-health history for the improve pipeline
+    // (docs/design/improve-collapse-churn-detector-design.md).
+    //
+    //   canary_queries — the fixed canary set, minted deterministically from the
+    //     live stash on first detector run and NEVER auto-refreshed (silent
+    //     re-baselining is how a slow collapse hides). `canary_set_id` groups one
+    //     mint; deactivated sets keep their rows (active = 0) so historical cycle
+    //     rows stay interpretable. Tens of rows; never purged.
+    //
+    //   improve_cycle_metrics — one row per qualifying improve cycle (a run where
+    //     consolidate processed ≥1 op or recombine evaluated ≥1 cluster). Every
+    //     column is a scalar or a size-capped JSON blob (< 2 KB/row by
+    //     construction — the result_json lesson applied). Retention: 365 days via
+    //     purgeOldCycleMetrics. Trend queries drive the collapse/churn alert
+    //     evaluation and the health advisory; `canary_set_id` scoping prevents
+    //     comparing across canary re-mints.
+    {
+        id: "016-collapse-churn-detector",
+        up: `
+      CREATE TABLE IF NOT EXISTS canary_queries (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        canary_set_id TEXT    NOT NULL,
+        anchor_ref    TEXT    NOT NULL,
+        query         TEXT    NOT NULL,
+        source        TEXT    NOT NULL DEFAULT 'auto',
+        active        INTEGER NOT NULL DEFAULT 1,
+        created_at    TEXT    NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_canary_queries_active
+        ON canary_queries(active, canary_set_id);
+
+      CREATE TABLE IF NOT EXISTS improve_cycle_metrics (
+        id                      INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id                  TEXT    NOT NULL,
+        ts                      TEXT    NOT NULL,
+        pass                    TEXT    NOT NULL,
+        canary_set_id           TEXT    NOT NULL,
+        mean_recall             REAL    NOT NULL,
+        mean_ndcg               REAL    NOT NULL,
+        mean_mrr                REAL    NOT NULL,
+        canary_ranks_json       TEXT    NOT NULL,
+        store_total             INTEGER NOT NULL,
+        store_by_type_json      TEXT    NOT NULL,
+        distinct_content_ratio  REAL    NOT NULL,
+        mean_bigram_diversity   REAL    NOT NULL,
+        over_generation_count   INTEGER NOT NULL,
+        accepted_actions        INTEGER NOT NULL,
+        merge_floor_violations  INTEGER NOT NULL DEFAULT 0,
+        alerts_json             TEXT    NOT NULL DEFAULT '[]'
+      );
+      CREATE INDEX IF NOT EXISTS idx_improve_cycle_metrics_ts
+        ON improve_cycle_metrics(ts);
+    `,
+    },
 ];
 /**
  * Apply every pending migration in a single transaction per migration.

package/dist/core/state-db.js

@@ -472,19 +472,20 @@ export function insertProposalIfAbsent(db, proposal, stashDir) {
 /**
  * Errors `BEGIN IMMEDIATE` can throw under concurrent-writer contention that are
  * transient (the statement did NOT start a usable transaction) and safe to
- * retry after clearing any phantom transaction state:
+ * retry:
  *   - "database is locked" / SQLITE_BUSY — another writer holds the lock.
- *   - "cannot start a transaction within a transaction" — bun:sqlite can leave
- *     the connection reporting an open transaction after a contended busy-wait
- *     on BEGIN IMMEDIATE (observed only under heavy parallel load, e.g. the
- *     proposal-queue worker race). A ROLLBACK clears that phantom state.
  * These are start-of-transaction failures only; an error thrown by `fn` is a
  * real failure and is NEVER retried.
+ *
+ * "cannot start a transaction within a transaction" is deliberately NOT
+ * retryable: it means a transaction is already open on this connection (a
+ * re-entrant call — handled by the entry guard in withImmediateTransaction),
+ * and "retrying" it with a ROLLBACK would destroy the caller's transaction
+ * (issue #686).
  */
 function isRetryableBeginError(err) {
     const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
-    return (msg.includes("within a transaction") ||
-        msg.includes("database is locked") ||
+    return (msg.includes("database is locked") ||
         msg.includes("database table is locked") ||
         // Phantom BEGIN (see below) — synthesized when BEGIN IMMEDIATE returns
         // without opening a transaction. Safe to retry: fn() has not run.
@@ -498,6 +499,16 @@ function sleepSyncMs(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 export function withImmediateTransaction(db, fn) {
+    // Re-entrancy guard (issue #686): if a transaction is already open on this
+    // connection (e.g. a nested withImmediateTransaction call inside an outer
+    // frame's fn), join it — run fn directly with no BEGIN/COMMIT/ROLLBACK of
+    // our own. Without this, the nested BEGIN throws "cannot start a transaction
+    // within a transaction", which the old retry path answered with an
+    // unconditional ROLLBACK — destroying the OUTER transaction and leaving its
+    // COMMIT to fail with "cannot commit - no transaction is active".
+    if (db.inTransaction) {
+        return fn();
+    }
     let lastBeginErr;
     for (let attempt = 1; attempt <= WITH_IMMEDIATE_TX_MAX_ATTEMPTS; attempt++) {
         try {
@@ -515,13 +526,15 @@ export function withImmediateTransaction(db, fn) {
         catch (err) {
             lastBeginErr = err;
             if (isRetryableBeginError(err) && attempt < WITH_IMMEDIATE_TX_MAX_ATTEMPTS) {
-                // Clear any phantom/stale transaction left by the contended BEGIN, then
-                // retry with a small backoff so concurrent writers serialize cleanly.
-                try {
-                    db.exec("ROLLBACK");
-                }
-                catch {
-                    // No active transaction to roll back — fine.
+                // Only roll back a transaction we can see — never blind-ROLLBACK, since
+                // that could destroy a transaction this frame does not own.
+                if (db.inTransaction) {
+                    try {
+                        db.exec("ROLLBACK");
+                    }
+                    catch {
+                        // Transaction already gone — fine.
+                    }
                 }
                 sleepSyncMs(2 ** (attempt - 1));
                 continue;
@@ -530,15 +543,25 @@ export function withImmediateTransaction(db, fn) {
         }
         try {
             const result = fn();
+            if (!db.inTransaction) {
+                // The transaction we opened vanished while fn() ran (e.g. an
+                // auto-rollback or a stray ROLLBACK inside fn). fn's writes may have
+                // escaped serialization, so retrying is unsafe — fail loudly instead of
+                // letting COMMIT throw the opaque "cannot commit - no transaction is
+                // active" SQLiteError.
+                throw new Error("withImmediateTransaction invariant violated: transaction opened by BEGIN IMMEDIATE was no longer active after the transaction body ran; refusing to COMMIT (writes may have escaped serialization)");
+            }
             db.exec("COMMIT");
             return result;
         }
         catch (err) {
-            try {
-                db.exec("ROLLBACK");
-            }
-            catch {
-                // Ignore rollback failures so the original error is preserved.
+            if (db.inTransaction) {
+                try {
+                    db.exec("ROLLBACK");
+                }
+                catch {
+                    // Ignore rollback failures so the original error is preserved.
+                }
             }
             throw err; // a real error inside the transaction body — never retried.
         }
@@ -1252,3 +1275,107 @@ export function upsertBodyEmbeddings(db, entries) {
         }
     })();
 }
+/** Insert a freshly minted canary set (all rows active, one shared set id). */
+export function insertCanaries(db, canarySetId, canaries, now) {
+    if (canaries.length === 0)
+        return;
+    const ts = now ?? new Date().toISOString();
+    const stmt = db.prepare(`
+    INSERT INTO canary_queries (canary_set_id, anchor_ref, query, source, active, created_at)
+    VALUES (?, ?, ?, ?, 1, ?)
+  `);
+    db.transaction(() => {
+        for (const c of canaries) {
+            stmt.run(canarySetId, c.anchorRef, c.query, c.source ?? "auto", ts);
+        }
+    })();
+}
+/** Load the active canary set (empty array = never minted). */
+export function getActiveCanaries(db) {
+    // Scope to the NEWEST active set: if an interrupted refresh (or a bug) ever
+    // leaves two sets active, mixing their rows would silently corrupt the
+    // recall/entropy trend baselines. The newest set wins; stale-active rows are
+    // simply never returned.
+    return db
+        .prepare(`SELECT * FROM canary_queries
+       WHERE active = 1 AND canary_set_id = (
+         SELECT canary_set_id FROM canary_queries WHERE active = 1
+         ORDER BY created_at DESC, id DESC LIMIT 1
+       )
+       ORDER BY id`)
+        .all();
+}
+/** Load one canary set's rows by its exact set id (any active state), insertion order. */
+export function getCanariesBySetId(db, canarySetId) {
+    return db
+        .prepare(`SELECT * FROM canary_queries WHERE canary_set_id = ? ORDER BY id`)
+        .all(canarySetId);
+}
+/** List every distinct canary_set_id that still has active rows. */
+export function listActiveCanarySetIds(db) {
+    const rows = db.prepare(`SELECT DISTINCT canary_set_id FROM canary_queries WHERE active = 1`).all();
+    return rows.map((r) => r.canary_set_id);
+}
+/**
+ * Deactivate every canary row in a set. Rows are RETAINED (active = 0) so
+ * historical improve_cycle_metrics rows keyed on the old canary_set_id stay
+ * interpretable; only `akm improve canary --refresh` calls this.
+ */
+export function deactivateCanarySet(db, canarySetId) {
+    const result = db
+        .prepare(`UPDATE canary_queries SET active = 0 WHERE canary_set_id = ? AND active = 1`)
+        .run(canarySetId);
+    const changes = result.changes ?? 0;
+    return typeof changes === "bigint" ? Number(changes) : changes;
+}
+/** Persist one qualifying cycle's store-health snapshot. */
+export function insertCycleMetrics(db, row) {
+    db.prepare(`
+    INSERT INTO improve_cycle_metrics
+      (run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
+       canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
+       mean_bigram_diversity, over_generation_count, accepted_actions,
+       merge_floor_violations, alerts_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(row.run_id, row.ts, row.pass, row.canary_set_id, row.mean_recall, row.mean_ndcg, row.mean_mrr, row.canary_ranks_json, row.store_total, row.store_by_type_json, row.distinct_content_ratio, row.mean_bigram_diversity, row.over_generation_count, row.accepted_actions, row.merge_floor_violations, row.alerts_json);
+}
+/**
+ * Load the most recent cycle rows for one canary set, OLDEST-first (the alert
+ * evaluator's window order). Scoped by canary_set_id so trends never compare
+ * across canary re-mints.
+ */
+export function queryRecentCycleMetrics(db, canarySetId, limit) {
+    const rows = db
+        .prepare(`SELECT run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
+              canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
+              mean_bigram_diversity, over_generation_count, accepted_actions,
+              merge_floor_violations, alerts_json
+       FROM improve_cycle_metrics WHERE canary_set_id = ?
+       ORDER BY ts DESC, id DESC LIMIT ?`)
+        .all(canarySetId, Math.max(0, limit));
+    return rows.reverse();
+}
+/** Load the single most recent cycle row across all canary sets (health surface). */
+export function getLatestCycleMetrics(db) {
+    const row = db
+        .prepare(`SELECT run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
+              canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
+              mean_bigram_diversity, over_generation_count, accepted_actions,
+              merge_floor_violations, alerts_json
+       FROM improve_cycle_metrics ORDER BY ts DESC, id DESC LIMIT 1`)
+        .get();
+    return row == null ? undefined : row;
+}
+/**
+ * Delete cycle rows older than `retentionDays` (default 365 — owner-approved;
+ * a slow collapse needs a longer trend window than the 90-day events log).
+ * Returns the purged row count. canary_queries rows are never purged.
+ */
+export function purgeOldCycleMetrics(db, retentionDays = 365) {
+    if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+        return 0;
+    const cutoff = new Date(Date.now() - retentionDays * 86_400_000).toISOString();
+    const result = db.prepare("DELETE FROM improve_cycle_metrics WHERE ts < ?").run(cutoff);
+    const changes = result.changes ?? 0;
+    return typeof changes === "bigint" ? Number(changes) : changes;
+}

package/dist/core/warn.js

@@ -17,6 +17,11 @@ import path from "node:path";
 let quiet = false;
 let verbose = false;
 let logFilePath;
+let sinkOverride;
+/** TEST-ONLY. Swap the output sink; pass undefined to restore real output. */
+export function _setWarnSinkForTests(fake) {
+    sinkOverride = fake;
+}
 export function setQuiet(value) {
     quiet = value;
 }
@@ -96,6 +101,10 @@ function appendToLogFile(level, args) {
  * Use for progress counters and status lines (replaces console.error used for progress).
  */
 export function info(...args) {
+    if (sinkOverride) {
+        sinkOverride("info", args);
+        return;
+    }
     appendToLogFile("INFO", args);
     if (!quiet) {
         console.warn(...args);
@@ -107,6 +116,10 @@ export function info(...args) {
  * Drop-in replacement for console.warn() across the codebase.
  */
 export function warn(...args) {
+    if (sinkOverride) {
+        sinkOverride("warn", args);
+        return;
+    }
     appendToLogFile("WARN", args);
     if (!quiet) {
         console.warn(...args);
@@ -118,6 +131,10 @@ export function warn(...args) {
  * Drop-in replacement for console.error() used for diagnostic failures.
  */
 export function error(...args) {
+    if (sinkOverride) {
+        sinkOverride("error", args);
+        return;
+    }
     appendToLogFile("ERROR", args);
     if (!quiet) {
         console.error(...args);
@@ -129,6 +146,10 @@ export function error(...args) {
  * default verbosity (e.g. registry-content workflow validation errors).
  */
 export function warnVerbose(...args) {
+    if (sinkOverride) {
+        sinkOverride("warnVerbose", args);
+        return;
+    }
     if (isVerbose()) {
         warn(...args);
     }

package/dist/indexer/db/db.js

@@ -1633,6 +1633,11 @@ function bareRef(ref) {
  * entry_ref populated (see logCurateEvent), so curation is a real retrieval
  * signal here. Legacy summary-only curate rows with a NULL entry_ref simply
  * contribute nothing.
+ *
+ * Machine-sourced events (`source` = 'improve' or 'task') are EXCLUDED: this
+ * count feeds salience/ranking, and pipeline probe traffic counting as demand
+ * creates a self-reinforcing loop (meta-review 05 DRIFT-6). NULL sources
+ * (pre-column rows) count as user demand.
  */
 export function getRetrievalCounts(db, refs) {
     if (refs.length === 0)
@@ -1671,6 +1676,7 @@ export function getRetrievalCounts(db, refs) {
          FROM usage_events
          WHERE event_type IN ('search','show','curate')
            AND entry_ref IS NOT NULL
+           AND (source IS NULL OR source NOT IN ('improve','task'))
            AND CASE
                  WHEN instr(entry_ref, '//') > 0
                    THEN substr(entry_ref, instr(entry_ref, '//') + 2)