akm-cli 0.9.31 → 0.10.261002-beta

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

@@ -22,7 +22,7 @@ import { getLiveRefSnapshot, isRefLiveInSnapshot, } from "../../storage/reposito
 import { clearAssetOutcomeMissing, countAssetOutcomeMissing, deleteAssetOutcomeMissingBefore, listAssetOutcomeMissingState, stampAssetOutcomeMissing, } from "../../storage/repositories/outcome-repository.js";
 import { clearAssetSalienceMissing, countAssetSalienceMissing, deleteAssetSalienceMissingBefore, listAssetSalienceMissingState, stampAssetSalienceMissing, } from "../../storage/repositories/salience-repository.js";
 import { readFreelistInfo, STATE_DB_VACUUMED_EVENT, vacuumIfReclaimable } from "../../storage/state-db-integrity.js";
-import { purgeOldTaskLogFiles } from "../../tasks/run/task-log.js";
+import { purgeOldRunLogFiles, purgeOldTaskLogFiles } from "../../tasks/run/task-log.js";
 import { expireStaleProposals, purgeOrphanProposals } from "../proposal/repository.js";
 import { checkDeadUrls } from "../url-checker.js";
 import { isDistillCandidateRef } from "./eligibility.js";
@@ -148,7 +148,6 @@ async function runLoopReflectPass(planned, env, tally) {
         ...(options.sourceName && primaryStashDir ? { target: { source: options.sourceName, root: primaryStashDir } } : {}),
         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
         eventSource: "improve",
-        lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
         ...(improveProfile.processes?.reflect?.defectFilter
             ? { defectFilter: improveProfile.processes.reflect.defectFilter }
             : {}),
@@ -174,10 +173,18 @@ async function runLoopReflectPass(planned, env, tally) {
         result,
     });
     // A quality rejection recorded itself, and the judge's text is no lesson for
