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

package/dist/cli/clack.js

@@ -0,0 +1,56 @@
+// 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 { cancel as realCancel, confirm as realConfirm, intro as realIntro, isCancel as realIsCancel, log as realLog, multiselect as realMultiselect, note as realNote, outro as realOutro, select as realSelect, spinner as realSpinner, text as realText, } from "@clack/prompts";
+// ── Test seam ────────────────────────────────────────────────────────────────
+// Swap-and-restore override. Inert in production; only tests call the setter
+// (via tests/_helpers/seams.ts `overrideSeam`, never directly).
+let clackFake;
+/** TEST-ONLY. Swap the clack prompt surface; pass undefined to restore. */
+export function _setClackForTests(fake) {
+    clackFake = fake;
+}
+const realFns = {
+    intro: realIntro,
+    outro: realOutro,
+    cancel: realCancel,
+    confirm: realConfirm,
+    select: realSelect,
+    multiselect: realMultiselect,
+    text: realText,
+    spinner: realSpinner,
+    note: realNote,
+    isCancel: realIsCancel,
+};
+/** Delegator with the real export's exact type; reads the fake at call time. */
+function bind(name) {
+    return ((...args) => {
+        const impl = (clackFake?.[name] ?? realFns[name]);
+        return impl(...args);
+    });
+}
+function bindLog(name) {
+    return ((...args) => {
+        const impl = (clackFake?.log?.[name] ?? realLog[name]);
+        return impl(...args);
+    });
+}
+export const intro = bind("intro");
+export const outro = bind("outro");
+export const cancel = bind("cancel");
+export const confirm = bind("confirm");
+export const select = bind("select");
+export const multiselect = bind("multiselect");
+export const text = bind("text");
+export const spinner = bind("spinner");
+export const note = bind("note");
+export const isCancel = bind("isCancel");
+export const log = {
+    message: bindLog("message"),
+    info: bindLog("info"),
+    success: bindLog("success"),
+    step: bindLog("step"),
+    warn: bindLog("warn"),
+    warning: bindLog("warning"),
+    error: bindLog("error"),
+};

package/dist/cli/confirm.js

@@ -35,8 +35,8 @@
  * `--quiet` NEVER suppresses the confirmation prompt — it is safety-critical
  * output. The auto-migration banner is similarly exempt from `--quiet`.
  */
-import * as p from "@clack/prompts";
 import { UsageError } from "../core/errors.js";
