akm-cli 0.9.30 → 0.10.26101001-alpha

package/dist/commands/improve/preparation.js

@@ -9,8 +9,8 @@
  * Candidate selection reads the improve ledger plus one set of signals: a ref
  * is eligible for a source when feedback newer than its last attempt landed and
  * no ledger window holds it, and reflect reads only negative feedback. Refs
- * without recent feedback can still be picked by the fallback lanes (proactive
- * maintenance, high salience), which only score them; the survivors are ranked
+ * without recent feedback can still be picked by the proactive-maintenance
+ * lane, which plans them with the rest; the survivors are ranked
  * by salience, checked on disk and capped. A plan-only run evaluates the same
  * selectors against read snapshots and writes nothing.
  */
@@ -35,7 +35,7 @@ import { isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmConsolidate, inspectConsolidationPool, loadExistingKnowledgeBodyHashes, makeConsolidateResult, } from "./consolidate.js";
 import { computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
 import { contentHash } from "./content-hash.js";
-import { assetTypeOf, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, resolveImproveScope, withIndexDb, } from "./eligibility.js";
+import { assetTypeOf, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, withIndexDb, } from "./eligibility.js";
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
 import { computeValenceScore } from "./feedback-valence.js";
 import { isLedgerBlocked, lastAttemptByRef, ledgerRowFor, loadLedgerSnapshot, stateKey, } from "./ledger.js";
@@ -81,7 +81,7 @@ export function pickDefined(source, keys) {
             out[key] = source[key];
     return out;
 }
-export const CONSOLIDATION_CONFIG_KEYS = ["enabled", "minPoolSize", "limit", "maxChunkSize"];
+export const CONSOLIDATION_CONFIG_KEYS = ["enabled", "limit", "maxChunkSize"];
 /** Emit an aggregate `improve_skipped` row (never one per ref). */
 export function recordImproveSkip(eventsCtx, ref, metadata) {
     appendEvent({ eventType: "improve_skipped", ref, metadata }, eventsCtx);
@@ -96,19 +96,13 @@ export function pushRecentError(recentErrors, originator, msg) {
 }
 // ── Consolidation ────────────────────────────────────────────────────────────
 /**
- * The consolidation gates and pool, with no model call: the profile toggle,
- * `minPoolSize` (not for a named strategy or ref scope, nor once the pool is
- * over the 100-memory volume trigger), and the ledger delta (every memory
- * judged recently and unchanged since means nothing to do).
+ * The consolidation gates and pool, with no model call: the profile toggle
+ * and the ledger delta (every memory judged recently and unchanged since
+ * means nothing to do).
  */
 function planConsolidationPass(args) {
-    const { options, primaryStashDir, memorySummary, resolvedPlan } = args;
+    const { options, primaryStashDir, resolvedPlan } = args;
     const processConfig = args.improveProfile?.processes?.consolidate;
-    const volumeTriggered = memorySummary.eligible > 100 && resolvedPlan.processes.consolidate.runner !== null;
-    const minPoolSize = typeof processConfig?.minPoolSize === "number" ? processConfig.minPoolSize : 0;
-    const eligiblePoolSize = typeof memorySummary.eligible === "number" ? memorySummary.eligible : 0;
-    const userNamed = options.strategy !== undefined || resolveImproveScope(options.scope).mode === "ref";
-    const poolBelowMinSize = !volumeTriggered && !userNamed && minPoolSize > 0 && eligiblePoolSize < minPoolSize;
     const pool = primaryStashDir
         ? inspectConsolidationPool({
             config: options.config,
@@ -127,18 +121,13 @@ function planConsolidationPass(args) {
         DEFAULT_CONTEXT_LENGTH_TOKENS, 500, processConfig?.maxChunkSize);
     const profilePassed = processConfig?.enabled !== false;
     const deltaPassed = pool.candidatePoolSize > 0 || pool.judgedUnchanged === 0;
-    const wouldRun = profilePassed && !poolBelowMinSize && deltaPassed && pool.candidatePoolSize > 0;
-    const belowMin = `pool ${eligiblePoolSize} is below minPoolSize ${minPoolSize}`;
+    const wouldRun = profilePassed && deltaPassed && pool.candidatePoolSize > 0;
     const unchanged = "every memory was judged recently and is unchanged since";
     return {
-        poolBelowMinSize,
-        eligiblePoolSize,
-        minPoolSize,
         plan: {
             configured: pickDefined(processConfig, CONSOLIDATION_CONFIG_KEYS),
             effective: {
                 enabled: profilePassed,
-                minPoolSize,
                 ...(processConfig?.limit !== undefined ? { limit: processConfig.limit } : {}),
                 chunkSize,
             },
@@ -149,10 +138,6 @@ function planConsolidationPass(args) {
                     passed: profilePassed,
                     reason: profilePassed ? "consolidation enabled" : "disabled by improve profile",
                 },
-                minimumPool: {
-                    passed: !poolBelowMinSize,
-                    reason: poolBelowMinSize ? belowMin : `pool satisfies minPoolSize ${minPoolSize}`,
-                },
                 delta: {
                     passed: deltaPassed,
                     reason: !deltaPassed
@@ -165,13 +150,11 @@ function planConsolidationPass(args) {
             wouldRun,
             reason: !profilePassed
                 ? "disabled by improve profile"
-                : poolBelowMinSize
-                    ? belowMin
-                    : !deltaPassed
-                        ? unchanged
-                        : pool.candidatePoolSize === 0
-                            ? "candidate pool is empty after narrowing"
-                            : "all consolidation gates pass",
+                : !deltaPassed
+                    ? unchanged
+                    : pool.candidatePoolSize === 0
+                        ? "candidate pool is empty after narrowing"
+                        : "all consolidation gates pass",
             estimatedChunks: wouldRun ? Math.ceil(pool.candidatePoolSize / chunkSize) : 0,
         },
     };
@@ -186,14 +169,6 @@ async function runConsolidationPass(args) {
     if (!planned.plan.gates.profile.passed) {
         info("[improve] consolidation skipped (disabled by improve profile)");
     }
-    else if (planned.poolBelowMinSize) {
-        recordImproveSkip(eventsCtx, "memories/_consolidation", {
-            reason: "pool_below_min_size",
-            poolSize: planned.eligiblePoolSize,
-            minPoolSize: planned.minPoolSize,
-        });
-        info(`[improve] consolidation skipped (pool ${planned.eligiblePoolSize} < minPoolSize ${planned.minPoolSize})`);
-    }
     else if (!planned.plan.gates.delta.passed) {
         recordImproveSkip(eventsCtx, "memories/_consolidation", { reason: "consolidation_no_memory_updates" });
         info("[improve] consolidation skipped (every memory was judged recently and is unchanged)");
@@ -212,7 +187,6 @@ async function runConsolidationPass(args) {
             limit: processConfig?.limit,
             maxChunkSize: processConfig?.maxChunkSize,
             signal: args.budgetSignal,
-            p90ChunkSecondsDefault: processConfig?.p90ChunkSecondsDefault,
             // Its read-only proposal lookups go through the run's own state.db handle.
             ...(eventsCtx?.db ? { proposalsCtx: { db: eventsCtx.db } } : {}),
         }));
@@ -671,7 +645,7 @@ export function buildSnapshotManifest(args) {
  *  - distillOnlyRefs: only distill's passes (any signal, a positive or a note
  *    included), on a distill candidate;
  *  - noFeedbackPool: no recent feedback and no reflect window, left to the
- *    fallback lanes, which only score them;
+ *    proactive-maintenance lane;
  *  - fullySkippedCount: feedback on record but nothing new, or a live window.
  * An explicit `--scope <ref>` bypasses every gate.
  */
@@ -722,12 +696,12 @@ export function partitionBySignalDelta(args) {
     return out;
 }
 /**
- * Pick the loop's refs: signal delta, the fallback lanes (unless
- * `--require-feedback-signal`; they score, never plan), lane attribution,
- * salience, the no-op-dampened ranking, the disk check and the limit.
+ * Pick the loop's refs: signal delta, the proactive-maintenance lane (unless
+ * `--require-feedback-signal`), lane attribution, salience, the no-op-dampened
+ * ranking, the disk check and the limit.
  */
 async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs, actions, persist) {
-    const { scope, options, primaryStashDir, eventsCtx, improveProfile } = args;
+    const { scope, options, primaryStashDir, eventsCtx } = args;
     const snapshot = buildSnapshotManifest({
         postCleanupRefs,
         validationFailureRefs,
@@ -739,9 +713,8 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     const processableRefs = [...partition.eligibleRefs, ...partition.distillOnlyRefs];
     const signalFiltered = processableRefs.filter((c) => snapshot.feedback.get(c.ref)?.hasSignal === true);
     const signalBearingSet = new Set(signalFiltered.map((r) => r.ref));
-    // The fallback lanes (proactive, high salience) have no usage evidence of
-    // their own: they pick only what retrieval returned or new material improve
-    // never processed (#986). Evaluated once per candidate.
+    // The proactive lane has no usage evidence of its own: it picks only what
+    // retrieval returned or new material improve never processed (#986). Evaluated once per candidate.
     const fallbackEligible = postCleanupRefs.filter((c) => !validationFailureRefs.has(c.ref));
     const allowFallbacks = options.requireFeedbackSignal !== true;
     const retrievalScope = scope.mode === "ref" || !allowFallbacks
@@ -753,22 +726,20 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
         ...partition.noFeedbackPool,
     ]);
     const noFeedbackCandidates = noFeedbackPool.filter((r) => !unscoped.has(r.ref));
-    // Only a ref no fallback lane may pick anymore is charged to the retrieval gate.
+    // Only a ref the proactive lane may not pick is charged to the retrieval gate.
     const outOfScope = new Set(noFeedbackPool.filter((r) => unscoped.has(r.ref)).map((r) => r.ref));
     const retrieval = fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, eventsCtx, persist);
     const proactive = allowFallbacks
         ? selectProactiveMaintenanceLane(args, noFeedbackCandidates, snapshot, retrieval, persist)
         : { proactiveRefs: [] };
-    const highSalienceRefs = allowFallbacks
-        ? selectHighSalienceLane(options, improveProfile, eventsCtx, noFeedbackCandidates.filter((r) => !proactive.proactiveRefs.some((p) => p.ref === r.ref)), snapshot.lastReflectAttemptAt, persist)
-        : [];
-    // An explicit ref scope always acts on its ref; otherwise only feedback plans the loop. The fallback lanes'
-    // picks are scored with it, never planned: a rewrite needs negative feedback.
-    const signalAndRetrievalRefs = dedupeRefs([...signalFiltered, ...proactive.proactiveRefs, ...highSalienceRefs]);
-    const mergedRefs = scope.mode === "ref" ? processableRefs : signalFiltered;
-    const scoredRefs = scope.mode === "ref" ? processableRefs : signalAndRetrievalRefs;
-    // Lane attribution: signal-delta, and an explicit ref scope over it.
+    // Planned: signal-delta refs plus the proactive lane's picks (whole-stash / type scope); an explicit ref scope
+    // acts on its own refs.
+    const mergedRefs = scope.mode === "ref" ? processableRefs : dedupeRefs([...signalFiltered, ...proactive.proactiveRefs]);
+    // Lane attribution, weakest first so the strongest wins: proactive < signal-delta, and an explicit ref scope
+    // over everything.
     const sourceByRef = new Map();
+    for (const r of proactive.proactiveRefs)
+        sourceByRef.set(r.ref, "proactive");
     for (const r of signalFiltered)
         sourceByRef.set(r.ref, "signal-delta");
     if (scope.mode === "ref")
@@ -776,7 +747,7 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
             sourceByRef.set(r.ref, "scope");
     for (const r of mergedRefs)
         r.eligibilitySource = sourceByRef.get(r.ref) ?? "unknown";
-    const salienceMap = scoreSalience(args, scoredRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
+    const salienceMap = scoreSalience(args, mergedRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
     // Rank by salience; a ref skipped as a no-op repeatedly sorts lower (its stored rank is untouched).
     const noOps = new Map();
     withRunState(eventsCtx, persist, (db) => {
@@ -795,8 +766,8 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
         distillOnlyRefs: partition.distillOnlyRefs,
         limit: options.limit,
     });
-    if (signalAndRetrievalRefs.length > 0) {
-        info(`[improve] ${signalAndRetrievalRefs.length} refs with usage signals (${signalFiltered.length} feedback)`);
+    if (mergedRefs.length > 0) {
+        info(`[improve] ${mergedRefs.length} refs with usage signals (${signalFiltered.length} feedback)`);
     }
     if (validationFailureRefs.size > 0)
         info(`[improve] ${validationFailureRefs.size} with validation failures excluded`);
@@ -883,11 +854,11 @@ function fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, ev
     return out;
 }
 /**
- * Proactive maintenance (default off, whole-stash/type runs): pick stable
- * assets due for a revisit. The picks are scored and never planned: improve
- * does not rewrite on a proactive cadence. The due gate doubles as the
- * rotation cooldown: a freshly reflected asset waits `dueDays` before it is
- * picked again.
+ * Proactive maintenance (default on, whole-stash/type runs): pick stable
+ * assets due for a revisit and plan them with the feedback-bearing refs. The
+ * cap against a proposal flood: `maxPerRun` limits the picks per run, the due
+ * gate admits only an asset not reflected or distilled for `dueDays` (so each
+ * comes up at most once per `dueDays`), and reflect's `limit` bounds the run.
  */
 function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, persist) {
     if (args.scope.mode === "ref" || !args.resolvedPlan.processes.proactiveMaintenance.enabled) {
@@ -895,7 +866,7 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
     }
     const pmCfg = args.improveProfile.processes?.proactiveMaintenance;
     const dueDays = pmCfg?.dueDays ?? DEFAULT_DUE_DAYS;
-    const maxPerRun = pmCfg?.maxPerRun ?? pmCfg?.limit ?? DEFAULT_MAX_PER_RUN;
+    const maxPerRun = pmCfg?.maxPerRun ?? DEFAULT_MAX_PER_RUN;
     const selection = selectProactiveMaintenanceRefs({
         candidates,
         lastReflectTs: snapshot.lastReflectAttemptAt,
@@ -927,7 +898,7 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
         proactiveRefs: selection.selected,
         proactiveMaintenanceSummary: { ...summary, selectedRefs },
         proactivePlan: {
-            configured: pickDefined(pmCfg, ["dueDays", "maxPerRun", "limit"]),
+            configured: pickDefined(pmCfg, ["dueDays", "maxPerRun"]),
             effective: { dueDays, maxPerRun },
             candidatePool: candidates.length,
             ...summary,
@@ -935,41 +906,13 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
         },
     };
 }
-/**
- * High salience: zero-feedback refs whose content-derived encoding score (not
- * a per-type stub) reaches `salienceThreshold` and that were never reflected,
- * top-N by score, capped at 10% of the effective limit. The picks are scored,
- * never planned.
- */
-function selectHighSalienceLane(options, improveProfile, eventsCtx, candidates, lastReflectAttemptAt, persist) {
-    const threshold = (options.config ?? loadConfig()).improve?.salience?.salienceThreshold ?? 0.75;
-    const effectiveLimit = options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit ?? 10;
-    const selected = withRunState(eventsCtx, persist, (db) => candidates
-        .flatMap((r) => {
-        const row = getAssetSalience(db, keyOf(r));
-        return row &&
-            isContentEncodingRow(row) &&
-            row.encoding_salience >= threshold &&
-            !lastReflectAttemptAt.has(r.ref)
-            ? [{ ref: r, score: row.encoding_salience }]
-            : [];
-    })
-        .sort((a, b) => b.score - a.score)
-        .slice(0, Math.max(1, Math.floor(effectiveLimit * 0.1)))
-        .map((q) => q.ref)) ?? [];
-    if (selected.length > 0) {
-        info(`[improve] high-salience lane admitted ${selected.length} content-scored ref(s) ` +
-            `(threshold=${threshold}, requires content-derived encoding_source)`);
-    }
-    return selected;
-}
 /**
  * Score the merged refs: update `asset_outcome` (projected on a plan-only
  * run), compute each salience vector (keeping a stored content-derived
  * encoding score), then persist it.
  */
 function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
-    const { options, eventsCtx } = args;
+    const { eventsCtx } = args;
     const utilityMap = buildUtilityMap(mergedRefs, !persist);
     const lastUseMsByRef = withIndexDb(!persist, (db) => getLastUseMsByRef(db, mergedRefs)) ?? new Map();
     const outcomeSalience = updateOutcomeScores({
@@ -982,7 +925,6 @@ function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
         eventsCtx,
         persist,
     });
-    const outcomeWeightEnabled = (options.config ?? loadConfig()).improve?.salience?.outcomeWeightEnabled !== false;
     const storedEncoding = new Map();
     withRunState(eventsCtx, persist, (db) => {
         for (const r of mergedRefs) {
@@ -1005,7 +947,6 @@ function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
             outcomeSalience: outcomeSalience.get(r.ref),
             sizeBytes: fileSize(r.filePath),
             now,
-            outcomeWeightEnabled,
         }));
     }
     if (persist) {

package/dist/commands/improve/proactive-maintenance.js

@@ -6,8 +6,8 @@ import { computeSalience } from "./salience.js";
 const DAY_MS = 86_400_000;
 /** An asset is due when last reflected/distilled more than this many days ago (or never). */
 export const DEFAULT_DUE_DAYS = 30;
-/** Default bound on how many assets the selector surfaces per run. */
-export const DEFAULT_MAX_PER_RUN = 25;
+/** Fallback for `maxPerRun`; the same as the shipped `default` strategy. */
+export const DEFAULT_MAX_PER_RUN = 15;
 /** Size floor for the cost term, so tiny files don't divide by ~0. */
 const SIZE_FLOOR_BYTES = 200;
 /**

package/dist/commands/improve/reflect-noise.js

@@ -19,8 +19,7 @@ import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 /**
  * `noop` (identical up to trailing whitespace) and `cosmetic` (identical after
  * normalizing frontmatter as parsed YAML and prose as unwrapped text) never
- * become proposals. `low-value` (#639) is a small prose rewrite — few changed
- * words, nothing structural; the caller decides (off by default).
+ * become proposals.
  */
 export function classifyReflectChange(sourceContent, candidateContent) {
     if (normalizeTrailingWhitespace(sourceContent) === normalizeTrailingWhitespace(candidateContent))
@@ -32,13 +31,6 @@ export function classifyReflectChange(sourceContent, candidateContent) {
     catch {
         // unprovable → substantive
     }
-    try {
-        if (isLowValueChange(sourceContent, candidateContent))
-            return "low-value";
-    }
-    catch {
-        // unprovable → substantive
-    }
     return "substantive";
 }
 /** Not TODO, TBD or FIXME: an asset may carry those on purpose, and the owner does not want them refused. */
@@ -136,7 +128,7 @@ function frontmatterCopiedIntoBody(source, candidate, keys) {
     if (keys.length === 0)
         return false;
     const keyLine = new RegExp(`^(?:${keys.map(escapeRegExp).join("|")}):(?:[ \\t].*)?$`);
-    const keyLines = (text) => parseLowValueSections(text).proseLines.filter((line) => keyLine.test(line)).length;
+    const keyLines = (text) => parseSections(text).proseLines.filter((line) => keyLine.test(line)).length;
     if (keyLines(candidate) > keyLines(source))
         return true;
     const sourceBody = lettersAndDigits(splitFrontmatter(source).body);
@@ -166,44 +158,8 @@ export function splitFrontmatter(raw) {
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
     return m ? { fmText: m[1] ?? "", body: m[2] ?? "" } : { fmText: null, body: raw };
 }
-/** At most this many changed words (and at least 2 — one word may be a flag flip) is low-value. */
-const LOW_VALUE_TOKEN_THRESHOLD = 4;
-/** A change to any of these is never low-value. */
-const NEGATION_WORDS = new Set(["never", "not", "no", "don't", "avoid", "cannot", "can't"]);
-/** Lines recording a decision or outcome are always significant; their words are not counted. */
-const DECISION_MARKER_RE = /\b(decision|outcome)\b/i;
-const STRUCTURAL_LINE_RE = /^\s*(#{1,6}\s|[-*+]\s|\d{1,9}[.)]\s|---+|===+|\|\s)/;
-function isLowValueChange(source, candidate) {
-    const src = parseLowValueSections(source);
-    const cnd = parseLowValueSections(candidate);
-    // Code and frontmatter changes are always substantive.
-    if (src.codeFences.join("\n") !== cnd.codeFences.join("\n") || src.frontmatter !== cnd.frontmatter)
-        return false;
-    if (Math.abs(src.proseLines.length - cnd.proseLines.length) > 2)
-        return false;
-    let changedTokens = 0;
-    for (let i = 0; i < Math.max(src.proseLines.length, cnd.proseLines.length); i++) {
-        const srcLine = src.proseLines[i] ?? "";
-        const cndLine = cnd.proseLines[i] ?? "";
-        if (srcLine === cndLine || DECISION_MARKER_RE.test(srcLine) || DECISION_MARKER_RE.test(cndLine))
-            continue;
-        if (STRUCTURAL_LINE_RE.test(cndLine) || STRUCTURAL_LINE_RE.test(srcLine))
-            return false;
-        const srcTokens = tokenize(srcLine);
-        const cndTokens = tokenize(cndLine);
-        const srcNeg = new Set(srcTokens.filter((t) => NEGATION_WORDS.has(t)));
-        const cndNeg = new Set(cndTokens.filter((t) => NEGATION_WORDS.has(t)));
-        if (srcNeg.size !== cndNeg.size || [...srcNeg].some((t) => !cndNeg.has(t)))
-            return false;
-        // max(added, removed) approximates substitutions: "is→runs" counts once.
-        const srcSet = new Set(srcTokens);
-        const cndSet = new Set(cndTokens);
-        changedTokens += Math.max(cndTokens.filter((t) => !srcSet.has(t)).length, srcTokens.filter((t) => !cndSet.has(t)).length);
-    }
-    return changedTokens >= 2 && changedTokens < LOW_VALUE_TOKEN_THRESHOLD;
-}
 /** Frontmatter text, fenced code blocks, and prose lines (an unclosed fence counts as prose). */
-function parseLowValueSections(text) {
+function parseSections(text) {
     const { fmText, body } = splitFrontmatter(normalizeTrailingWhitespace(text));
     const codeFences = [];
     const proseLines = [];
@@ -230,14 +186,6 @@ function parseLowValueSections(text) {
         proseLines.push(...fence.lines);
     return { frontmatter: fmText ?? "", codeFences, proseLines };
 }
-function tokenize(line) {
-    return line
-        .toLowerCase()
-        .replace(/’/g, "'") // curly apostrophes still match "don't"
-        .replace(/[^a-z0-9'-]/g, " ")
-        .split(/\s+/)
-        .filter((t) => t.length > 0);
-}
 /** CRLF → LF, no trailing spaces per line, no trailing newlines. */
 export function normalizeTrailingWhitespace(text) {
     return text

package/dist/commands/improve/reflect.js

@@ -782,10 +782,9 @@ async function runReflectRefineIterations(args) {
 const NOISE_SUBREASONS = {
     noop: "reflect_skipped_noop",
     cosmetic: "reflect_skipped_cosmetic",
-    "low-value": "reflect_skipped_low_value",
 };
 /**
- * Apply the patch, drop a no-op/cosmetic (and optionally low-value) change,
+ * Apply the patch, drop a no-op/cosmetic change,
  * judge the exact content that would be persisted, then mint. A revision with a
  * deterministic defect is refused before the judge runs, whether or not the
  * gate is on.
@@ -798,15 +797,11 @@ async function finalizeReflectProposal(args) {
     // A patch that changes nothing leaves the asset as it is: an empty diff.
     const content = patched?.content ?? assetContent;
     const changeKind = classifyReflectChange(assetContent, content);
-    if (changeKind === "noop" ||
-        changeKind === "cosmetic" ||
-        (changeKind === "low-value" && options.lowValueFilter === true)) {
+    if (changeKind === "noop" || changeKind === "cosmetic") {
         run.emitFailed("no_change", NOISE_SUBREASONS[changeKind], options.ref, { changeKind, ...telemetry });
         const what = changeKind === "noop"
             ? "identical to the current asset (empty diff)"
-            : changeKind === "low-value"
-                ? "a low-value prose micro-rewrite (few changed tokens, no structural changes)"
-                : "a cosmetic-only reformat of the current asset (whitespace/fence/YAML-folding changes)";
+            : "a cosmetic-only reformat of the current asset (whitespace/fence/YAML-folding changes)";
         return reflectFailure(run, result, "no_change", `Reflect skipped: proposed content for ${payload.ref} is ${what}; no proposal created.`, false);
     }
     /** A judge refused the revision: record it for the ledger's rejection window and stop. */

package/dist/commands/improve/retrieval-scope.js

@@ -46,8 +46,8 @@ export function loadRetrievalScope(access, stashDir) {
             // Blocker 1 (second review round): a pair-pass ledger row must NOT mark
             // an asset "processed" — unlike every other stage, the pair pass judges
             // material against its NEIGHBOURS, not on its own merits, so its own
-            // attempt is not usage evidence the fallback lanes (proactive,
-            // high-salience) or promotion retries should be starved by. Left in
+            // attempt is not usage evidence the proactive lane
+            // or promotion retries should be starved by. Left in
             // the ledger for the pair pass's OWN eligibility
             // (selectInitiators reads content_hash directly, never this scope).
             // Proposal rows are untouched: a MINTED retire proposal is real

package/dist/commands/improve/salience.js

@@ -14,14 +14,10 @@ const RECENCY_FLOOR_HALFLIFE_DAYS = 180;
 /** Keeps frequency ordinal for assets whose last use is unknown. */
 const RECENCY_EPSILON = 0.01;
 const SIZE_FLOOR_BYTES = 200;
-/** Default weights: the outcome term is on (opt out with `improve.salience.outcomeWeightEnabled: false`). */
+/** Rank-score weights. */
 export const W_ENCODING = 0.25;
 export const W_OUTCOME = 0.15;
 export const W_RETRIEVAL = 0.6;
-/** Weights with the outcome term off. */
-export const W_ENCODING_PARITY = 0.3;
-export const W_OUTCOME_PARITY = 0;
-export const W_RETRIEVAL_PARITY = 0.7;
 /** Encoding salience by type, for assets with no content-derived score yet. */
 export const DEFAULT_TYPE_ENCODING_WEIGHTS = Object.freeze({
     skill: 0.9,
@@ -56,10 +52,7 @@ export function computeSalience(inputs) {
     const retrieval = rawRetrieval / (rawRetrieval + 1);
     // Larger assets rank slightly lower.
     const sizePenalty = 1 / Math.log10(Math.max(SIZE_FLOOR_BYTES, inputs.sizeBytes ?? 0));
-    const [we, wo, wr] = inputs.outcomeWeightEnabled !== false
-        ? [W_ENCODING, W_OUTCOME, W_RETRIEVAL]
-        : [W_ENCODING_PARITY, W_OUTCOME_PARITY, W_RETRIEVAL_PARITY];
-    const rankScore = clamp01((we * encoding + wo * outcome + wr * retrieval) * sizePenalty);
+    const rankScore = clamp01((W_ENCODING * encoding + W_OUTCOME * outcome + W_RETRIEVAL * retrieval) * sizePenalty);
     return { encoding, outcome, retrieval, rankScore, encodingSource };
 }
 export { getAssetSalience, getConsecutiveNoOps, recordNoOp, resetConsecutiveNoOps, upsertAssetSalience, } from "../../storage/repositories/salience-repository.js";

package/dist/commands/improve/stage.js

@@ -217,14 +217,18 @@ export function resolveQualityGateJudge(config, profile, processName, onNotices)
     return resolved.runner;
 }
 /** Lesson judge prompt: what the writer was given (the source and its feedback), the assets nearest the new lesson, the lesson. */
-export function buildJudgePrompt(lessonContent, sourceContent, related, feedback) {
+export function buildJudgePrompt(lessonContent, sourceContent, related, feedback, extending) {
     const lines = [
         "You are evaluating a lesson an agent wrote from a memory and the feedback about it, for an akm knowledge base.",
         "",
         "Score this lesson on each criterion from 1 (poor) to 5 (excellent):",
         "1. REUSABLE: Does the lesson state a rule an agent can use on another occasion, with the reason it holds? Score 1-2 when it only records what was done, shipped, decided, found or is pending, on a date or for one build, machine or project, or how a system is set up now, however it is phrased. Score 4-5 for a rule with its reason.",
-        '2. NON-REDUNDANCY: Compare the lesson only with the assets listed under "Existing assets nearest the new lesson" (each starts with "Existing asset ref:"); never with the source memory. When that list is absent, score 5. Score 1-2 when a listed asset already states the same rule, or states most of what the lesson says in broader words. Score 4-5 when the lesson gives a rule none of the listed assets gives, or when they are on other subjects.',
-        "3. GROUNDING: Is every statement in the lesson stated by the source or its feedback, in any words? Check each cause, step, number, rule and limit in the lesson against them. Score 4-5 when each is stated. Score 3 when one stretches what the source says. Score 1-2 when any is in neither, when the lesson drops a limit the source states (one place checked, not confirmed, a guess) and says more than it, or when it is about another subject than the source.",
+        extending !== undefined
+            ? "2. NON-REDUNDANCY: The proposed lesson is the existing lesson below with lines added. Compare each added line (a line the existing lesson does not have) only with the existing lesson, never with the source memory. Redundancy means the information is already in the existing lesson. Score 1-2 when an added line only says again what the existing lesson says: its rule or cause in other words, or the same rule applied to an example from the memory. Score 4-5 when every added line states a fact the existing lesson does not contain (a cause, number, version, limit, consequence or observation), however specific or tied to one incident it is: whether the lesson is general enough is REUSABLE's question, asked of the whole lesson, never of this criterion."
+            : '2. NON-REDUNDANCY: Compare the lesson only with the assets listed under "Existing assets nearest the new lesson" (each starts with "Existing asset ref:"); never with the source memory. When that list is absent, score 5. Score 1-2 when a listed asset already states the same rule, or states most of what the lesson says in broader words. Score 4-5 when the lesson gives a rule none of the listed assets gives, or when they are on other subjects.',
+        extending !== undefined
+            ? "3. GROUNDING: Is every statement in the lesson stated by the source, its feedback or the existing lesson below, in any words? Check each cause, step, number, rule and limit in the lesson against them. Score 4-5 when each is stated. Score 3 when one stretches what they say. Score 1-2 when any is in none of them, when it contradicts the existing lesson, or when it is about another subject than the source."
+            : "3. GROUNDING: Is every statement in the lesson stated by the source or its feedback, in any words? Check each cause, step, number, rule and limit in the lesson against them. Score 4-5 when each is stated. Score 3 when one stretches what the source says. Score 1-2 when any is in neither, when the lesson drops a limit the source states (one place checked, not confirmed, a guess) and says more than it, or when it is about another subject than the source.",
         "",
         "Source memory:",
         "```",
@@ -235,7 +239,10 @@ export function buildJudgePrompt(lessonContent, sourceContent, related, feedback
     if (feedback && feedback.length > 0) {
         lines.push("", "Feedback recorded about the memory (the writer saw it too):", "```", feedback.join("\n").slice(0, 1500), "```");
     }
-    if (related && related.length > 0) {
+    if (extending !== undefined) {
+        lines.push("", "Existing lesson that the proposed lesson extends (it is already in the library):", "```", extending.slice(0, 2000), "```");
+    }
+    else if (related && related.length > 0) {
         lines.push("", "Existing assets nearest the new lesson (they may be on another subject):");
         for (const asset of related)
             lines.push(`\nExisting asset ref: ${asset.ref}`, "```", asset.content.slice(0, 600), "```");
@@ -326,12 +333,10 @@ export function buildReflectJudgePrompt(candidateContent, sourceContent, feedbac
  * 17 of 19 of them bad on 2026-10-05. The rubric reserves 1-2 for a lesson that
  * records what was done instead of a rule, repeats an asset the library holds,
  * or states what neither its source nor its feedback does. The judge is shown
- * the feedback the writer saw, so a statement it supports is not an invention. A
- * contradiction of the source is the optional fidelity check's to send to a
- * human (`judgeAndQueue` in distill.ts).
+ * the feedback the writer saw, so a statement it supports is not an invention.
  */
 const GROUNDING_CRITERION = "grounding";
-const LESSON_REJECT_MAX_SCORE = 2;
+export const LESSON_REJECT_MAX_SCORE = 2;
 const LESSON_JUDGE_CRITERIA = ["reusable", "nonRedundancy", GROUNDING_CRITERION];
 const REFLECT_JUDGE_CRITERIA = ["need", "preservation", "quality"];
 /**
@@ -439,7 +444,7 @@ async function runQualityJudge(feature, config, prompt, keys, chat, options) {
 }
 /** Judge a proposed lesson (or knowledge promotion) against its source. */
 export function runLessonQualityJudge(config, lessonContent, sourceContent, chat, options = {}) {
-    const prompt = buildJudgePrompt(lessonContent, sourceContent, options.related, options.feedback);
+    const prompt = buildJudgePrompt(lessonContent, sourceContent, options.related, options.feedback, options.extending);
     return runQualityJudge("lesson_quality_gate", config, prompt, LESSON_JUDGE_CRITERIA, chat, options);
 }
 /** Judge an in-place reflect revision without new-lesson novelty criteria. */

package/dist/commands/lint/index.js

@@ -3,7 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { factDiagnostics, matchWorkflowPlaceholder, memoryOrphanStubApplies, nameOrTypeDiagnostics, ORPHANED_STUB_DETAIL, taskDiagnostics, workflowFrontendDiagnostics, workflowYamlSourceDiagnostics, } from "../../core/adapter/adapters/akm-lint.js";
+import { factDiagnostics, matchWorkflowPlaceholder, memoryOrphanStubApplies, nameOrTypeDiagnostics, ORPHANED_STUB_DETAIL, taskDiagnostics, workflowFrontendDiagnostics, } from "../../core/adapter/adapters/akm-lint.js";
 import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { adapterForId } from "../../core/adapter/registry.js";
 import { createValidateContext } from "../../core/adapter/validate-context.js";
@@ -79,7 +79,7 @@ function collectMarkdownFiles(dir, caseInsensitive = false) {
     }
     return results;
 }
-/** Peer workflow sources accepted by the source-IR compiler; `.yaml` remains unsupported. */
+/** Workflow sources: Markdown only. */
 function collectWorkflowFiles(dir) {
     if (!fs.existsSync(dir))
         return [];
@@ -99,7 +99,7 @@ function collectWorkflowFiles(dir) {
         if (!entry.isFile() && !entry.isSymbolicLink())
             continue;
         const extension = path.extname(entry.name).toLowerCase();
-        if (extension === ".md" || extension === ".yml")
+        if (extension === ".md")
             results.push(full);
     }
     return results.sort(compareCodePoints);
@@ -532,8 +532,8 @@ function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
     const dirsToScan = options.typeFilter ? STASH_SUBDIRS.filter((d) => d === options.typeFilter) : STASH_SUBDIRS;
     for (const subdir of dirsToScan) {
         const dirPath = path.join(stashRoot, subdir);
-        // Tasks have their own `.yml` plus near-miss collector. Workflows accept
-        // peer `.md`/`.yml` sources; every remaining AKM subdir is Markdown.
+        // Tasks have their own `.yml` plus near-miss collector; every other AKM
+        // subdir is Markdown.
         const files = subdir === "tasks"
             ? collectTaskFiles(dirPath)
             : subdir === "workflows"
@@ -580,21 +580,6 @@ function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
             catch {
                 continue;
             }
-            // GitHub-shaped YAML is a peer workflow source, not a Markdown document:
-            // no frontmatter/base/stub checks and no `--fix` mutation apply. Compile
-            // once through the shared source-IR frontend and route its findings.
-            if (subdir === "workflows" && path.extname(filePath).toLowerCase() === ".yml") {
-                const frontend = workflowYamlSourceDiagnostics(relPath, raw, filePath, stashRoot);
-                for (const finding of [...frontend.errors, ...frontend.warnings]) {
-                    if (isAdvisoryLintIssue(finding)) {
-                        warnings.push(finding);
-                    }
-                    else {
-                        flagged.push(finding);
-                    }
-                }
-                continue;
-            }
             let data;
             let body;
             let frontmatter;