akm-cli 0.9.17-alpha.2 → 0.9.17-alpha.4

package/dist/commands/improve/memory/derived-ref.js

@@ -1,61 +1,22 @@
 // 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/.
-/**
- * The single, keyed-on-ref implementation of "is this a derived memory?" and
- * "which parent does it derive from?" (R12).
- *
- * Two divergent copies previously lived side by side — the CONSUMER
- * (`memory-improve.ts`, keyed on the memory name) and the PRODUCER
- * (`memory-contradiction-detect.ts`, keyed on the file path). The producer's
- * copy was strictly narrower: it ignored `derivedFrom` entirely and matched
- * `source:` through a separate parser. That let the producer and consumer
- * disagree on a memory's parent — the exact defect plan §6 calls out
- * ("producer/consumer cannot disagree").
- *
- * Both sides now share this one impl, keyed on the memory NAME (the stash-
- * relative path without the `.md` extension, e.g. `nested/foo.derived`). The
- * producer converts its file path to a name via `toMemoryRef` before calling
- * in. Adopting it on the producer side is an INTENTIONAL widening, pinned by
- * `tests/commands/improve/derived-ref.test.ts`:
- *   - `derivedFrom`-keyed families now resolve a parent (and so participate in
- *     contradiction detection); and
- *   - `source:` is parsed through `parseRefInput` so current bundle-qualified
- *     refs resolve consistently.
- *
- * Resolution order (source → derivedFrom → `.derived` suffix) matches the
- * consumer's prior behaviour exactly, so the consumer side is a pure move.
- */
+/** The one implementation of "is this a derived memory, and what is its parent?" (R12), keyed on the memory name. */
 import { conceptIdFromTypeName, parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { asNonEmptyString } from "../../../core/common.js";
 import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
 /**
- * Parse a belief edge (`supersededBy` / `contradictedBy` / `currentBeliefRefs`)
- * to the bare memory name the identity channel keys on.
- *
- * Accepts BOTH spellings, because both reach this function:
- *   - `memory:<name>` — the internal identity spelling, and what belief edges
- *     written before 0.9.0 carry on disk;
- *   - `memories/<name>` / `<bundle>//memories/<name>` — the conceptId grammar
- *     the current writers emit (`akm remember --supersedes` and `akm import
- *     --supersedes` go through `writeSupersededEdge` with the write result's
- *     `ref`, which is fully qualified).
- *
- * Accepting only the first spelling silently reduced every edge written by the
- * current code path to nothing, so a superseded memory read back as active.
- * Both normalize to the bare name; the caller re-mints the internal
- * `memory:<name>` form via {@link memoryIdentityRef}, so there is still exactly
- * one identity spelling downstream.
+ * A belief edge (`supersededBy` / `contradictedBy` / `currentBeliefRefs`) as a
+ * bare memory name. Both spellings occur: `memory:<name>` (pre-0.9 edges) and
+ * `[bundle//]memories/<name>` (what `--supersedes` writes today); accepting only
+ * the first once read every superseded memory back as active.
  */
 export function parseMemoryName(value) {
     if (!value)
         return undefined;
     const trimmed = value.trim();
-    const MEMORY_PREFIX = "memory:";
-    if (trimmed.startsWith(MEMORY_PREFIX)) {
-        const name = trimmed.slice(MEMORY_PREFIX.length);
-        return name.length > 0 ? name : undefined;
-    }
+    if (trimmed.startsWith("memory:"))
+        return trimmed.slice("memory:".length) || undefined;
     try {
         const parsed = parseRefInput(trimmed);
         return parsed.type === "memory" && parsed.name.length > 0 ? parsed.name : undefined;
@@ -64,10 +25,7 @@ export function parseMemoryName(value) {
         return undefined;
     }
 }
-/**
- * Parse a current `source:` backref and return its canonical memory conceptId,
- * or `undefined` when it is empty, invalid, or not a memory ref.
- */
+/** A `source:` backref as a memory conceptId, or `undefined` when it is not a memory ref. */
 export function parseMemoryRef(value) {
     if (!value)
         return undefined;
@@ -79,37 +37,15 @@ export function parseMemoryRef(value) {
         return undefined;
     }
 }
-/**
- * Format a bare memory name into the belief-edge IDENTITY channel ref
- * `memory:<name>` — the ONE implementation of that spelling.
- *
- * Belief-edge / identity
- * channel (`contradictedBy` / `supersededBy` / `currentBeliefRefs`, and a derived
- * memory's own `record.ref`) uses `memory:<name>` and is compared against a
- * derived memory's identity ref. This channel is separate from `source:` asset
- * refs, which use `memories/<name>`. Both `memory-improve.ts` (`refArray`) and
- * `memory-contradiction-detect.ts` (`toMemoryRef`) emit through here so the
- * identity spelling has one implementation.
- */
+/** The belief-edge identity spelling, `memory:<name>` (separate from `source:` asset refs). */
 export function memoryIdentityRef(name) {
     return `memory:${name}`;
 }
-/**
- * True when the named memory is a derived/inferred child — either it carries
- * `inferred: true` in its frontmatter or its name ends with the structural
- * `.derived` suffix.
- */
+/** Inferred (`inferred: true`) or named with the `.derived` suffix. */
 export function isDerivedMemory(name, frontmatter) {
     return frontmatter.inferred === true || name.endsWith(DERIVED_SUFFIX);
 }
-/**
- * Resolve the parent (source) memory ref for a derived memory as a canonical
- * `memories/<name>` conceptId, or `undefined` when none
- * can be determined. Precedence:
- *   1. `frontmatter.source` (normalised through {@link parseMemoryRef});
- *   2. `frontmatter.derivedFrom` (a bare memory name → `memories/<name>`);
- *   3. the `.derived` name suffix, stripped → `memories/<name>`.
- */
+/** A derived memory's parent conceptId: from `source`, else `derivedFrom`, else the name minus `.derived`. */
 export function resolveParentRef(name, frontmatter) {
     const fromSource = parseMemoryRef(asNonEmptyString(frontmatter.source));
     if (fromSource)
@@ -117,8 +53,7 @@ export function resolveParentRef(name, frontmatter) {
     const derivedFrom = asNonEmptyString(frontmatter.derivedFrom);
     if (derivedFrom)
         return conceptIdFromTypeName("memory", derivedFrom);
-    if (name.endsWith(DERIVED_SUFFIX)) {
+    if (name.endsWith(DERIVED_SUFFIX))
         return conceptIdFromTypeName("memory", name.slice(0, -DERIVED_SUFFIX.length));
-    }
     return undefined;
 }

package/dist/commands/improve/memory/memory-belief.js

@@ -2,141 +2,37 @@
 // 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/.
 /**
- * Shared memory belief-state machinery (C-3 / #382).
- *
- * Extracted from `memory-improve.ts` so both `akmConsolidate` and
- * `analyzeMemoryCleanup` can emit `MemoryBeliefTransitionLogRecord` entries
- * through a unified state-transition model.
- *
- * # Design
- *
- * The 4-state belief lifecycle (active → superseded | contradicted → archived)
- * was previously encoded only in `memory-improve.ts`. `akmConsolidate` used a
- * flat merge/delete/promote model with no belief states, causing the two engines
- * to diverge. This module:
- *
- *   1. Re-exports the belief-state types from `memory-improve.ts` so callers
- *      can import from one canonical location.
- *   2. Provides `writeContradictEdge` — a shared primitive that both engines
- *      use when an LLM (or heuristic) identifies a contradiction between two
- *      memories. This is the bridge between `akmConsolidate`'s LLM-detected
- *      contradictions and `resolveFamilyContradictions`' SCC resolver.
- *
- * # References
- *
- * - Zep / Graphiti (arXiv:2501.13956 §3) — unified belief-revision pipeline
- * - MemOS (arXiv:2507.03724) — formal archive/merge/transition with shared state model
+ * Belief-state edge writer (#382): append a `supersededBy` edge to an asset's
+ * frontmatter and demote its `beliefState`, metadata only. Idempotent (a
+ * present edge AND demotion is a no-op; an edge without its demotion is
+ * repaired) and never weakens a stronger demotion — severity is
+ * superseded > contradicted > archived, per the ranker's `beliefStateBoost`.
+ * The SCC resolver in memory-improve.ts is a state-transition writer (it
+ * replaces and clears edges) and deliberately does not use this (#885).
  */
 import { mutateFrontmatter } from "../../../core/asset/frontmatter.js";
-// ── Shared edge-list reader ───────────────────────────────────────────────────
 /**
- * Read a frontmatter edge value (`supersededBy` / `contradictedBy`) as a
- * string list, promoting a scalar string to a one-element list.
- *
- * Scalar edges are LIVE data: the indexer's `normalizeNonEmptyStringList`
- * accepts them and lint deliberately never flags them. An Array.isArray-only
- * read treats a scalar as "no existing edges" and silently destroys the edge
- * on the next merge — mirror `mergeXrefsIntoContent`'s scalar promotion
- * instead.
+ * An edge value as a list. A scalar string is live data (the indexer accepts
+ * it), so it is promoted rather than dropped on the next write.
  */
 function readEdgeList(value) {
-    if (Array.isArray(value)) {
+    if (Array.isArray(value))
         return value.filter((v) => typeof v === "string" && v.trim().length > 0);
-    }
     if (typeof value === "string" && value.trim())
         return [value.trim()];
     return [];
 }
-// ── Contradiction edge writer ─────────────────────────────────────────────────
-/**
- * Write `contradictedBy` and `beliefState: contradicted` edges to a memory
- * file's frontmatter (C-3 / #382).
- *
- * The shared primitive for APPENDING one contradiction edge. Used by
- * `memory-contradiction-detect.ts`'s automated contradiction pass.
- *
- * NOT used by `persistBeliefStateTransition` in `memory-improve.ts`, and that
- * is deliberate (#885): the SCC resolver is a state-TRANSITION writer, not an
- * edge appender. It replaces `contradictedBy` wholesale from recomputed
- * `currentBeliefRefs`, deletes the key when a memory transitions away from
- * `contradicted`, and moves a memory to any target state including back to
- * active. An append-only primitive that never weakens a demotion cannot
- * express those, and routing it through this would break the resolver's
- * ability to clear an edge.
- *
- * Idempotent: if the `contradictedByRef` is already in `contradictedBy` AND
- * the file already carries the demotion state, the file is not rewritten. The
- * guard is state-aware like its sibling {@link writeSupersededEdge}: an edge
- * present WITHOUT the demotion (e.g. a hand-written `contradictedBy:` line,
- * or a beliefState lost to a partial edit) is repaired, not skipped — an
- * edge-only guard would make such a file a permanent no-op while
- * contradiction writers report the contradiction as applied.
- *
- * Never weakens a stronger demotion: `archived` ranks BELOW `contradicted`
- * (see `BELIEF_STATE_SCORE_CEILINGS` in
- * src/indexer/search/ranking-contributors.ts), so contradicting an archived
- * memory keeps `archived` and only appends the edge.
- *
- * @param filePath          - Absolute path to the memory markdown file.
- * @param contradictedByRef - The ref that contradicts this memory.
- * @returns `true` when the file was rewritten, `false` when the edge and the
- *          demotion were already present (the idempotent no-op). Callers count
- *          edges written from this.
- */
-export function writeContradictEdge(filePath, contradictedByRef) {
-    return mutateFrontmatter(filePath, (parsed) => {
-        const existing = readEdgeList(parsed.data.contradictedBy);
-        const currentState = parsed.data.beliefState;
-        const nextState = currentState === "archived" ? currentState : "contradicted";
-        if (existing.includes(contradictedByRef) && currentState === nextState) {
-            return null; // Already written — idempotent.
-        }
-        const nextContradictedBy = [...new Set([...existing, contradictedByRef])].sort();
-        return {
-            ...parsed.data,
-            contradictedBy: nextContradictedBy,
-            beliefState: nextState,
-        };
-    });
-}
-// ── Supersession edge writer ─────────────────────────────────────────────────
-/**
- * Write `supersededBy` and `beliefState: superseded` edges to an asset file's
- * frontmatter (SPEC-5, stash-conventions-code-spec.md).
- *
- * Sibling of {@link writeContradictEdge}: the shared primitive for the
- * conventions' corrections pattern — when a new asset supersedes an old one,
- * the old asset gets a METADATA-ONLY demotion edit (every other frontmatter
- * key and the body are preserved) so the ranker's beliefStateBoost demotes the
- * stale incumbent and `--belief current` hides it. Used by
- * `akm remember --supersedes` / `akm import --supersedes`.
- *
- * Idempotent: if `supersededByRef` is already in `supersededBy` and the file
- * is already demoted, the file is not rewritten. Multiple corrections
- * sorted-set-append their refs.
- *
- * Never WEAKENS an existing demotion: `contradicted` and `archived` rank
- * BELOW `superseded` (severity order deprecated > superseded > contradicted >
- * archived — see `BELIEF_STATE_SCORE_CEILINGS` in
- * src/indexer/search/ranking-contributors.ts), so superseding an already
- * contradicted/archived asset keeps the stronger state and only appends the
- * `supersededBy` edge.
- *
- * @param filePath        - Absolute path to the asset markdown file.
- * @param supersededByRef - The ref of the correction that supersedes this asset.
- */
+/** Mark an asset superseded by a correction (`akm remember|import --supersedes`). */
 export function writeSupersededEdge(filePath, supersededByRef) {
     mutateFrontmatter(filePath, (parsed) => {
         const existing = readEdgeList(parsed.data.supersededBy);
         const currentState = parsed.data.beliefState;
         const nextState = currentState === "contradicted" || currentState === "archived" ? currentState : "superseded";
-        if (existing.includes(supersededByRef) && currentState === nextState) {
-            return null; // Already written — idempotent.
-        }
-        const nextSupersededBy = [...new Set([...existing, supersededByRef])].sort();
+        if (existing.includes(supersededByRef) && currentState === nextState)
+            return null;
         return {
             ...parsed.data,
-            supersededBy: nextSupersededBy,
+            supersededBy: [...new Set([...existing, supersededByRef])].sort(),
             beliefState: nextState,
         };
     });

package/dist/commands/improve/memory/memory-improve.js

@@ -12,6 +12,7 @@ import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
 import { warn } from "../../../core/warn.js";
 import { recordWrittenPath } from "../../../core/write-provenance.js";
 import { walkMarkdownFiles } from "../../../indexer/walk/walker.js";
+import { contentHash } from "../content-hash.js";
 import { isDerivedMemory, memoryIdentityRef, parseMemoryName, resolveParentRef } from "./derived-ref.js";
 export function analyzeMemoryCleanup(stashDir, options = {}) {
     const records = collectDerivedMemories(stashDir, options.parentRef);
@@ -676,7 +677,7 @@ function resolveBeliefState(frontmatter) {
 // firstExistingRef's byRef map), so they are NORMALIZED to `memory:<name>` here.
 // On disk they arrive in either spelling — `memory:<name>` from pre-0.9.0
 // writes, or the `[<bundle>//]memories/<name>` conceptId that
-// `writeSupersededEdge`/`writeContradictEdge` persist today — and
+// `writeSupersededEdge` persists today — and
 // `parseMemoryName` accepts both. Reading only the first spelling silently
 // dropped every edge the current write path produces.
 function refArray(value) {
@@ -697,13 +698,13 @@ function refArray(value) {
     return [...refs].sort();
 }
 function buildFingerprint(title, description, tags, searchHints, body) {
-    return JSON.stringify({
+    return contentHash(JSON.stringify({
         title: normalizeSignal(title),
         description: normalizeSignal(description),
         tags: normalizeList(tags),
         searchHints: normalizeList(searchHints),
         body: normalizeBody(body),
-    });
+    }));
 }
 function normalizeBody(value) {
     return value

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

@@ -2,85 +2,37 @@
 // 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 { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef, upsertAssetOutcome, } from "../../storage/repositories/outcome-repository.js";
-// ── Constants ─────────────────────────────────────────────────────────────────
-/**
- * EMA decay factor for the expected-retrieval rolling mean (α).
- * New expected = α × new_count + (1−α) × old_expected.
- * At α = 0.3 the window is ≈ 3 cycles.
- */
+/** EMA factor for both the score and the expected retrieval delta (≈ a 3-cycle window). */
 export const OUTCOME_EMA_ALPHA = 0.3;
-/**
- * Warm-start cap: the maximum `outcome_score` a brand-new row can be seeded with
- * (from the utility EMA). Prevents a `[0,1]`-range utility value from generating
- * a score that the first negative delta could catastrophically invert. Clipped to
- * the maximum plausible first differential update: `max(0, 1 − 0) = 1`, so cap
- * at a modest 0.3 to avoid spurious rank-flip on first cycle.
- */
+/** The most a new row can be seeded with, so the first negative delta cannot flip the rank. */
 export const WARM_START_CAP = 0.3;
-/**
- * Penalty cap: the minimum outcome_score is capped at this value so a single
- * very-negative run can't send the score to −∞.
- */
 export const OUTCOME_SCORE_MIN = -1.0;
-/**
- * Saturation ceiling: the maximum outcome_score. Biological RPE saturates —
- * a fully predicted reward produces zero response, not an ever-growing one —
- * so a long-lived popular asset must not accrue unbounded outcome mass that
- * would dominate ranking once the outcome weight is enabled (analysis G2).
- * 1.5 comfortably exceeds the max plausible single-cycle raw update while
- * keeping the normalised outcomeSalience spread meaningful.
- */
+/** Saturation: a long-popular asset must not accrue unbounded outcome mass. */
 export const OUTCOME_SCORE_MAX = 1.5;
-/**
- * Diversity floor: `outcomeSalience` for any asset is at least this fraction
- * of the maximum observed `outcome_score` in the table, so rare-but-correct
- * assets cannot be permanently outcompeted. 0 = disabled (pure competition).
- */
+/** `outcomeSalience` never drops below this fraction of the stash-wide maximum. */
 export const DIVERSITY_FLOOR_FRACTION = 0.1;
-/**
- * Project the next outcome values without touching storage. Dry planning and
- * the live writer both call this function, so rank inputs cannot drift merely
- * because one caller persists the projection and the other does not.
- */
+export { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef };
+/** The next outcome values, without storage — dry planning and the writer share it. */
 export function projectAssetOutcome(existing, inputs) {
-    const valence = inputs.valence ?? 0;
-    const isNewRow = existing === undefined;
-    let outcomeScore;
-    let expectedRetrievalRate;
-    if (isNewRow) {
-        const seedScore = Math.min(WARM_START_CAP, Math.max(0, inputs.utilityScore ?? 0));
-        outcomeScore = seedScore;
-        expectedRetrievalRate = 0;
+    if (existing === undefined) {
+        return {
+            outcomeScore: Math.min(WARM_START_CAP, Math.max(0, inputs.utilityScore ?? 0)),
+            expectedRetrievalRate: 0,
+            isNewRow: true,
+        };
     }
-    else {
-        const retrievalDelta = Math.max(0, inputs.currentRetrievalCount - existing.retrieval_count);
-        const expectedDelta = existing.expected_retrieval_rate;
-        const predictionError = retrievalDelta - expectedDelta;
-        expectedRetrievalRate =
-            OUTCOME_EMA_ALPHA * retrievalDelta + (1 - OUTCOME_EMA_ALPHA) * existing.expected_retrieval_rate;
-        const rawUpdate = predictionError + valence;
-        const newScore = OUTCOME_EMA_ALPHA * rawUpdate + (1 - OUTCOME_EMA_ALPHA) * existing.outcome_score;
-        outcomeScore = Math.min(OUTCOME_SCORE_MAX, Math.max(OUTCOME_SCORE_MIN, newScore));
-    }
-    return { outcomeScore, expectedRetrievalRate, isNewRow };
+    const retrievalDelta = Math.max(0, inputs.currentRetrievalCount - existing.retrieval_count);
+    const rawUpdate = retrievalDelta - existing.expected_retrieval_rate + (inputs.valence ?? 0);
+    const newScore = OUTCOME_EMA_ALPHA * rawUpdate + (1 - OUTCOME_EMA_ALPHA) * existing.outcome_score;
+    return {
+        outcomeScore: Math.min(OUTCOME_SCORE_MAX, Math.max(OUTCOME_SCORE_MIN, newScore)),
+        expectedRetrievalRate: OUTCOME_EMA_ALPHA * retrievalDelta + (1 - OUTCOME_EMA_ALPHA) * existing.expected_retrieval_rate,
+        isNewRow: false,
+    };
 }
-/**
- * Upsert one asset's outcome row.
- *
- * On first call for a ref (no prior row): warm-starts from `utilityScore`.
- * On subsequent calls: applies the differential update formula.
- *
- * Returns the resulting `outcome_score` so the caller can pass it to
- * `computeSalience` without a second read.
- */
+/** Upsert one asset's outcome row; returns the score for the salience vector. */
 export function updateAssetOutcome(db, inputs) {
-    const now = inputs.now ?? Date.now();
-    const existing = getAssetOutcome(db, inputs.ref);
-    const projection = projectAssetOutcome(existing, inputs);
-    // Upsert the row. See `upsertAssetOutcome` in
-    // storage/repositories/outcome-repository.ts (#672 part 2) for the SQL text
-    // and the `review_pressure` omission rationale — this call site is
-    // unchanged in intent, just no longer inline.
+    const projection = projectAssetOutcome(getAssetOutcome(db, inputs.ref), inputs);
     upsertAssetOutcome(db, {
         ref: inputs.ref,
         lastRetrievedAt: inputs.lastRetrievedAt,
@@ -89,97 +41,17 @@ export function updateAssetOutcome(db, inputs) {
         negativeFeedbackCount: inputs.negativeFeedbackCount,
         acceptedChangeCount: inputs.acceptedChangeCount,
         outcomeScore: projection.outcomeScore,
-        updatedAt: now,
+        updatedAt: inputs.now ?? Date.now(),
     });
     return { outcomeScore: projection.outcomeScore, isNewRow: projection.isNewRow };
 }
-// ── Reader ────────────────────────────────────────────────────────────────────
-//
-// getAssetOutcome / getAllAssetOutcomes / getOutcomeScoresByRef moved verbatim
-// to storage/repositories/outcome-repository.ts (#672 part 2) — re-exported
-// here so existing importers of this module resolve unchanged.
-export { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef };
-// ── outcomeSalience projection ────────────────────────────────────────────────
 /**
- * Convert a raw `outcome_score` (differential, may be negative) to a
- * `outcomeSalience` value in [0, 1] suitable for use in the salience projection.
- *
- * Approach:
- *   1. Clip negative scores to 0 (a negative outcome just means "below expected",
- *      not "irrelevant"; it should not harm the base retrieval/encoding ranking).
- *   2. Apply the diversity floor so rare-but-correct assets always retain a
- *      minimum `outcomeSalience` relative to the stash-wide maximum.
- *   3. Normalise by `maxScore` (the stash-wide max outcome_score) so the term
- *      lives in [0, 1]. When maxScore ≤ 0 (all seeds, nothing observed yet),
- *      return the floor (or 0 if DIVERSITY_FLOOR_FRACTION = 0).
- *
- * @param outcomeScore - Raw outcome_score from asset_outcome.
- * @param maxScore     - Maximum outcome_score across ALL rows (≥ 0 after clip).
- *                       Callers must compute this once per batch and pass it in.
+ * A raw outcome score as salience in [0, 1]: negatives clip to 0 (below
+ * expected is not irrelevant), normalized by the stash-wide maximum, never
+ * below the diversity floor.
  */
 export function outcomeScoreToSalience(outcomeScore, maxScore) {
-    const clipped = Math.max(0, outcomeScore);
-    if (maxScore <= 0) {
-        // No positive scores observed yet — return diversity floor.
+    if (maxScore <= 0)
         return DIVERSITY_FLOOR_FRACTION;
-    }
-    const normalised = clipped / 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
- * insufficient data (fewer than 3 rows or zero variance in either variable).
- *
- * A NEGATIVE correlation means: assets with a HIGH outcome_score have a LOW
- * accepted_change_rate — i.e. the assets the proxy rates as "doing well"
- * (frequently retrieved) are precisely the ones that rarely yield an accepted
- * improvement. That inverts the proxy: high outcome_score ≠ "doing well", so the
- * coarse retrieval-delta signal is no longer trustworthy and the 0.10+ rich
- * signal is due. (`isInverted = correlation < -0.3`.)
- */
-export function computeProxyAdequacy(rows) {
-    const n = rows.length;
-    if (n < 3)
-        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));
-    const meanX = xs.reduce((a, b) => a + b, 0) / n;
-    const meanY = ys.reduce((a, b) => a + b, 0) / n;
-    let covXY = 0;
-    let varX = 0;
-    let varY = 0;
-    for (let i = 0; i < n; i++) {
-        const dx = xs[i] - meanX;
-        const dy = ys[i] - meanY;
-        covXY += dx * dy;
-        varX += dx * dx;
-        varY += dy * dy;
-    }
-    covXY /= n;
-    varX /= n;
-    varY /= n;
-    const denom = Math.sqrt(varX) * Math.sqrt(varY);
-    if (denom < 1e-12)
-        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;
-    // 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 };
+    return Math.max(DIVERSITY_FLOOR_FRACTION, Math.max(0, outcomeScore) / maxScore);
 }

package/dist/commands/improve/planner.js

@@ -42,10 +42,7 @@ export function projectMemoryCleanup(input) {
         },
     };
 }
-/**
- * Apply the final global cap to an already-ranked candidate snapshot.
- * Replay remains additive to the ordinary cap, matching the live #610 rule.
- */
+/** Apply the final global cap to an already-ranked candidate snapshot. */
 export function selectEffectiveImproveRefs(args) {
     const distillOnlySet = new Set(args.distillOnlyRefs.map((entry) => entry.ref));
     const reflectAndDistill = args.rankedRefs.filter((entry) => !distillOnlySet.has(entry.ref));
@@ -53,10 +50,7 @@ export function selectEffectiveImproveRefs(args) {
     // Preserve the established live ordering: ordinary reflect-path refs first,
     // then distill-only refs, with the rank order stable inside each partition.
     const allLoopRefs = [...reflectAndDistill, ...distillOnly];
-    const replay = allLoopRefs.filter((entry) => entry.eligibilitySource === "replay");
-    const ordinary = allLoopRefs.filter((entry) => entry.eligibilitySource !== "replay");
-    const selectedOrdinary = args.limit === undefined ? ordinary : ordinary.slice(0, args.limit);
-    const loopRefs = [...selectedOrdinary, ...replay.slice(0, args.replayBudget)];
+    const loopRefs = args.limit === undefined ? allLoopRefs : allLoopRefs.slice(0, args.limit);
     return {
         loopRefs,
         distillOnlyRefs: distillOnly,
@@ -82,8 +76,9 @@ export function buildImproveExecutionPlan(input) {
         limits: {
             configured: { ...input.configuredLimits },
             ...(input.effectiveLimit !== undefined ? { effective: input.effectiveLimit } : {}),
-            additiveReplayAllowance: input.replayBudget,
-            ...(input.effectiveLimit !== undefined ? { totalCeiling: input.effectiveLimit + input.replayBudget } : {}),
+            // The replay lane is gone; the published plan keeps a zero allowance.
+            additiveReplayAllowance: 0,
+            ...(input.effectiveLimit !== undefined ? { totalCeiling: input.effectiveLimit } : {}),
         },
         gates: input.gates.map((gate) => ({ ...gate })),
         effectiveRefs,