akm-cli 0.9.27-alpha.1 → 0.9.27-alpha.3

package/CHANGELOG.md

@@ -6,6 +6,137 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.27-alpha.3] - 2026-10-07
+
+### Fixed
+
+- **The drain's judge rejects a promotion that is a status snapshot, a plan or
+  something retired, not only a duplicate.** Its rubric for a promotion (a memory
+  proposed as a new knowledge note) said to reject a note that is wrong, a
+  duplicate or contradicts the live asset, and to accept a correct, valuable one,
+  so it judged only whether the note was new: the reasons it gave for accepting a
+  note pinned to commits and versions, a rollout status or a retired host were
+  "distinct from the existing notes". The reject line now also names a note that
+  reports the state of something that changes (a status, rollout, branch, commit,
+  version, test count, "as of <date>"), a plan not yet carried out, or something
+  already retired, replaced or superseded, and says a lesson drawn from an
+  incident is durable. On the owner's 65 labelled promotions (chat/qwen3.8-27b,
+  two runs each) the judge accepted 7 and 8 of the 14 stale ones and 4 and 5 of
+  the 7 ephemeral ones before, and 1 and 3, 0 and 1 after. Other proposals keep
+  the old rubric. No new settings.
+
+## [0.9.27-alpha.2] - 2026-10-07
+
+### Removed
+
+- **The `scripts/akm-eval` toolkit has moved out of this repository.** The
+  read-only measurement toolkit (the case runner and its suites, the twin
+  experiment, the real-query verdict for the proactive lane, the state
+  analyzers and the curate benchmark) is retired; every live eval is in
+  [itlackey/akm-eval](https://github.com/itlackey/akm-eval). Its code is kept
+  there, to read and not to run, in `retired/akm-scripts-akm-eval/`, copied from
+  commit `f57a7fd44b37`. It imports akm's `src/` by relative path, so it runs
+  only in a checkout at that commit. Removed here with it: `scripts/akm-eval/`,
+  its tests (`tests/integration/akm-eval/`, `tests/akm-eval-*.test.ts`,
+  `tests/curate-metrics.test.ts`) and fixtures (`tests/fixtures/akm-eval/`, and
+  the `curate-golden` stash, which only the curate benchmark read), the
+  `akm-eval determinism` CI job, and `getMeasurementVerdictsDir`, whose only
+  caller was the verdict runner. akm no longer names
+  `$STATE/improve/measurement/verdicts/<stash>/`; a file already there is inert.
+  `docs/maintainers/eval.md` is now a pointer to the new home.
+
+### Fixed
+
+- **The drain's judge no longer sees a note with a code block as truncated.**
+  The judgment prompt fenced the proposed content (and the live asset, sibling
+  proposals and neighbour excerpts) in three backticks, so a note holding its
+  own code block closed the fence early and read as cut off; real rejections said
+  "ends in an empty code block" or "truncated". Each block now uses a fence longer
+  than any backtick run inside it. The judge's reason is also kept on accepts,
+  staged accepts and defers (as the gate decision's `judgeReason`, until now
+  rejections only), and a judge reply that is not a verdict is stamped
+  `judgment-parse-failure`, and a runner failure `judgment-error`, instead of
+  looking like a defer.
+
+- **Distill writes a lesson only when its memory holds one, says only what the
+  memory says, and its judge rejects what a reviewer would.** 2 of the 22 distill
+  proposals since 0.9.26 began were accepted, and 17 of the 19 queued on
+  2026-10-05 were bad (they restated their memory, filed a dated status as a
+  lesson, claimed what the memory does not say, or repeated an asset the library
+  holds). Four causes, found in the code and the rejected proposals, and fixed:
+  (1) the prompt and schema forced a lesson from every memory, and 18 of the 19
+  were records of what was done; the writer now says why a memory holds a
+  lesson or none (`reason`, then `decision: lesson|none`, or the word `NONE`),
+  defined as a cause and what to do about it, or a rule with its reason, and
+  writes only what the memory and its feedback state, in the scope they have; a
+  `NONE` is a `skipped` distill (`skipReason: nothing_reusable`, the writer's
+  reason in the message) with no proposal and no judge call, and the loop keeps
+  its ledger row `unchanged`. (2) The judge asked for "information not already
+  present in the source", so an invented claim scored as novel and a faithful
+  lesson of a lesson-worthy memory as a restatement, and it passed anything that
+  "goes beyond the source" because it "may draw on feedback you are not shown".
+  The rubric is now reusable (a rule with its reason, not a record of what was
+  done), non-redundancy and grounding (every cause, step, number and limit is
+  in the source or its feedback), and the judge is shown the feedback the writer
+  saw. (3) A mean hid a decisive score (4 and 1 average 2.5, a review), and a
+  reviewer read everything the judge did not reject; any criterion at 2 or
+  below, grounding included, is now `quality_rejected`, and the reason names it
+  (`grounding 2/5: …`). The "borderline grounding" routing is gone. (4) Neither
+  the writer nor the judge could see a knowledge note or a skill that already
+  states the rule (the judge saw the 3 lexically nearest lessons, none of them
+  related); both now see the lessons, knowledge notes and skills nearest the
+  memory, which is the existing `processes.distill.cls` context turned on by
+  default (`enabled: false` turns it off). Judge scores are keyed `reusable`
+  where they were `novelty`. Measured on the local qwen3.8-27b with akm-eval's
+  `evals/distill` (30 fictional memories, 5 runs each side): good lessons 7/14 on
+  average (5 to 9) against 3.7/14 (3 to 5), lessons queued for memories that
+  deserve none 0.4/16 against 3.3/16. On 37 real memories with their feedback
+  (34 reviewed bad, 3 good; 3 runs against 2): a lesson was queued for 11% of the
+  bad ones against 44%, and for 6 of 9 good ones against 4 of 6; of the memories
+  that pass 0.9.26's skip of bare positive feedback, 20% of the bad against 50%.
+  No new settings.
+
+- **Reflect no longer plans an asset whose negative feedback is already acted
+  on.** A negative `akm feedback` that came with an exact fix (`--replace` and
+  `--with`, `--outdated` or `--superseded-by`) makes a `feedback` proposal, and
+  once that proposal is accepted the feedback has done its work. Reflect still
+  took the ref as having fresh negative feedback, and on 2026-10-07 44 of its 50
+  refs were of that kind: the judge refused or the model changed nothing for
+  most of them. A negative event with a fix is now left out of the reflect
+  cursor when an accepted `feedback` proposal for the ref was created at or
+  after it. A negative with no fix, one given after the proposal, and one whose
+  proposal is still pending or was rejected plan a reflect as before.
+
+- **Consolidate stops re-offering memories a reviewer already turned down, and
+  the nightly judge sees what a promotion may duplicate.** About 53 promotions a
+  night reached review at ~5% precision, 64-70% of them a memory body already
+  proposed or rejected. Four causes, four changes: a memory whose body equals
+  that of a consolidate promotion rejected on or after 2026-09-29 is held until
+  its body changes, under any name (earlier rejections, the bulk audits of
+  2026-08, do not count); a memory the model judged and left alone is held by its
+  body hash instead of a 7-day clock, so an unchanged memory is no longer judged
+  every week (a row recorded without a hash keeps the 7 days); the coverage gate
+  skips a memory when 30% of its text, not 50%, is in a neighbouring knowledge
+  doc, which catches paraphrases; and the drain's judgment tier, which judged a
+  promotion seeing only the proposal and never `knowledge/`, is now shown the 5
+  nearest knowledge notes (ref, description, excerpt) and told to reject a
+  promotion they already cover. No new settings.
+
+- **A confident `subsumed` or `supersedes` retirement resolves unattended, as a
+  `duplicate` already did.** The pair pass staged a retire proposal for the
+  triage drain only when the judge's label was `duplicate`; every other retirement
+  waited for a person. It now stages any of the three retire labels when the
+  second look (what does the retired note hold that the kept one lacks?) comes
+  back empty and there is no continuity risk; the retired side's claim list is
+  already empty for any proposal, and a `duplicate` must still have an empty list
+  on the kept side too. The staged gate reason is the judge's label, and the drain records it. Replay over 360
+  judged pairs: 336 safe (0.93): `duplicate` 0.98, `subsumed` 0.92, `supersedes`
+  0.875. In production, unstaged `subsumed` retirements were accepted 45 of 54
+  times by hand, and in the latest run 41 of 47 pair proposals would have resolved
+  without a person. `docs/architecture/internals/improve-workflow.md` said triage
+  never auto-accepts a retire proposal, which stopped being true in 0.9.26; it,
+  and the matching lines in `improvement.md`, now describe the staging rule.
+
 ## [0.9.27-alpha.1] - 2026-10-06
 
 ### Fixed

package/LICENSE

@@ -225,10 +225,9 @@ statute, judicial order, or regulation then You must: (a) comply with
 the terms of this License to the maximum extent possible; and (b)
 describe the limitations and the code they affect. Such description must
 be placed in a text file included with all distributions of the Covered
-Software under the name "LEGAL", with additions for new restrictions
-placed at the end of the file. Except to the extent prohibited by
-statute or regulation, such description must be sufficiently detailed
-for a recipient of ordinary skill to be able to understand it.
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
 
 5. Termination
 --------------

package/dist/assets/prompts/distill-lesson-system.md

@@ -1,7 +1,29 @@
 You are the akm `distill` distiller.
-Given an asset and recent feedback events about it, produce a single
-concise *lesson* an agent should remember next time it works on this
-asset's domain.
+You are given a memory and the feedback recorded about it. Decide whether it
+holds a lesson and, if it does, write the lesson.
+
+A memory holds a lesson when it states a cause and what to do about it: a
+failure or surprise with its cause and the fix that worked, or a rule with the
+reason it holds. It holds a lesson even when it is short and names one project,
+tool or incident, if the cause and the fix would help someone in a similar
+situation.
+
+A memory holds NO lesson when all it states is what was done, shipped, released
+or decided, what is pending or planned, how a system is set up now, or the steps
+of a procedure, with no failure and cause behind it, or when its feedback says
+only that it is out of date or superseded. ANSWER NONE then: the single word and
+nothing else. A reply bound to a JSON schema answers NONE by
+setting `decision` to `none` and leaving the other fields empty. Answer NONE too
+when a related asset listed below the memory already states the rule the memory
+would give.
+
+When the memory holds a lesson, write it from what the memory and its feedback
+say, and nothing more:
+- Add no cause, step, rule, number, check or safeguard that neither states.
+- Keep the scope the memory has. A fix verified in one place is a fix for that
+  place, and what was not checked stays unchecked. One case is not "always" or
+  "never".
+- Be shorter than the memory.
 
 YOUR RESPONSE MUST START EXACTLY WITH `---` ON THE VERY FIRST LINE.
 DO NOT output any prose, explanation, or code fences before or after.
@@ -12,7 +34,7 @@ description: <one complete sentence (ending with `.`) summarising what the lesso
 when_to_use: <one complete sentence describing the concrete trigger condition>
 ---
 
-<lesson body — plain markdown, 1–3 short paragraphs of practical guidance>
+<lesson body — plain markdown, as short as the memory allows>
 
 ## description field (MANDATORY)
 - A single complete sentence in present tense, 20–400 chars, NO markdown.
@@ -21,7 +43,7 @@ when_to_use: <one complete sentence describing the concrete trigger condition>
 - DO NOT copy a section heading ("Key takeaways", "For example", "Key pitfalls").
 - DO NOT begin with a numbered list marker, code fence, or markdown heading.
 
-GOOD: "Always validate ref existence before promoting a memory to knowledge; missing refs surface as silent 404s during accept."
+GOOD: "Pin the container image tag, because the `latest` tag moved under the nightly job and its output changed with no code change."
 BAD:  "Key pitfalls"
 BAD:  "When working with the akm CLI"
 BAD:  "For example, you might..."
@@ -32,5 +54,5 @@ RULES:
 - `description` and `when_to_use` MUST differ from each other.
 - The lesson body MUST be non-empty markdown prose. Do NOT restate `description:` or `when_to_use:` inside the body (no `**description:** ...` or `**when_to_use:** ...` lines — the frontmatter is the only place those keys belong).
 - Do NOT emit a second `---` fence after the opening frontmatter — there are exactly two `---` lines in the output, both belonging to the single frontmatter block at the top.
-- Do NOT reproduce the source asset verbatim — distil what a caller needs to know.
-- Output ONLY the lesson file. No preamble, no code fences, no trailing prose.
+- Do NOT reproduce the source asset verbatim.
+- Output ONLY the lesson file. No preamble, no code fences, no trailing prose.

package/dist/commands/improve/consolidate/coverage.js

@@ -6,7 +6,7 @@
  * `knowledge/` proposal, ask whether `knowledge/` already says it.
  *
  * The rule: a memory is covered when at least {@link COVERAGE_MIN_CONTAINMENT}
- * (half) of its distinct {@link COVERAGE_SHINGLE_WORDS}-word shingles appear in
+ * (30%) of its distinct {@link COVERAGE_SHINGLE_WORDS}-word shingles appear in
  * one of the knowledge docs nearest to it. It is a containment of the MEMORY in
  * the doc, not a similarity: a long guide that quotes the memory covers it; a
  * memory that quotes a short doc and adds claims of its own does not.
@@ -25,9 +25,13 @@
  * this gate achieves: it reads only the {@link PAIR_NEIGHBOR_FETCH_K} nearest
  * knowledge docs (below), and a covering doc that ranks lower goes unseen. The
  * recall over that candidate set is unmeasured. The rest of the rejected
- * proposals (paraphrases, partial overlaps) still reach review: the next cut
- * measured, 0.2 (169 of 224 rejected), would also have skipped 2 of the 103
- * accepted ones, and no cosine cut was measured at all. A wrong skip is a
+ * proposals (paraphrases, partial overlaps) still reach review. 0.5 let
+ * paraphrases through: of the 54 promotions minted on 2026-10-07, 18 of the 51
+ * later rejected held 30% or more of their text in a neighbouring doc. The cut is
+ * now 0.3, between the two measured points: 0.2 (169 of 224 rejected) also
+ * skipped 2 of the 103 accepted ones. At 0.3, none of the 5 promotions graded
+ * good in the 2026-10-05 review sample would be skipped (their best doc holds
+ * at most 1% of them) while 5 of its 15 bad ones would. A wrong skip is a
  * promotion nobody gets to review.
  *
  * Candidates are the memory's {@link PAIR_NEIGHBOR_FETCH_K} nearest knowledge
@@ -49,7 +53,7 @@ import { PAIR_NEIGHBOR_FETCH_K } from "./pair-pass.js";
 /** Words per shingle. */
 export const COVERAGE_SHINGLE_WORDS = 5;
 /** Share of a memory's distinct shingles one knowledge doc must hold for the memory to count as covered. */
-export const COVERAGE_MIN_CONTAINMENT = 0.5;
+export const COVERAGE_MIN_CONTAINMENT = 0.3;
 const WORD = /[\p{L}\p{N}]+/gu;
 /** The distinct lower-cased word n-grams of `text`; empty when it has fewer than {@link COVERAGE_SHINGLE_WORDS} words. */
 export function wordShingles(text) {
@@ -72,19 +76,15 @@ export function shingleContainment(memory, doc) {
     return shared / memory.size;
 }
 /**
- * The best-covering knowledge doc among the {@link PAIR_NEIGHBOR_FETCH_K}
- * knowledge docs in `bundleId` nearest to the memory. `filePath` is the
- * memory's indexed file; a memory the index does not know has no stored vector
- * and so no candidates.
+ * The {@link PAIR_NEIGHBOR_FETCH_K} knowledge docs in `bundleId` nearest to the
+ * memory at `filePath`, nearest first. A memory the index does not know has no
+ * stored vector and so no neighbours.
  */
-export function findCoveringKnowledge(db, bundleId, filePath, body) {
-    const shingles = wordShingles(body);
-    if (shingles.size === 0)
-        return undefined;
+function knowledgeNeighbours(db, bundleId, filePath) {
     const entryId = getEntryIdByFilePath(db, filePath);
     if (entryId === undefined)
-        return undefined;
-    let best;
+        return [];
+    const out = [];
     for (const hit of getNeighborsByEntryId(db, entryId, PAIR_NEIGHBOR_FETCH_K, { type: "knowledge", bundleId })) {
         const neighbour = getEntryById(db, hit.id);
         if (!neighbour)
@@ -96,13 +96,67 @@ export function findCoveringKnowledge(db, bundleId, filePath, body) {
         catch {
             continue; // the index outlived the file
         }
-        const containment = shingleContainment(shingles, stripFrontmatterBody(raw));
+        out.push({
+            ref: neighbour.conceptId,
+            description: neighbour.entry.description ?? "",
+            body: stripFrontmatterBody(raw),
+        });
+    }
+    return out;
+}
+/**
+ * The best-covering knowledge doc among the {@link PAIR_NEIGHBOR_FETCH_K}
+ * knowledge docs in `bundleId` nearest to the memory. `filePath` is the
+ * memory's indexed file; a memory the index does not know has no stored
+ * vector and so no candidates.
+ */
+export function findCoveringKnowledge(db, bundleId, filePath, body) {
+    const shingles = wordShingles(body);
+    if (shingles.size === 0)
+        return undefined;
+    let best;
+    for (const neighbour of knowledgeNeighbours(db, bundleId, filePath)) {
+        const containment = shingleContainment(shingles, neighbour.body);
         if (containment >= COVERAGE_MIN_CONTAINMENT && (best === undefined || containment > best.containment)) {
-            best = { ref: neighbour.conceptId, containment };
+            best = { ref: neighbour.ref, containment };
         }
     }
     return best;
 }
+/** Knowledge docs a reviewer is shown for a promotion, nearest first. */
+export const NEIGHBOUR_NOTE_COUNT = 5;
+const NEIGHBOUR_EXCERPT_CHARS = 300;
+/**
+ * The knowledge notes nearest to the memory at `memoryPath`, for the drain's
+ * judge to compare a promotion against: the nearest {@link NEIGHBOUR_NOTE_COUNT}
+ * of the same candidates the coverage gate reads. The memory's bundle is the one
+ * the index recorded for it. Empty when the index has no vector for the memory
+ * or cannot be opened; never throws.
+ */
+export function nearestKnowledgeNotes(memoryPath) {
+    let db;
+    try {
+        db = openExistingDatabase();
+        const entryId = getEntryIdByFilePath(db, memoryPath);
+        const bundleId = entryId === undefined ? undefined : getEntryById(db, entryId)?.bundleId;
+        if (bundleId === undefined)
+            return [];
+        return knowledgeNeighbours(db, bundleId, memoryPath)
+            .slice(0, NEIGHBOUR_NOTE_COUNT)
+            .map((n) => ({
+            ref: n.ref,
+            description: n.description,
+            excerpt: n.body.length > NEIGHBOUR_EXCERPT_CHARS ? `${n.body.slice(0, NEIGHBOUR_EXCERPT_CHARS)}...` : n.body,
+        }));
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (db)
+            closeDatabase(db);
+    }
+}
 /**
  * The gate for one run, holding its own read handle on `index.db` for the
  * promotions that run emits; `undefined` when there is no bundle or no index

package/dist/commands/improve/consolidate/pair-pass.js

@@ -503,7 +503,7 @@ function checkSection(label, side) {
     ].join("\n");
 }
 /**
- * The second look a duplicate gets before it may retire unattended: one call
+ * The second look a retirement gets before it may retire unattended: one call
  * that asks only what the retired note holds that the kept one lacks. True
  * only on a clean, empty answer (it caught 2 of 4 duplicates the judge got
  * wrong, and held back none of 109 right ones).
@@ -658,17 +658,20 @@ async function judgeOne(ctx, candidate) {
         }, ctx.opts.proposalsCtx);
         ctx.retired.push(proposal.id);
         ctx.perInitiatorProposed.add(candidate.initiator.ref);
-        // A duplicate with nothing unique on either side, confirmed by a second
-        // look, is the one class that retires unattended (109 of 111 safe on the
-        // owner's reviewed pairs, 2026-10-04): the triage drain accepts it under
-        // its usual applyMode. Every other retirement waits for a person.
-        if (verdict.relation === "duplicate" &&
-            verdict.onlyInA.length + verdict.onlyInB.length === 0 &&
+        // A retirement the second look confirms loses nothing retires unattended:
+        // the triage drain accepts it under its usual applyMode. The retired side
+        // holds no claim of its own for any label (`decideRetirement` mints nothing
+        // else); a duplicate must also leave the kept side with none, while a
+        // subsumed or superseding successor holds more by definition. Replay
+        // precision 336/360 (duplicate 0.98, subsumed 0.92, supersedes 0.875,
+        // 2026-10-07); a duplicate alone was 109 of 111 safe on the owner's
+        // reviewed pairs (2026-10-04). Anything else waits for a person.
+        if ((verdict.relation !== "duplicate" || verdict.onlyInA.length + verdict.onlyInB.length === 0) &&
             !continuityRisk &&
             (await confirmNothingLost(ctx, retired, successor))) {
             recordGateDecision(ctx.stashDir, proposal.id, {
                 outcome: "staged",
-                reason: "duplicate",
+                reason: verdict.relation,
                 gate: PAIR_PASS_GATE,
                 contentHash: proposalContentHash(proposal),
             }, ctx.opts.proposalsCtx);

package/dist/commands/improve/consolidate.js

@@ -260,6 +260,39 @@ function loadPendingConsolidateProposalHashes(stashDir, proposalsCtx) {
     }
     return hashes;
 }
+/**
+ * Rejections decided before this are not a verdict on the memory's text: the
+ * 2026-08-02 and 2026-08-18 bulk audits rejected hundreds of promotions
+ * wholesale, and holding their bodies would skip good memories for good.
+ */
+const REJECTED_BODY_HOLD_FROM = "2026-09-29";
+/**
+ * Body hashes of the memories whose promotion was rejected on review. A
+ * proposal minted with `promotionSourceHash` names the memory's raw body; an
+ * older one is hashed from its own body, which is the memory's unless
+ * sanitization changed it.
+ */
+function loadRejectedPromotionBodyHashes(stashDir, proposalsCtx) {
+    const hashes = new Set();
+    try {
+        for (const p of listProposalsReadOnly(stashDir, { status: "rejected", includeArchive: true }, proposalsCtx)) {
+            if (p.source !== "consolidate")
+                continue;
+            if ((p.review?.decidedAt ?? p.updatedAt) < REJECTED_BODY_HOLD_FROM)
+                continue;
+            try {
+                hashes.add(p.promotionSourceHash ?? contentHash(proposalContent(p), "body"));
+            }
+            catch {
+                // A malformed payload cannot hold a memory.
+            }
+        }
+    }
+    catch {
+        // Best-effort: a failed read never blocks judging.
+    }
+    return hashes;
+}
 /**
  * Body hashes of the live knowledge assets, read from disk (the index may lag
  * a just-written asset), so an accepted promotion is not proposed again.
@@ -469,6 +502,18 @@ export function inspectConsolidationPool(opts, stashDir, warnings, existingKnowl
             return !isLedgerBlocked(row, nowIso, changedAt);
         });
     }
+    // A memory whose text a reviewer already rejected as a promotion waits for an edit, whatever it is called.
+    const rejectedBodies = loadRejectedPromotionBodyHashes(stashDir, opts.proposalsCtx);
+    if (rejectedBodies.size > 0) {
+        memories = memories.filter((memory) => {
+            try {
+                return !rejectedBodies.has(contentHash(fs.readFileSync(memory.filePath, "utf8"), "body"));
+            }
+            catch {
+                return true;
+            }
+        });
+    }
     const judgedUnchanged = poolSize - memories.length;
     // Only what retrieval returned or new material improve never processed (#986).
     const retrievalScope = loadRetrievalScope({ proposalsCtx: opts.proposalsCtx, readOnly }, stashDir);
@@ -768,7 +813,13 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
     recordLedgerAttempt({ proposalsCtx: opts.proposalsCtx }, [...acc.judgedRefs]
         .filter((ref) => !ctx.promotedSourceRefs.has(ref) &&
         !acc.skipReasonByRef.get(ref)?.skips.some((skip) => skip.reason === "promote_create_failed"))
-        .map((ref) => ({ stashDir, ref, source: "consolidate", outcome: "judged_no_action" })));
+        .map((ref) => ({
+        stashDir,
+        ref,
+        source: "consolidate",
+        outcome: "judged_no_action",
+        ...bodyHashOf(ctx.memoryByRef.get(ref)),
+    })));
     return makeConsolidateResult({
         ...summary(),
         promoted: ctx.promoted,
@@ -783,6 +834,17 @@ async function consolidate(opts, config, stashDir, startMs, stateDb) {
         },
     });
 }
+/** The memory's current body hash as a ledger input field; empty when it cannot be read (the row then keeps its 7-day window). */
+function bodyHashOf(memory) {
+    if (!memory)
+        return {};
+    try {
+        return { contentHash: contentHash(fs.readFileSync(memory.filePath, "utf8"), "body") };
+    }
+    catch {
+        return {};
+    }
+}
 /** The conceptId a ref maps to, or undefined for an invalid ref. */
 function conceptIdForRef(ref) {
     try {

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

@@ -2,25 +2,24 @@
 // 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/.
 /**
- * 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.
+ * Distill guards: the related lessons, knowledge notes and skills shown to the
+ * writer so it does not repeat or overwrite them (CLS context), and a cheap check
+ * that a proposal does not contradict the memories it came from.
  */
 export const DEFAULT_CLS_ADJACENT_COUNT = 3;
-/** The CLS prompt section (each entry capped at 400 chars); empty when disabled or nothing is related. */
+/** The CLS prompt section (each entry capped at 600 chars); empty when disabled (on unless `enabled: false`) or nothing is related. */
 export function buildClsContext(adjacentItems, config) {
-    if (!config.enabled || adjacentItems.length === 0)
+    if (config.enabled === false || adjacentItems.length === 0)
         return "";
     const lines = [
         "",
-        "## Existing adjacent lessons / knowledge (CLS context)",
-        "The following are semantically related entries already in the stash.",
-        "Your proposal MUST NOT contradict or silently overwrite these — if you",
-        "disagree with one, flag it as contradicted (do not ignore it).",
+        "## Related assets already in the library",
+        "The library already holds these lessons, knowledge notes and skills near this memory. They may be about another subject.",
+        "If one of them already states the rule the memory would give, answer NONE. Do not contradict or overwrite them.",
         "",
     ];
     for (const item of adjacentItems)
-        lines.push(`### ${item.ref}`, item.content.trim().slice(0, 400), "");
+        lines.push(`### ${item.ref}`, item.content.trim().slice(0, 600), "");
     return lines.join("\n");
 }
 /**