-    // the next prompt; skips revisit on the `unchanged` cadence.
+    // the next prompt; skips revisit on the `unchanged` cadence. A transient
+    // failure (transport, parse, timeout, budget abort, crash) is not a verdict
+    // on the asset and writes no row, like distill: a `failed` row would advance
+    // the ledger cursor and consume the feedback that planned the ref. Only a
+    // guard rejection records `failed`.
     if (!result.ok && reason !== "quality_rejected") {
-        recordLoopAttempt(planned, env, "reflect", skipped ? "unchanged" : "failed", reason);
-        if (!skipped) {
+        if (skipped)
+            recordLoopAttempt(planned, env, "reflect", "unchanged", reason);
+        else if (reason === "content_policy_reject")
+            recordLoopAttempt(planned, env, "reflect", "failed", reason);
+        // A budget abort is no lesson for the next prompt either.
+        if (!skipped && reason !== "aborted") {
             tally.recentErrorPushes.push({
                 originator: "reflect",
                 message: result.error ?? reason ?? "unknown reflect error",
@@ -588,6 +595,12 @@ export function runRetentionPurgePass(ctx) {
     catch (err) {
         warnings.push(`task log files purge failed: ${errMessage(err)}`);
     }
+    try {
+        report("run_log_files_purged", "run_log_files/_purge", purgeOldRunLogFiles(retentionDays), "improve/index run log file(s)");
+    }
+    catch (err) {
+        warnings.push(`run log files purge failed: ${errMessage(err)}`);
+    }
     return { warnings };
 }
 /**

package/dist/commands/improve/planner.js

@@ -99,7 +99,6 @@ export function buildImproveExecutionPlan(input) {
             effective: { ...input.consolidation.effective },
             gates: {
                 profile: { ...input.consolidation.gates.profile },
-                minimumPool: { ...input.consolidation.gates.minimumPool },
                 delta: { ...input.consolidation.gates.delta },
             },
         },

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

@@ -45,7 +45,6 @@ import { findAssetFilePath } from "./eligibility.js";
 import { resolveImproveExecution } from "./execution.js";
 import { recordLedgerAttempt } from "./ledger.js";
 import { classifyReflectChange, findReflectDefect, splitFrontmatter } from "./reflect-noise.js";
-import { loadRetrievalQueries, runRetrievalRegressionGate } from "./retrieval-gate.js";
 import { callStageOnce, errMessage, mintProposal, noticeSet, rejectedProposalContext, resolveQualityGateJudge, runReflectQualityJudge, } from "./stage.js";
 const MAX_FEEDBACK_LINES = 10;
 const MAX_GLOBAL_FEEDBACK_LINES = 20;
@@ -779,13 +778,27 @@ async function runReflectRefineIterations(args) {
     }
     return result;
 }
+/**
+ * The judge's review band for a reflect revision: a non-pass whose mean is at or above this goes to a
+ * person (`judge-uncertain`); a lower one is refused. The judge's own review label starts at 2.5, but
+ * nothing labelled below 3.5 is worth a person's time. Labelled runs of the judge (akm-eval judge-gate,
+ * lab 27B Q2; ~/akm/eval/judge-gate/tuning), good / bad among non-passing verdicts:
+ *   mean >= 3.5, frontmatter-only proposals Opus reviewed: 17 / 9 (shipped judge, 113 proposals),
+ *     15 / 0, 18 / 9 and 15 / 5 (earlier rubric, three runs);
+ *   mean >= 3.5, public corpus of body rewrites: 12 / 35;
+ *   mean < 3.5, 396 labelled body rewrites: 6 / 285 (Q4 judge 5 / 177, Q2 judge 1 / 108);
+ *     public corpus 3 / 37; frontmatter-only proposals: 1 / 2 (shipped judge), 5 / 1 (earlier runs).
+ * Mean 4.0 with one criterion at 2 was good 14 / 0; mean 3.67 was 3 / 8. A rule on the lowest
+ * criterion did not help: a criterion at 3 or more is rare in a non-pass, and a 2 is the usual
+ * shape of a good one.
+ */
+const REFLECT_REVIEW_MIN_SCORE = 3.5;
 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 +811,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. */
@@ -833,6 +842,7 @@ async function finalizeReflectProposal(args) {
         return refuse(defect, { reflectDefect: defect }, `Reflect proposal refused before the judge: ${defect}`);
     let verdict;
     let judgeFailed = false;
+    let judgeUncertain = false;
     if (judge.enabled) {
         verdict = await runReflectQualityJudge(run.config, content, assetContent, feedback, options.chat, {
             runnerSelectionFrozen: true,
@@ -844,7 +854,9 @@ async function finalizeReflectProposal(args) {
         });
         // A judge that timed out, errored or replied unparseably gave no verdict: a person reviews the revision.
         judgeFailed = verdict.reviewNeeded === true && verdict.score === -1;
-        if (!verdict.pass && !judgeFailed) {
+        // A real score in the band is uncertain, not bad: a person decides, and no window is recorded.
+        judgeUncertain = verdict.reviewNeeded === true && verdict.score >= REFLECT_REVIEW_MIN_SCORE;
+        if (!verdict.pass && !judgeFailed && !judgeUncertain) {
             return refuse(verdict.reason, {
                 qualityScore: verdict.score,
                 qualityReason: verdict.reason,
@@ -852,32 +864,12 @@ async function finalizeReflectProposal(args) {
             }, `Reflect proposal quality gate rejected: score=${verdict.score}, reason="${verdict.reason}"`);
         }
     }
-    // #722: a revision of an existing asset must not grade lower on its own retrieval queries.
-    if (verdict?.pass && judge.runner) {
-        const retrieval = await runRetrievalRegressionGate({
-            ref: payload.ref,
-            before: assetContent,
-            after: content,
-            queries: loadRetrievalQueries({ proposalsCtx: options.ctx, eventsCtx: options.eventsCtx }, payload.ref),
-            runner: judge.runner,
-            ...(options.chat ? { chat: options.chat } : {}),
-            ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),
-            ...(options.signal ? { signal: options.signal } : {}),
-            onNotices: run.notices.add,
-        });
-        if (!retrieval.pass) {
-            return refuse(retrieval.reason, {
-                retrievalRegression: true,
-                retrievalQueries: retrieval.queries,
-                ...(retrieval.oldMean !== undefined ? { retrievalGradeBefore: retrieval.oldMean } : {}),
-                ...(retrieval.newMean !== undefined ? { retrievalGradeAfter: retrieval.newMean } : {}),
-            }, `Reflect proposal refused: ${retrieval.reason}`);
-        }
-    }
     const reviewReasons = [
         ...(judge.skippedNoJudge ? ["no-judge-configured"] : []),
         ...(judgeFailed ? ["judge-error"] : []),
+        ...(judgeUncertain ? ["judge-uncertain"] : []),
     ];
+    const gateReview = judgeFailed || judgeUncertain;
     const proposal = mintProposal(run.stash, options.ctx, {
         ref: payload.ref,
         ...(options.target ? { target: options.target } : {}),
@@ -892,7 +884,9 @@ async function finalizeReflectProposal(args) {
             review: {
                 reason: reviewReasons.join("+"),
                 // The quality gate's hand-off to a person, as distill's: the triage drain leaves it alone.
-                gate: judgeFailed ? "quality-gate" : "reflect",
+                gate: gateReview ? "quality-gate" : "reflect",
+                ...(gateReview && verdict?.criteria ? { scores: verdict.criteria } : {}),
+                ...(gateReview && verdict?.reason ? { judgeReason: verdict.reason } : {}),
             },
         }
         : { judged: verdict });
@@ -904,7 +898,8 @@ async function finalizeReflectProposal(args) {
             source: "reflect",
             engine: run.engineName,
             ...(judge.skippedNoJudge ? { qualityGateSkippedNoJudge: true } : {}),
-            ...(judgeFailed ? { qualityReason: verdict?.reason } : {}),
+            ...(judgeFailed || judgeUncertain ? { qualityReason: verdict?.reason } : {}),
+            ...(judgeUncertain ? { qualityScore: verdict?.score } : {}),
             ...telemetry,
         },
     }, options.eventsCtx);

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

@@ -0,0 +1,37 @@
+// 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/.
+/**
+ * An asset's own retrieval queries from the usage log, cleaned for replay.
+ * The consolidate continuity check replays them against a retiring asset's
+ * successor.
+ */
+import { nonTaskInput } from "../../core/non-task-input.js";
+import { listRetrievalQueries } from "../../indexer/usage/usage-events.js";
+import { readLedgerDb, stripBundle } from "./ledger.js";
+/** Queries kept per asset. */
+const MAX_QUERIES = 5;
+/** The retrieval suite treats a longer input as a paste, not a query. */
+const MAX_QUERY_CHARS = 2000;
+/** Up to five distinct task queries, in the given order, whitespace collapsed. */
+export function usableRetrievalQueries(raw) {
+    const out = [];
+    for (const text of raw) {
+        const query = text.replace(/\s+/g, " ").trim();
+        if (!query || query.length > MAX_QUERY_CHARS || nonTaskInput(query) || out.includes(query))
+            continue;
+        out.push(query);
+        if (out.length === MAX_QUERIES)
+            break;
+    }
+    return out;
+}
+/** The asset's own retrieval queries from the usage log (none when state.db cannot be read). */
+export function loadRetrievalQueries(access, ref) {
+    try {
+        return usableRetrievalQueries(readLedgerDb(access, (db) => listRetrievalQueries(db, stripBundle(ref))) ?? []);
+    }
+    catch {
+        return [];
+    }
+}