+import * as p from "./clack.js";
 /**
  * Prompt the user to confirm a destructive action.
  *

package/dist/commands/health/html-report.js

@@ -282,6 +282,7 @@ export function buildHealthHtmlReplacements(result, opts) {
     };
     const coverage = improve.coverage;
     const degradation = improve.degradation;
+    const minting = improve.enrichmentMinting;
     // #576: real per-stage LLM token/time accounting (replaces the GPU-time
     // proxy). Optional-guarded so reports built from older health JSON without
     // the aggregate still render.
@@ -557,7 +558,7 @@ export function buildHealthHtmlReplacements(result, opts) {
             "Coverage rate",
             pct(coverage.rate, 1),
             "flat",
-            "Accepted proposals / total stash assets (denominator-fixed). Shows what fraction of the corpus has been touched.",
+            "Distinct accepted refs / total stash assets (denominator-fixed). Shows what fraction of the corpus has been touched.",
         ], [
             "Eligible fraction",
             pct(coverage.eligibleFraction, 1),
@@ -566,8 +567,22 @@ export function buildHealthHtmlReplacements(result, opts) {
         ], [
             "Coverage accepted",
             num(coverage.acceptedProposals),
-            "up",
-            "Total accepted proposals used for the denominator-fixed coverage rate.",
+            "flat",
+            "Total accepted proposals in the window (raw volume — includes repeated rewrites of the same asset).",
+        ], [
+            "Churn ratio",
+            Number.isFinite(coverage.churnRatio) ? num(coverage.churnRatio) : "—",
+            Number.isFinite(coverage.churnRatio) && coverage.churnRatio > 1.5 ? "down" : "flat",
+            "Accepted proposals / distinct refs touched. >1.5 = the loop is repeatedly rewriting the same assets (churn, not coverage).",
+        ]);
+    }
+    // Enrichment-vs-minting policy rollup (reporting-only).
+    if (minting && Number.isFinite(minting.share)) {
+        summaryRows.push([
+            "Enrichment-lane minted share",
+            pct(minting.share, 1),
+            minting.share > 0.05 ? "down" : "flat",
+            `New assets minted by enrichment lanes / their accepted total (${minting.minted} minted vs ${minting.updated} updated). Enrichment lanes are ratified to edit existing assets only; WARN >5%, FAIL >15%.`,
         ]);
     }
     // WS-5: perf telemetry rows (only when at least one run reported telemetry).
@@ -606,18 +621,13 @@ export function buildHealthHtmlReplacements(result, opts) {
         summaryRows.push([
             "Corpus diversity (Gini)",
             num(degradation.corpusCentroidDistance),
-            degradation.entrenchmentFlagged ? "down" : "flat",
-            "Gini coefficient of retrieval_salience for top-100 ranked assets. High Gini (>0.35) = entrenchment risk.",
+            degradation.entrenchmentFlagged || degradation.salienceUniformityFlagged ? "down" : "flat",
+            "Gini coefficient of retrieval_salience for top-100 ranked assets. Two-tailed: >0.35 = entrenchment risk; <0.08 = collapsed toward uniform (ranking no longer discriminates).",
         ], [
             "Merge fidelity contradiction rate",
             pct(degradation.mergeFidelityContradictionRate, 1),
             "flat",
             "Fraction of consolidated proposals that involved a contradiction, from consolidation result envelopes.",
-        ], [
-            "High-generation fraction",
-            pct(degradation.highGenerationFraction, 1),
-            "flat",
-            "Fraction of assets with consecutive_no_ops >= 2 (proxy for high-generation assets in the salience table).",
         ]);
     }
     const summaryRowsHtml = summaryRows
@@ -726,6 +736,19 @@ export function buildHealthHtmlReplacements(result, opts) {
             remedy: "akm health --format json | jq '.improve.degradation'",
         });
     }
+    // Low-tail companion: salience distribution collapsed toward uniform.
+    if (degradation?.salienceUniformityFlagged) {
+        pushItem({
+            key: "salience-uniformity-collapse",
+            prio: "P2",
+            cls: "warn",
+            title: "Salience distribution collapsed: retrieval_salience Gini < 0.08",
+            descHtml: "The top-100 salience scores are near-uniform (uniform baseline ≈ 0.1) — " +
+                "ranking currently carries little to no discrimination between assets. " +
+                `Corpus diversity proxy: ${esc(String(degradation.corpusCentroidDistance))}.`,
+            remedy: "akm health --format json | jq '.improve.degradation'",
+        });
+    }
     // WS-5: over-budget consolidation advisory.
     if (perf.overBudgetRuns > 0) {
         pushItem({

package/dist/commands/health.js

@@ -14,6 +14,17 @@ import { getExecutionLogCandidates } from "../integrations/session-logs/index.js
 import { LLM_USAGE_EVENT } from "../llm/usage-persist.js";
 import { HEALTH_CHECKS } from "./health/checks.js";
 import { gateDecisionsToSamples, summarizeCalibration } from "./improve/calibration.js";
+/**
+ * Lanes ratified as ENRICHMENT-ONLY: they may propose edits to existing
+ * assets (metadata, relations, content refresh) but must not mint new ones.
+ * New-asset generation belongs to the signal-gated minting lanes
+ * (extract/distill/memory-inference/recombine).
+ */
+export const ENRICHMENT_LANES = ["proactive", "high-salience", "high-retrieval", "signal-delta"];
+/** Minted share of enrichment-lane accepts that triggers a WARN advisory. */
+export const ENRICHMENT_MINTED_WARN_SHARE = 0.05;
+/** Minted share of enrichment-lane accepts that triggers a FAIL advisory. */
+export const ENRICHMENT_MINTED_FAIL_SHARE = 0.15;
 const DEFAULT_SINCE_MS = 24 * 60 * 60 * 1000;
 const IMPROVE_COMPLETED_EVENT = "improve_completed";
 const HEALTH_PROBE_EVENT = "health_probe";
