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

package/dist/commands/improve/content-hash.js

@@ -1,23 +1,9 @@
 // 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/.
-/**
- * Shared memory-content hashing primitives, extracted from the deleted
- * `dedup.ts` (#617 dedup pre-pass, removed WI-7.3) so `consolidate.ts` /
- * `consolidate/chunking.ts` / `distill.ts` keep a stable, dependency-free home
- * for the case-preserving stripped-body hash they use for the body-embedding
- * cache and (formerly) the fidelity-check body comparison.
- *
- * @module content-hash
- */
 import { createHash } from "node:crypto";
-import { parseFrontmatter } from "../../core/asset/frontmatter.js";
-/**
- * Strip frontmatter from raw memory content, returning the body text trimmed.
- * Case and whitespace are preserved. Falls back to `raw.trim()` on
- * unparseable frontmatter (consistent with the pre-existing load-time hot
- * guard).
- */
+import { computeNormalizedContentHash, parseFrontmatter } from "../../core/asset/frontmatter.js";
+/** The markdown body with its frontmatter removed, trimmed (the raw text when it does not parse). */
 export function stripFrontmatterBody(raw) {
     try {
         return parseFrontmatter(raw).content.trim();
@@ -27,13 +13,19 @@ export function stripFrontmatterBody(raw) {
     }
 }
 /**
- * Hash used for change-detection and the body-embedding cache: case-/
- * whitespace-preserving stripped body. Two memories with the same wording
- * but different casing produce DIFFERENT hashes here, which is intentional —
- * we embed the exact text and cache by its precise content.
- *
- * This is the `content_hash` stored in `body_embeddings`.
+ * The one "is this the same content?" hash for improve and the proposal queue
+ * (sha256, hex):
+ *  - `raw`: the exact bytes — proposal before/after and judged-content hashes,
+ *    session transcripts, cache keys for plain text.
+ *  - `body`: the body without frontmatter, case and wording preserved — memory
+ *    and knowledge dedup and the body-embedding cache.
+ *  - `normalized`: the whole asset minus akm's bookkeeping frontmatter
+ *    (`BOOKKEEPING_FRONTMATTER_KEYS`), keys sorted — proposal freshness, so a
+ *    salience or inference rewrite of the target never stales a proposal.
  */
-export function cacheHash(raw) {
-    return createHash("sha256").update(stripFrontmatterBody(raw), "utf8").digest("hex");
+export function contentHash(content, mode = "raw") {
+    if (mode === "raw")
+        return createHash("sha256").update(content).digest("hex");
+    const text = typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+    return mode === "body" ? contentHash(stripFrontmatterBody(text)) : computeNormalizedContentHash(text);
 }

package/dist/commands/improve/distill/content-repair.js

@@ -1,33 +1,16 @@
 // 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/.
-/**
- * Pure content-repair + quality-validation stages for `akm distill`.
- *
- * Extracted verbatim from the inline body of `akmDistill` so each normalization
- * pass is an independently testable unit. Every function is a pure transform of
- * `(content, inputRef) → content | findings` with no I/O — logic is
- * byte-identical to the pre-extraction inline code. The lesson-path guard
- * (`effectiveProposalKind !== "knowledge"`) stays in the caller; these helpers
- * assume the lesson path.
- */
+/** Deterministic lesson repairs and checks for `akm distill` (pure; the caller keeps the lesson-path guard). */
 import { assembleAssetFromString, serializeFrontmatterQuoted } from "../../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
 import { repairTruncatedDescription } from "../../../core/text-truncation.js";
-import { detectDoubleFrontmatter, isValidDescription, isValidWhenToUse, } from "../../proposal/validators/proposal-quality-validators.js";
+import { isValidDescription, isValidWhenToUse, lessonQualityIssues, } from "../../proposal/validators/proposal-quality-validators.js";
 /**
- * Auto-repair missing frontmatter fields before hard-failing. Small models
- * frequently produce a good lesson body but omit the YAML header entirely.
- * Rather than discarding valid content, we extract description/when_to_use
- * from the body and prepend the required frontmatter block.
- *
- * IMPORTANT: We do NOT synthesise placeholder strings here. If the body
- * does not contain text that passes the post-LLM validators
- * (`isValidDescription` / `isValidWhenToUse`), we leave the field missing
- * and let the lesson lint reject the proposal as `validation_failed`.
- * Emitting placeholders like `"Lesson distilled from <ref>"` or
- * `"When working with <slug>"` is what produced the systematic broken
- * proposals observed across 323 archived rejections.
+ * Fill a missing description / when_to_use from body lines that pass their
+ * validators — small models often write a good body with no header. Never a
+ * placeholder: those produced hundreds of broken proposals; a field nothing
+ * qualifies for stays missing for lint to reject.
  */
 export function autoRepairLessonFrontmatter(content, inputRef) {
     const parsed = parseFrontmatter(content);
@@ -37,7 +20,6 @@ export function autoRepairLessonFrontmatter(content, inputRef) {
     if (!missingDesc && !missingWtu)
         return content;
     const body = parsed.content.trim();
-    // Strip markdown formatting tokens from a line so extracted text is clean.
     const stripMd = (l) => l
         .replace(/\*\*([^*]+)\*\*/g, "$1")
         .replace(/\*([^*]+)\*/g, "$1")
@@ -45,14 +27,9 @@ export function autoRepairLessonFrontmatter(content, inputRef) {
         .replace(/^[#*\->_]+\s*/, "")
         .replace(/:\s*$/, "")
         .trim();
-    // Skip lines that look like YAML field assignments (key: value) or frontmatter delimiters.
-    // These appear when the LLM leaks frontmatter content into the body, causing
-    // auto-repair to produce description: "description: Key Takeaways".
+    // Leaked frontmatter lines in the body would yield `description: "description: …"`.
     const isYamlLike = (l) => /^---/.test(l) || /^[a-z_]+:\s/i.test(l);
     const bodyLines = body.split("\n").map(stripMd);
-    // Extract description: first body line that BOTH looks like prose AND
-    // passes isValidDescription. If nothing qualifies, leave the field
-    // missing — the lint pass will reject the proposal cleanly.
     let descLine;
     for (const l of bodyLines) {
         if (isYamlLike(l))
@@ -64,8 +41,6 @@ export function autoRepairLessonFrontmatter(content, inputRef) {
             break;
         }
     }
-    // Extract when_to_use: a line starting with "When" / "Use when" / "Apply when"
-    // that ALSO passes isValidWhenToUse (rejects circular fallbacks).
     let wtuLine;
     for (const l of bodyLines) {
         if (!/^(when |use when|apply when)/i.test(l))
@@ -83,23 +58,15 @@ export function autoRepairLessonFrontmatter(content, inputRef) {
         ...(missingWtu && wtuLine ? { when_to_use: wtuLine } : {}),
     };
     const fmLines = serializeFrontmatterQuoted(repairedFm);
-    // Only rewrite content if we actually have at least one field to write.
-    // Otherwise leave the original content for the lint pass to reject.
     if (Object.keys(repairedFm).length > 0) {
         return assembleAssetFromString(fmLines, body);
     }
     return content;
 }
 /**
- * Description ↔ when_to_use auto-swap normalization (recover ~93% of
- * qwen-9b's `^when\b/i` rejections at zero LLM cost). When the LLM emits
- * a conditional-framed description ("When X happens, do Y") and the
- * when_to_use field looks like a declarative description (or is empty),
- * the two fields are mis-fielded — exactly what `isValidDescription`'s
- * error message says ("that pattern belongs in when_to_use"). We swap
- * them and revalidate; the swap is committed only if BOTH fields pass
- * their respective validators afterwards. If revalidation still fails,
- * we fall through returning the original content (swapped: 0).
+ * Swap a conditional description ("When X, do Y") with a declarative
+ * when_to_use — mis-fielded, as the description validator says — when both
+ * then pass; this recovers most `^when` rejections at no LLM cost.
  */
 export function autoSwapDescriptionWhenToUse(content, inputRef) {
     const parsedSwap = parseFrontmatter(content);
@@ -109,9 +76,6 @@ export function autoSwapDescriptionWhenToUse(content, inputRef) {
     const descStartsConditional = /^(when|if)\b/i.test(descRaw);
     const wtuStartsConditional = /^(when|if)\b/i.test(wtuRaw);
     if (descStartsConditional && !wtuStartsConditional && wtuRaw.length > 0) {
-        // Try the swap and revalidate. The when_to_use validator requires the
-        // value not match `/^when working with\b/i` (the circular fallback) —
-        // a real description rarely does, so this usually passes.
         const swappedDescCheck = isValidDescription(wtuRaw, inputRef);
         const swappedWtuCheck = isValidWhenToUse(descRaw, inputRef);
         if (swappedDescCheck.ok && swappedWtuCheck.ok) {
@@ -126,13 +90,7 @@ export function autoSwapDescriptionWhenToUse(content, inputRef) {
     }
     return { content, swapped: 0 };
 }
-/**
- * Post-generation truncation repair (#556): if the LLM sliced the
- * description mid-sentence, deterministically complete it from its own text
- * / the lesson body BEFORE the lint + quality validators run. No-op
- * (byte-identical) for already-complete descriptions, so this never alters
- * a valid proposal.
- */
+/** Complete a description cut mid-sentence from its own text or the body (#556); a complete one is untouched. */
 export function repairLessonDescriptionTruncation(content) {
     const parsedRepair = parseFrontmatter(content);
     const fmRepair = (parsedRepair.data ?? {});
@@ -145,52 +103,12 @@ export function repairLessonDescriptionTruncation(content) {
     const repairedFmLines = serializeFrontmatterQuoted({ ...fmRepair, description: repaired });
     return assembleAssetFromString(repairedFmLines, parsedRepair.content);
 }
-/**
- * Additional quality validators that run only on lessons whose lesson-lint
- * pass was clean. lesson-lint checks "field is present and non-empty"; these
- * reject the systematic failure modes observed across 323 archived rejected
- * proposals:
- *   - description is a body fragment, section heading, or placeholder
- *   - when_to_use is the circular "When working with <ref>" fallback
- *   - description == when_to_use (LLM duplicated a single sentence)
- *   - body contains a second pseudo-frontmatter block
- */
+/** The shared lesson quality checks, for a lesson whose lint pass was clean. */
 export function collectLessonQualityFindings(content, inputRef) {
-    const findings = [];
-    const parsedQC = parseFrontmatter(content);
-    const fmQC = (parsedQC.data ?? {});
-    const descCheck = isValidDescription(fmQC.description, inputRef);
-    if (!descCheck.ok) {
-        findings.push({
-            kind: "invalid-description",
-            field: "description",
-            message: `Distilled lesson for ${inputRef} has an invalid description: ${descCheck.reason}.`,
-        });
-    }
-    const wtuCheck = isValidWhenToUse(fmQC.when_to_use, inputRef);
-    if (!wtuCheck.ok) {
-        findings.push({
-            kind: "invalid-when_to_use",
-            field: "when_to_use",
-            message: `Distilled lesson for ${inputRef} has an invalid when_to_use: ${wtuCheck.reason}.`,
-        });
-    }
-    // description and when_to_use must say different things.
-    if (descCheck.ok &&
-        wtuCheck.ok &&
-        typeof fmQC.description === "string" &&
-        typeof fmQC.when_to_use === "string" &&
-        fmQC.description.trim().toLowerCase() === fmQC.when_to_use.trim().toLowerCase()) {
-        findings.push({
-            kind: "description-equals-when_to_use",
-            field: "description",
-            message: `Distilled lesson for ${inputRef} has identical description and when_to_use.`,
-        });
-    }
-    // Double-frontmatter / pseudo-frontmatter pollution in the body.
-    const dfm = detectDoubleFrontmatter(content);
-    if (dfm) {
-        findings.push({ kind: dfm.kind, field: "body", message: `Distilled lesson for ${inputRef}: ${dfm.message}` });
-    }
-    return findings;
+    const fm = (parseFrontmatter(content).data ?? {});
+    return lessonQualityIssues(fm, content, inputRef).map((issue) => ({
+        kind: issue.kind,
+        field: issue.field,
+        message: `Distilled lesson for ${inputRef}${issue.text}`,
+    }));
 }

package/dist/commands/improve/distill-guards.js

@@ -2,34 +2,12 @@
 // 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/.
 /**
- * WS-3b distill-stage guards.
- *
- * **CLS interleaving (step 9)**
- *   distill/memoryInference prompts include embedding-retrieved adjacent
- *   lessons/knowledge so the pipeline doesn't overwrite prior generalizations.
- *
- * **Distill→source fidelity (step 10)**
- *   After a distill proposal, check it against cited source memories; a
- *   contradiction flag routes to human review.
- *
- * @module distill-guards
+ * Distill guards: related lessons/knowledge shown to the model so it does not
+ * overwrite prior generalizations (CLS context), and a cheap check that a
+ * proposal does not contradict the memories it came from.
  */
-// ── CLS adjacent lesson context (step 9) ─────────────────────────────────────
-/** Default number of adjacent lessons/knowledge for CLS interleaving. */
 export const DEFAULT_CLS_ADJACENT_COUNT = 3;
-/**
- * Build a CLS (Complementary Learning System) context snippet for injection
- * into distill/memoryInference prompts.
- *
- * Given a list of embedding-retrieved adjacent lessons/knowledge, formats them
- * as a markdown section to append to the prompt so the LLM avoids overwriting
- * prior generalizations.
- *
- * Returns an empty string when CLS is disabled or no adjacent items are found.
- *
- * @param adjacentItems - Top-N adjacent lessons/knowledge retrieved by embedding.
- * @param config - CLS config.
- */
+/** The CLS prompt section (each entry capped at 400 chars); empty when disabled or nothing is related. */
 export function buildClsContext(adjacentItems, config) {
     if (!config.enabled || adjacentItems.length === 0)
         return "";
@@ -41,54 +19,23 @@ export function buildClsContext(adjacentItems, config) {
         "disagree with one, flag it as contradicted (do not ignore it).",
         "",
     ];
-    for (const item of adjacentItems) {
-        lines.push(`### ${item.ref}`);
-        // Truncate to 400 chars to keep the prompt size reasonable.
-        lines.push(item.content.trim().slice(0, 400));
-        lines.push("");
-    }
+    for (const item of adjacentItems)
+        lines.push(`### ${item.ref}`, item.content.trim().slice(0, 400), "");
     return lines.join("\n");
 }
 /**
- * Check a distill proposal against its cited source memories for contradictions.
- *
- * Uses a simple heuristic: looks for explicit negation of key claims in the
- * proposal body that appear in the source bodies. A full LLM-based
- * contradiction check is expensive (one LLM call per proposal); this cheap
- * heuristic catches the most obvious cases and flags them for human review.
- *
- * When `fidelityCheck.enabled` is false, returns `{ contradictionDetected: false }`
- * immediately (no work done).
- *
- * @param proposalBody - The stripped body of the distill proposal.
- * @param sourceBodies - The stripped bodies of the cited source memories.
- * @param config - Fidelity check config.
+ * Flag a proposal whose "always/must X" (or "never/must not X") claim meets
+ * the opposite claim about X in a source. Deliberately conservative: a flag
+ * only costs a human review, while a model call per proposal is expensive.
  */
 export function checkDistillFidelity(proposalBody, sourceBodies, config) {
-    if (!config.enabled || sourceBodies.length === 0) {
-        return { contradictionDetected: false };
-    }
-    // Heuristic: detect explicit negation of "never" / "always" / "must" claims.
-    // A proposal that says "always X" while the source says "never X" (or vice
-    // versa) is a clear contradiction worth flagging.
-    //
-    // This is intentionally conservative: it only flags when both the proposal
-    // AND the source contain the opposing polarity of the same key term. False
-    // negatives (missed contradictions) are preferred over false positives
-    // (blocking valid proposals) since the consequence of a false positive is
-    // a human review request, while the cost of a false negative is a slightly
-    // degraded stash.
-    const proposalLow = proposalBody.toLowerCase();
-    // Extract "always/never/must/must not" claims from the proposal.
-    const strongClaims = extractStrongClaims(proposalLow);
-    if (strongClaims.length === 0)
+    if (!config.enabled || sourceBodies.length === 0)
         return { contradictionDetected: false };
+    const strongClaims = extractStrongClaims(proposalBody.toLowerCase());
     for (const sourceBody of sourceBodies) {
         const sourceLow = sourceBody.toLowerCase();
         for (const { polarity, term } of strongClaims) {
-            const oppositePolarity = polarity === "positive" ? "negative" : "positive";
-            const sourceHasOpposite = hasStrongClaim(sourceLow, term, oppositePolarity);
-            if (sourceHasOpposite) {
+            if (hasStrongClaim(sourceLow, term, polarity === "positive" ? "negative" : "positive")) {
                 return {
                     contradictionDetected: true,
                     reason: `Proposal makes a ${polarity} strong claim about "${term}" that conflicts with an opposing claim in a cited source. Route to human review.`,
@@ -96,32 +43,24 @@ export function checkDistillFidelity(proposalBody, sourceBodies, config) {
             }
         }
     }
-    // Also flag proposals whose xrefs are empty (broken provenance).
-    // This is a degradation signal, not a contradiction, but worth surfacing.
     return { contradictionDetected: false };
 }
+const CLAIM_PATTERNS = [
+    { polarity: "positive", re: /\b(?:always|must)\s+(\w+)/g },
+    { polarity: "negative", re: /\b(?:never|must\s+not|should\s+not)\s+(\w+)/g },
+];
 function extractStrongClaims(text) {
     const claims = [];
-    // Match "always <term>", "never <term>", "must <term>", "must not <term>".
-    const patterns = [
-        { polarity: "positive", re: /\b(?:always|must)\s+(\w+)/g },
-        { polarity: "negative", re: /\b(?:never|must\s+not|should\s+not)\s+(\w+)/g },
-    ];
-    for (const { polarity, re } of patterns) {
-        re.lastIndex = 0;
-        let m = re.exec(text);
-        while (m !== null) {
+    for (const { polarity, re } of CLAIM_PATTERNS) {
+        for (const m of text.matchAll(re)) {
             const term = m[1];
             if (term && term.length > 2)
                 claims.push({ polarity, term });
-            m = re.exec(text);
         }
     }
     return claims;
 }
 function hasStrongClaim(text, term, polarity) {
-    if (polarity === "positive") {
-        return /\b(?:always|must)\s/.test(text) && text.includes(term);
-    }
-    return /\b(?:never|must\s+not|should\s+not)\s/.test(text) && text.includes(term);
+    const marker = polarity === "positive" ? /\b(?:always|must)\s/ : /\b(?:never|must\s+not|should\s+not)\s/;
+    return marker.test(text) && text.includes(term);
 }

package/dist/commands/improve/distill-promotion-policy.js

@@ -216,249 +216,29 @@ function assessWithWeightedModel(input, model, threshold) {
         modelName: model.name,
     };
 }
-function precision(tp, fp) {
-    return tp + fp === 0 ? 1 : tp / (tp + fp);
-}
-function recall(tp, fn) {
-    return tp + fn === 0 ? 1 : tp / (tp + fn);
-}
-function f1Score(p, r) {
-    return p + r === 0 ? 0 : (2 * p * r) / (p + r);
-}
-function casePromoteValue(testCase) {
-    return testCase.promoteValue ?? 3;
-}
-function caseFalsePromoteCost(testCase) {
-    return testCase.falsePromoteCost ?? 4;
-}
-function caseMissedPromoteCost(testCase) {
-    return testCase.missedPromoteCost ?? 2;
-}
-export function evaluateMemoryPromotionBenchmark(cases, policy = DEFAULT_PROMOTION_POLICY) {
-    const results = cases.map((fixture) => {
-        const assessment = policy.assess(fixture.input);
-        const passed = assessment.promote === fixture.expectPromote;
-        return {
-            fixture,
-            name: fixture.name,
-            expectPromote: fixture.expectPromote,
-            assessment,
-            passed,
-        };
-    });
-    const truePositives = results.filter((result) => result.assessment.promote && result.expectPromote).length;
-    const trueNegatives = results.filter((result) => !result.assessment.promote && !result.expectPromote).length;
-    const falsePositives = results.filter((result) => result.assessment.promote && !result.expectPromote).length;
-    const falseNegatives = results.filter((result) => !result.assessment.promote && result.expectPromote).length;
-    const correct = truePositives + trueNegatives;
-    const p = precision(truePositives, falsePositives);
-    const r = recall(truePositives, falseNegatives);
-    let netOutcomeScore = 0;
-    let capturedPromoteValue = 0;
-    let preventedFalsePromotionCost = 0;
-    for (const result of results) {
-        if (result.expectPromote && result.assessment.promote) {
-            const value = casePromoteValue(result.fixture);
-            netOutcomeScore += value;
-            capturedPromoteValue += value;
-        }
-        else if (result.expectPromote && !result.assessment.promote) {
-            netOutcomeScore -= caseMissedPromoteCost(result.fixture);
-        }
-        else if (!result.expectPromote && result.assessment.promote) {
-            netOutcomeScore -= caseFalsePromoteCost(result.fixture);
-        }
-        else {
-            preventedFalsePromotionCost += caseFalsePromoteCost(result.fixture);
-        }
-    }
-    return {
-        total: results.length,
-        correct,
-        falsePositives,
-        falseNegatives,
-        accuracy: results.length === 0 ? 1 : correct / results.length,
-        precision: p,
-        recall: r,
-        f1: f1Score(p, r),
-        truePositives,
-        trueNegatives,
-        netOutcomeScore,
-        capturedPromoteValue,
-        preventedFalsePromotionCost,
-        results: results.map(({ name, expectPromote, assessment, passed }) => ({
-            name,
-            expectPromote,
-            assessment,
-            passed,
-        })),
-    };
-}
-function thresholdCandidates() {
-    const values = [];
-    for (let value = 2.4; value <= 4.2; value += 0.2) {
-        values.push(Number(value.toFixed(1)));
-    }
-    return values;
-}
-const POSITIVE_FEEDBACK_BASELINE = {
-    name: "baseline-positive-feedback",
-    threshold: 2,
-    assess(input) {
-        const knowledgeRef = deriveKnowledgeRef(input.inputRef);
-        const featureState = collectPromotionFeatures(input);
-        if (featureState.blockedBy.length > 0) {
-            return {
-                applicable: !featureState.blockedBy.includes("not-memory"),
-                promote: false,
-                score: 0,
-                threshold: 2,
-                knowledgeRef,
-                blockedBy: featureState.blockedBy,
-                positiveSignals: [],
-                negativeSignals: [],
-                modelName: "baseline-positive-feedback",
-            };
-        }
-        const features = featureState.features;
-        const promote = features.positiveFeedback >= 2;
-        return {
-            applicable: true,
-            promote,
-            score: features.positiveFeedback,
-            threshold: 2,
-            knowledgeRef,
-            ...(promote ? { content: buildKnowledgeContent(input) } : {}),
-            blockedBy: [],
-            positiveSignals: promote ? ["baseline positive feedback rule"] : [],
-            negativeSignals: promote ? [] : ["baseline positive feedback rule not met"],
-            modelName: "baseline-positive-feedback",
-        };
-    },
-};
-const METADATA_BASELINE = {
-    name: "baseline-metadata",
-    threshold: 2,
-    assess(input) {
-        const knowledgeRef = deriveKnowledgeRef(input.inputRef);
-        const featureState = collectPromotionFeatures(input);
-        if (featureState.blockedBy.length > 0) {
-            return {
-                applicable: !featureState.blockedBy.includes("not-memory"),
-                promote: false,
-                score: 0,
-                threshold: 2,
-                knowledgeRef,
-                blockedBy: featureState.blockedBy,
-                positiveSignals: [],
-                negativeSignals: [],
-                modelName: "baseline-metadata",
-            };
-        }
-        const features = featureState.features;
-        const metadataScore = (features.hasSource ? 1 : 0) + (features.hasObservedAt ? 1 : 0);
-        const promote = metadataScore >= 2;
-        return {
-            applicable: true,
-            promote,
-            score: metadataScore,
-            threshold: 3,
-            knowledgeRef,
-            ...(promote ? { content: buildKnowledgeContent(input) } : {}),
-            blockedBy: [],
-            positiveSignals: promote ? ["baseline metadata rule"] : [],
-            negativeSignals: promote ? [] : ["baseline metadata rule not met"],
-            modelName: "baseline-metadata",
-        };
-    },
-};
-export function selectPromotionPolicy(corpus, candidates) {
-    const trainingCases = corpus.filter((testCase) => (testCase.split ?? "train") === "train");
-    const heldOutCases = corpus.filter((testCase) => (testCase.split ?? "train") === "heldout");
-    let bestPolicy;
-    let bestTraining;
-    for (const model of candidates) {
-        for (const threshold of thresholdCandidates()) {
-            const policy = {
-                name: model.name,
-                threshold,
-                assess: (input) => assessWithWeightedModel(input, model, threshold),
-            };
-            const training = evaluateMemoryPromotionBenchmark(trainingCases, policy);
-            if (!bestTraining) {
-                bestTraining = training;
-                bestPolicy = policy;
-                continue;
-            }
-            const trainingWins = training.f1 > bestTraining.f1 ||
-                (training.f1 === bestTraining.f1 && training.netOutcomeScore > bestTraining.netOutcomeScore) ||
-                (training.f1 === bestTraining.f1 &&
-                    training.netOutcomeScore === bestTraining.netOutcomeScore &&
-                    training.accuracy > bestTraining.accuracy);
-            if (trainingWins) {
-                bestTraining = training;
-                bestPolicy = policy;
-            }
-        }
-    }
-    const selectedPolicy = bestPolicy;
-    const selectedTraining = bestTraining;
-    const heldOut = evaluateMemoryPromotionBenchmark(heldOutCases, selectedPolicy);
-    const baselines = [POSITIVE_FEEDBACK_BASELINE, METADATA_BASELINE].map((policy) => {
-        const baselineHeldOut = evaluateMemoryPromotionBenchmark(heldOutCases, policy);
-        const noWorseThanSelected = heldOut.f1 >= baselineHeldOut.f1 && heldOut.netOutcomeScore >= baselineHeldOut.netOutcomeScore;
-        const strictWinMetrics = [];
-        if (heldOut.f1 > baselineHeldOut.f1)
-            strictWinMetrics.push("f1");
-        if (heldOut.netOutcomeScore > baselineHeldOut.netOutcomeScore)
-            strictWinMetrics.push("netOutcomeScore");
-        if (heldOut.accuracy > baselineHeldOut.accuracy)
-            strictWinMetrics.push("accuracy");
-        return {
-            name: policy.name,
-            heldOut: baselineHeldOut,
-            noWorseThanSelected,
-            strictWin: noWorseThanSelected && strictWinMetrics.length > 0,
-            strictWinMetrics,
-        };
-    });
-    const strictlyBeatsBaselines = baselines.every((baseline) => baseline.strictWin);
-    return {
-        corpusSize: corpus.length,
-        trainingSize: trainingCases.length,
-        heldOutSize: heldOutCases.length,
-        selectedModel: { name: selectedPolicy.name, threshold: selectedPolicy.threshold },
-        training: selectedTraining,
-        heldOut,
-        baselines,
-        strictlyBeatsBaselines,
-    };
-}
-export const DEFAULT_PROMOTION_POLICY_SELECTION = {
-    selectedModel: {
-        name: "balanced-evidence",
-        positiveWeight: 0.8,
-        repeatedPositiveWeight: 0.65,
-        noPositivePenalty: 0.9,
-        singlePositivePenalty: 0.7,
-        negativeWeight: 2.0,
-        curatedWeight: 0.55,
-        confidenceWeight: 0.7,
-        sourceWeight: 0.4,
-        observedAtWeight: 0.4,
-        descriptionWeight: 0.2,
-        tagWeight: 0.15,
-        substantiveBodyWeight: 0.15,
-        tentativePenalty: 1.1,
-    },
-    threshold: 3.8,
-};
-const SELECTED_MODEL = DEFAULT_PROMOTION_POLICY_SELECTION.selectedModel;
-export const DEFAULT_PROMOTION_POLICY = {
-    name: SELECTED_MODEL.name,
-    threshold: DEFAULT_PROMOTION_POLICY_SELECTION.threshold,
-    assess: (input) => assessWithWeightedModel(input, SELECTED_MODEL, DEFAULT_PROMOTION_POLICY_SELECTION.threshold),
+/**
+ * The memory → knowledge promotion model: a weighted score over feedback
+ * reinforcement and memory metadata, promoted at or above the threshold. The
+ * weights were chosen by a grid search over a labelled corpus; they are a
+ * plain constant now.
+ */
+const PROMOTION_MODEL = {
+    name: "balanced-evidence",
+    positiveWeight: 0.8,
+    repeatedPositiveWeight: 0.65,
+    noPositivePenalty: 0.9,
+    singlePositivePenalty: 0.7,
+    negativeWeight: 2.0,
+    curatedWeight: 0.55,
+    confidenceWeight: 0.7,
+    sourceWeight: 0.4,
+    observedAtWeight: 0.4,
+    descriptionWeight: 0.2,
+    tagWeight: 0.15,
+    substantiveBodyWeight: 0.15,
+    tentativePenalty: 1.1,
 };
+const PROMOTION_THRESHOLD = 3.8;
 export function assessMemoryKnowledgePromotionCandidate(input) {
-    return DEFAULT_PROMOTION_POLICY.assess(input);
+    return assessWithWeightedModel(input, PROMOTION_MODEL, PROMOTION_THRESHOLD);
 }