@@ -173,6 +184,8 @@ function createUnknownImproveMetrics() {
             rate: Number.NaN,
             eligibleFraction: Number.NaN,
             acceptedProposals: 0,
+            distinctRefs: 0,
+            churnRatio: Number.NaN,
             totalAssets: 0,
         },
     };
@@ -1134,6 +1147,7 @@ function readCalibration(db, since, until) {
  */
 function computeDenominatorFixedCoverage(db, totalAssets, eligibleAssets, since, until, stashDir) {
     let acceptedProposals = 0;
+    let distinctRefs = 0;
     try {
         const proposals = listStateProposals(db, {
             status: "accepted",
@@ -1147,25 +1161,91 @@ function computeDenominatorFixedCoverage(db, totalAssets, eligibleAssets, since,
             return true;
         });
         acceptedProposals = proposals.length;
+        // Coverage counts DISTINCT refs: N accepted rewrites of one asset are
+        // churn, not coverage. The raw proposal count is kept alongside so the
+        // churn ratio (proposals ÷ distinct refs) stays visible.
+        distinctRefs = new Set(proposals.map((p) => p.ref)).size;
     }
     catch {
         // Fail open: table may not exist on older installs.
     }
+    const churnRatio = distinctRefs > 0 ? roundRate(acceptedProposals / distinctRefs) : Number.NaN;
     if (totalAssets === 0) {
         return {
             rate: Number.NaN,
             eligibleFraction: Number.NaN,
             acceptedProposals,
+            distinctRefs,
+            churnRatio,
             totalAssets: 0,
         };
     }
     return {
-        rate: roundRate(acceptedProposals / totalAssets),
+        rate: roundRate(distinctRefs / totalAssets),
         eligibleFraction: roundRate(eligibleAssets / totalAssets),
         acceptedProposals,
+        distinctRefs,
+        churnRatio,
         totalAssets,
     };
 }
+/**
+ * Compute the enrichment-vs-minting rollup over the window's accepted,
+ * lane-attributed proposals (reporting-only; see {@link EnrichmentMintingRollup}).
+ *
+ * SQL-side `json_extract` keeps the (potentially large) `backupContent` blobs
+ * out of process memory. Pre-Phase-6C rows without an `eligibilitySource`
+ * cannot be lane-classified and are excluded. Fails open (undefined) when the
+ * proposals table is absent.
+ */
+export function computeEnrichmentMintingRollup(db, since, until) {
+    try {
+        const rows = db
+            .prepare(`SELECT
+           json_extract(metadata_json, '$.eligibilitySource') AS lane,
+           CASE WHEN json_extract(metadata_json, '$.backupContent') IS NULL THEN 1 ELSE 0 END AS is_minted,
+           COUNT(*) AS cnt
+         FROM proposals
+         WHERE status = 'accepted'
+           AND updated_at >= ?
+           AND (? IS NULL OR updated_at < ?)
+           AND json_extract(metadata_json, '$.eligibilitySource') IS NOT NULL
+           AND json_extract(metadata_json, '$.eligibilitySource') != ''
+         GROUP BY lane, is_minted`)
+            .all(since, until ?? null, until ?? null);
+        if (rows.length === 0)
+            return undefined;
+        const byLane = {};
+        for (const row of rows) {
+            byLane[row.lane] ??= { minted: 0, updated: 0 };
+            const entry = byLane[row.lane];
+            if (row.is_minted === 1)
+                entry.minted += row.cnt;
+            else
+                entry.updated += row.cnt;
+        }
+        let minted = 0;
+        let updated = 0;
+        for (const lane of ENRICHMENT_LANES) {
+            const entry = byLane[lane];
+            if (!entry)
+                continue;
+            minted += entry.minted;
+            updated += entry.updated;
+        }
+        const decided = minted + updated;
+        return {
+            minted,
+            updated,
+            share: decided > 0 ? roundRate(minted / decided) : Number.NaN,
+            byLane,
+        };
+    }
+    catch {
+        // Fail open: proposals table may not exist on older installs.
+        return undefined;
+    }
+}
 /**
  * Compute WS-5 per-run degradation metrics (Part V §4).
  *
@@ -1176,7 +1256,7 @@ function computeDenominatorFixedCoverage(db, totalAssets, eligibleAssets, since,
  * @param since - Window start (ISO-8601).
  * @param until - Window end (ISO-8601).
  */
-function computeDegradationMetrics(db, since, until) {
+export function computeDegradationMetrics(db, since, until) {
     // (a) Corpus diversity — salience rank distribution of the top-100 assets.
     // We use the Gini coefficient of retrieval_salience scores as an intra-corpus
     // diversity proxy. A Gini close to 1 = highly concentrated (entrenched top
@@ -1184,6 +1264,7 @@ function computeDegradationMetrics(db, since, until) {
     // consecutive-run centroid distance requires cross-run history not yet stored.
     let corpusCentroidDistance = Number.NaN;
     let entrenchmentFlagged;
+    let salienceUniformityFlagged;
     try {
         const rows = db
             .prepare(`SELECT retrieval_salience FROM asset_salience
@@ -1202,9 +1283,13 @@ function computeDegradationMetrics(db, since, until) {
             // corpusCentroidDistance approximation: gini is "distance from uniform".
             // Note: retrieval_salience values are in [0,1], so the max achievable Gini
             // with this formula is ~0.5 (when one asset dominates and others are near 0).
-            // Threshold: >0.35 flags entrenchment (robustly above the ~0.1 uniform baseline).
+            // Two-tailed: >0.35 flags entrenchment (robustly above the ~0.1 uniform
+            // baseline); <0.08 flags uniformity collapse — the distribution no longer
+            // discriminates between assets (live 2026-07 value 0.040 sat unflagged
+            // in this tail under the old one-tailed check).
             corpusCentroidDistance = roundRate(gini);
             entrenchmentFlagged = gini > 0.35;
+            salienceUniformityFlagged = gini < 0.08;
         }
     }
     catch {
@@ -1243,23 +1328,11 @@ function computeDegradationMetrics(db, since, until) {
     catch {
         // Fail open.
     }
-    // (c) Generation distribution — fraction of asset_salience rows with
-    // generation >= 2. Generation is NOT currently stored in asset_salience
-    // (it's in frontmatter). We approximate using consecutive_no_ops as a
-    // maturity proxy: assets that have never been no-op'd are "fresh".
-    // TODO(0.10+): store generation in asset_salience for proper tracking.
-    let highGenerationFraction = Number.NaN;
-    try {
-        const genRows = db.prepare("SELECT consecutive_no_ops FROM asset_salience").all();
-        if (genRows.length > 0) {
-            // Use consecutive_no_ops >= 2 as a proxy for "has been through merge cycles".
-            const highGen = genRows.filter((r) => r.consecutive_no_ops >= 2).length;
-            highGenerationFraction = roundRate(highGen / genRows.length);
-        }
-    }
-    catch {
-        // Table not present.
-    }
+    // (c) highGenerationFraction was DELETED (meta-review 05 DRIFT-3): it
+    // approximated "LLM-merge generations" from consecutive_no_ops — which counts
+    // the opposite condition (cycles where nothing was changed) — and its own
+    // in-code TODO admitted the proxy. Display-only, never actionable; removed
+    // rather than instrumented.
     // (d) Oracle spot-check — up to 5 recently accepted proposals in the window.
     const oracleSpotCheck = [];
     try {
@@ -1287,8 +1360,8 @@ function computeDegradationMetrics(db, since, until) {
     return {
         corpusCentroidDistance,
         entrenchmentFlagged,
+        salienceUniformityFlagged,
         mergeFidelityContradictionRate,
-        highGenerationFraction,
         oracleSpotCheck,
     };
 }
@@ -1447,6 +1520,7 @@ export function akmHealth(options = {}) {
         if (degradationMain) {
             improveSummary.degradation = degradationMain;
         }
+        improveSummary.enrichmentMinting = computeEnrichmentMintingRollup(db, since, until);
         // WS-2 proxy-adequacy tripwire: surface any outcome_proxy_inverted events
         // in the health window as an advisory so operators know when the 0.10+
         // rich in-session signal is no longer deferrable.
@@ -1466,6 +1540,65 @@ export function akmHealth(options = {}) {
                     "The 0.10+ rich in-session outcome signal is no longer deferrable. See plan §WS-2.",
             });
         }
+        // Two-tailed companion: a proxy that decays to noise (|corr| < 0.1 at scale)
+        // is as much a failure as an inverted one — it just fails silently.
+        const proxyDeadEvents = readEvents({ since, type: "outcome_proxy_dead" }, { dbPath: stateDbPath, db }).events;
+        if (proxyDeadEvents.length > 0) {
+            const lastEvent = proxyDeadEvents[proxyDeadEvents.length - 1];
+            const correlation = typeof lastEvent.metadata?.correlation === "number" ? lastEvent.metadata.correlation.toFixed(3) : "unknown";
+            advisories.push({
+                name: "outcome-proxy-dead",
+                status: "warn",
+                kind: "deterministic",
+                confidence: "high",
+                message: `WS-2 outcome proxy is DEAD (${proxyDeadEvents.length} event(s) in window). ` +
+                    `|corr(outcome_score, accepted_change_rate)| = ${correlation} < 0.1 at n ≥ 500. ` +
+                    "outcome_score is statistically unrelated to improvement outcomes — " +
+                    "treat outcome-derived rank contributions as noise until a real usage/outcome signal lands.",
+            });
+        }
+        // Salience-distribution collapse: Gini below the uniform baseline means
+        // ranking no longer discriminates between assets.
+        if (improveSummary.degradation?.salienceUniformityFlagged) {
+            advisories.push({
+                name: "salience-uniformity-collapse",
+                status: "warn",
+                kind: "deterministic",
+                confidence: "high",
+                message: `Salience distribution collapsed toward uniform: top-100 retrieval_salience Gini = ` +
+                    `${improveSummary.degradation.corpusCentroidDistance} < 0.08 (uniform baseline ≈ 0.1). ` +
+                    "Ranking currently carries little to no discrimination between assets.",
+            });
+        }
+        // Enrichment-vs-minting policy: enrichment lanes edit existing assets;
+        // a rising minted share means a lane is generating new content instead.
+        const minting = improveSummary.enrichmentMinting;
+        if (minting && Number.isFinite(minting.share) && minting.share > ENRICHMENT_MINTED_WARN_SHARE) {
+            advisories.push({
+                name: "enrichment-lane-minting",
+                status: minting.share > ENRICHMENT_MINTED_FAIL_SHARE ? "fail" : "warn",
+                kind: "deterministic",
+                confidence: "high",
+                message: `Enrichment lanes minted ${minting.minted} NEW asset(s) vs ${minting.updated} update(s) ` +
+                    `(${Math.round(minting.share * 100)}% minted, threshold ${Math.round(ENRICHMENT_MINTED_WARN_SHARE * 100)}%). ` +
+                    "Enrichment-classed lanes (proactive/high-salience/high-retrieval/signal-delta) are ratified to edit " +
+                    "existing assets only — new-asset generation belongs to the signal-gated minting lanes.",
+            });
+        }
+        // Churn: accepted proposals far exceeding distinct touched refs means the
+        // loop is repeatedly rewriting the same assets, not covering the corpus.
+        if (Number.isFinite(improveSummary.coverage.churnRatio) && improveSummary.coverage.churnRatio > 1.5) {
+            advisories.push({
+                name: "improve-churn-ratio",
+                status: "warn",
+                kind: "deterministic",
+                confidence: "high",
+                message: `Improve churn ratio ${improveSummary.coverage.churnRatio} > 1.5: ` +
+                    `${improveSummary.coverage.acceptedProposals} accepted proposals touched only ` +
+                    `${improveSummary.coverage.distinctRefs} distinct assets in the window — ` +
+                    "repeated rewrites of the same refs count as churn, not coverage.",
+            });
+        }
         // R5 collapse/churn detector: surface any collapse_detector_alert events
         // in the health window, plus the latest cycle row's headline numbers so
         // the operator can act without opening the DB. `unknown` when the detector

package/dist/commands/improve/outcome-loop.js

@@ -2,12 +2,6 @@
 // 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/.
 // ── Constants ─────────────────────────────────────────────────────────────────
-/**
- * Weight on the "retrieved-but-never-improved" penalty term. Setting this to
- * 0 degrades to a pure prediction-error score (no quality filter); setting it
- * to 1 heavily penalises assets whose retrievals never led to accepted changes.
- */
-export const OUTCOME_PENALTY_WEIGHT = 0.3;
 /**
  * EMA decay factor for the expected-retrieval rolling mean (α).
  * New expected = α × new_count + (1−α) × old_expected.
@@ -95,12 +89,8 @@ export function updateAssetOutcome(db, inputs) {
         //
         // retrieval_delta = current − stored (non-negative — we never go backwards)
         const retrievalDelta = Math.max(0, inputs.currentRetrievalCount - existing.retrieval_count);
-        // accepted_change_rate = accepted_count / max(1, retrieval_count)
-        const acceptedChangeRate = inputs.acceptedChangeCount / Math.max(1, inputs.currentRetrievalCount);
         // Differential prediction-error term:
-        // outcome = (retrieval_delta − expected_delta)
-        //           − PENALTY × retrieval_delta × (1 − accepted_change_rate)
-        //           + valence
+        // outcome = (retrieval_delta − expected_delta) + valence
         //
         // Prediction error is computed against the PRIOR stored EMA (before folding
         // in this cycle's observation), so the current delta cannot leak into its own
@@ -111,10 +101,9 @@ export function updateAssetOutcome(db, inputs) {
         // expected' = α × delta + (1−α) × prior_expected
         expectedRetrievalRate =
             OUTCOME_EMA_ALPHA * retrievalDelta + (1 - OUTCOME_EMA_ALPHA) * existing.expected_retrieval_rate;
-        const penalty = OUTCOME_PENALTY_WEIGHT * retrievalDelta * (1 - acceptedChangeRate);
         // Running sum (EMA approach): new score = α × update + (1−α) × old
         // so the score tracks the moving signal, not the cumulative sum.
-        const rawUpdate = predictionError - penalty + valence;
+        const rawUpdate = predictionError + valence;
         const newScore = OUTCOME_EMA_ALPHA * rawUpdate + (1 - OUTCOME_EMA_ALPHA) * existing.outcome_score;
         // Clip to [OUTCOME_SCORE_MIN, OUTCOME_SCORE_MAX] — the ceiling is the RPE
         // saturation analog (G2): without it, long-lived popular assets accumulate
@@ -223,6 +212,17 @@ export function outcomeScoreToSalience(outcomeScore, maxScore) {
     // Apply diversity floor.
     return Math.max(DIVERSITY_FLOOR_FRACTION, normalised);
 }
+// ── Proxy-adequacy tripwire ───────────────────────────────────────────────────
+/**
+ * Dead-proxy threshold: |corr| below this means outcome_score carries no
+ * information about improvement need (pure noise).
+ */
+export const PROXY_DEAD_CORR_THRESHOLD = 0.1;
+/**
+ * Minimum sample size before the dead-proxy check fires. Below this, a
+ * near-zero correlation is indistinguishable from small-sample noise.
+ */
+export const PROXY_DEAD_MIN_N = 500;
 /**
  * Compute `corr(outcome_score, accepted_change_rate)` across all asset_outcome
  * rows. Returns `{correlation: NaN, n, isInverted: false}` when there is
@@ -238,7 +238,7 @@ export function outcomeScoreToSalience(outcomeScore, maxScore) {
 export function computeProxyAdequacy(rows) {
     const n = rows.length;
     if (n < 3)
-        return { correlation: Number.NaN, n, isInverted: false };
+        return { correlation: Number.NaN, n, isInverted: false, isDead: false };
     // accepted_change_rate per row.
     const xs = rows.map((r) => r.outcome_score);
     const ys = rows.map((r) => r.accepted_change_count / Math.max(1, r.retrieval_count));
@@ -259,10 +259,12 @@ export function computeProxyAdequacy(rows) {
     varY /= n;
     const denom = Math.sqrt(varX) * Math.sqrt(varY);
     if (denom < 1e-12)
-        return { correlation: Number.NaN, n, isInverted: false };
+        return { correlation: Number.NaN, n, isInverted: false, isDead: false };
     const correlation = covXY / denom;
     // Inverted proxy: negative correlation between outcome and accepted_change_rate
     // means high-outcome assets are also high-need — the opposite of "useful".
     const isInverted = correlation < -0.3;
-    return { correlation, n, isInverted };
+    // Dead proxy: near-zero correlation at scale — the score is noise.
+    const isDead = n >= PROXY_DEAD_MIN_N && Math.abs(correlation) < PROXY_DEAD_CORR_THRESHOLD;
+    return { correlation, n, isInverted, isDead };
 }

package/dist/commands/improve/preparation.js

@@ -27,7 +27,7 @@ import { computeValenceScore, FEEDBACK_WEIGHT, UTILITY_WEIGHT } from "./feedback
 import { makeGateConfig, resolveExtractConfidence, runAutoAcceptGate } from "./improve-auto-accept.js";
 import { resolveProcessEnabled } from "./improve-profiles.js";
 import { applyMemoryCleanup } from "./memory/memory-improve.js";
-import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
+import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, OUTCOME_SCORE_MAX, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
 import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
 // ── improve preparation stage ───────────────────────
@@ -1358,8 +1358,13 @@ export async function runImprovePreparationStage(args) {
                     if (row.outcome_score > maxOutcomeScore)
                         maxOutcomeScore = row.outcome_score;
                 }
-                // Proxy-adequacy tripwire: emit a health event if outcome_score is
-                // negatively correlated with accepted_change_rate (inverted proxy).
+                // Read-clip: legacy rows written before the OUTCOME_SCORE_MAX write-clip
+                // existed can sit above the ceiling (live max was 3.13). Without this
+                // clip they inflate the normalisation denominator and floor everyone
+                // else's outcomeSalience (#691 follow-up).
+                maxOutcomeScore = Math.min(maxOutcomeScore, OUTCOME_SCORE_MAX);
+                // Proxy-adequacy tripwire (two-tailed): inverted (corr < −0.3) and
+                // dead (|corr| < 0.1 at n ≥ 500) both emit health events.
                 const adequacy = computeProxyAdequacy(allOutcomes);
                 if (adequacy.isInverted) {
                     appendEvent({
@@ -1372,6 +1377,17 @@ export async function runImprovePreparationStage(args) {
                         },
                     }, eventsCtx);
                 }
+                if (adequacy.isDead) {
+                    appendEvent({
+                        eventType: "outcome_proxy_dead",
+                        ref: undefined,
+                        metadata: {
+                            correlation: adequacy.correlation,
+                            n: adequacy.n,
+                            note: "|corr(outcome_score, accepted_change_rate)| < 0.1 at n ≥ 500: outcome_score is statistically unrelated to improvement outcomes — the proxy is noise, not signal. Rank contributions derived from it are not currently informative.",
+                        },
+                    }, eventsCtx);
+                }
             }
             catch {
                 // best-effort: tripwire failure never blocks ranking

package/dist/commands/read/curate.js

@@ -58,7 +58,7 @@ const CURATE_REFERENCE_QUERY_RE = /\b(?:reference|docs?|guide|how|explain|learn|
  * Fire-and-forget: log a curate event to the usage_events table and events.jsonl.
  * Never blocks the caller; errors are silently ignored.
  */
-function logCurateEvent(query, result) {
+function logCurateEvent(query, result, eventSource = "user") {
     const itemRefs = result.items.map((item) => ("ref" in item ? item.ref : `registry:${item.id}`));
     appendEvent({
         eventType: "curate",
@@ -73,7 +73,7 @@ function logCurateEvent(query, result) {
                     itemCount: result.items.length,
                     itemRefs,
                 }),
-                source: "user",
+                source: eventSource,
             });
             for (const item of result.items) {
                 if (!("ref" in item) || typeof item.ref !== "string")
@@ -82,7 +82,7 @@ function logCurateEvent(query, result) {
                     event_type: "curate",
                     query,
                     entry_ref: item.ref,
-                    source: "user",
+                    source: eventSource,
                 });
             }
         }, { busyTimeoutMs: TELEMETRY_BUSY_TIMEOUT_MS });
@@ -106,7 +106,7 @@ export async function akmCurate(options) {
             source,
         }));
     const result = await curateSearchResults(options.query, searchResponse, limit, options.type);
-    logCurateEvent(options.query, result);
+    logCurateEvent(options.query, result, options.eventSource);
     return result;
 }
 export async function curateSearchResults(query, result, limit, selectedType) {

package/dist/commands/read/search-cli.js

@@ -21,13 +21,15 @@ import { getHyphenatedBoolean, getOutputMode, parseFlagValue } from "../../outpu
 import { akmCurate } from "./curate.js";
 import { akmSearch, parseBeliefFilterMode, parseScopeFilterFlags, parseSearchSource } from "./search.js";
 import { akmShowUnified } from "./show.js";
-// AKM_EVENT_SOURCE attributes a query to a `user` invocation or the internal
-// `improve` loop so the event log can distinguish them; any other value is
-// treated as unset.
+// AKM_EVENT_SOURCE attributes a query to a `user` invocation, the internal
+// `improve` loop, or the `task` runner so the event log can distinguish
+// genuine demand from machine traffic; any other value is treated as unset.
 function resolveEventSource() {
     const raw = process.env.AKM_EVENT_SOURCE;
     if (raw === "improve")
         return "improve";
+    if (raw === "task")
+        return "task";
     if (raw === "user")
         return "user";
     return undefined;
@@ -129,7 +131,7 @@ export const curateCommand = defineJsonCommand({
         const limitParsed = parsePositiveIntFlag(args.limit ?? undefined);
         const limit = limitParsed && limitParsed > 0 ? limitParsed : 4;
         const source = parseSearchSource(args.source ?? "stash");
-        const curated = await akmCurate({ query: args.query, type, limit, source });
+        const curated = await akmCurate({ query: args.query, type, limit, source, eventSource: resolveEventSource() });
         output("curate", curated);
     },
 });

package/dist/commands/read/search.js

@@ -16,8 +16,8 @@ import { rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { isTransientStashPath } from "../../core/paths.js";
 import { bumpUtilityScoresBatch, getEntryIdByFilePath } from "../../indexer/db/db.js";
+import { resolveReadSources } from "../../indexer/read-preflight.js";
 import { searchLocal } from "../../indexer/search/db-search.js";
-import { resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
 // Eagerly import source providers to trigger self-registration before the
 // indexer or path-resolution code runs.
@@ -57,7 +57,7 @@ export async function akmSearch(input) {
     else {
         source = parsedSource;
     }
-    let allSources = resolveSourceEntries(undefined, config);
+    let allSources = resolveReadSources(undefined, config).sources;
     // When a named source was requested, narrow the sources list to just that entry.
     // `resolveSourceEntries` sets `registryId` to `entry.name` for each config source.
     if (namedSourceName !== undefined) {
@@ -243,7 +243,11 @@ function logSearchEvent(query, response, mode = "keyword", eventSource = "user",
             }
             // Bump utility scores for all resolved entries (MemRL retrieval signal).
             // The indexer overwrites these at next reindex; bumps are temporary hints.
-            const resolvedIds = resolved.map((r) => r.entryId).filter((id) => id !== undefined);
+            // Gated to user-sourced events: pipeline searches (improve probes, task
+            // runner) must not feed the utility signal (meta-review 05 DRIFT-6 —
+            // the bump previously fired unconditionally, so even correctly-tagged
+            // machine traffic inflated utility).
+            const resolvedIds = eventSource === "user" ? resolved.map((r) => r.entryId).filter((id) => id !== undefined) : [];
             if (resolvedIds.length > 0) {
                 let scopeKey;
                 try {