akm-cli 0.9.20 → 0.9.22

package/CHANGELOG.md

@@ -4,7 +4,119 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [Unreleased]
+## [0.9.22] - 2026-10-01
+
+### Fixed
+
+- **Accepting a proposal no longer rewrites a long description at its first line
+  break.** `yaml.stringify`, which reflect and the other writers serialize
+  frontmatter with, wraps a description past about 80 columns over indented
+  lines. The truncation repair that `akm proposal accept` runs before it
+  promotes read only the first of those lines. When that line ended in a
+  connector word (`the`, `and`) or a comma it took the wrap for a truncation,
+  dropped the tail words, added a period and left the continuation lines
+  behind: `...the cooldowns that drive the` followed by `rest of the pipeline`
+  was written as `...the cooldowns that drive.` followed by `rest of the
+  pipeline`. Plain, single-quoted and double-quoted descriptions were all
+  damaged this way, and the repair has behaved so since it shipped in
+  0.9.0-beta.36 (#645). It now runs only on a single-line description and
+  leaves a wrapped one exactly as proposed. Assets already promoted with a
+  damaged description are not repaired by this change (the dropped words and the
+  stray period stay in them), so they need a separate repair.
+- **The same repair no longer rewrites a body line or another key.** It looked
+  for `description:` in the whole file, and its `\s*` ran past the end of the
+  line. A file whose frontmatter had no description had a body line starting
+  with `description:` completed instead, and an empty `description:` had the
+  next key's line rewritten (`title: Notes about how we configure the` became
+  `title: Notes about how we configure.`). It now reads only the `description:`
+  line of the frontmatter block. Content already promoted that way is not
+  repaired by this change.
+
+## [0.9.21] - 2026-10-01
+
+### Changed
+
+- **`akm improve` rewrites an asset only from negative feedback.** Reflect's
+  signal delta reads negative feedback only, so an asset whose recent feedback
+  is positive or a note is no longer planned for a rewrite; any signal planned
+  one before. `akm feedback <ref> --negative --reason "<what is wrong and what
+  should change>"` flags the asset for review, and the next improve run
+  proposes a fix based on the reason. `--positive` records that the asset
+  helped (it raises its ranking) and never triggers a rewrite. An explicit ref
+  (`akm improve skills/x`) still plans one, and distill still reads any recent
+  signal on a memory.
+- **The fallback lanes score assets and no longer plan them.** High salience,
+  and proactive maintenance in a strategy that enables it (the shipped
+  `proactive-maintenance` strategy), still pick assets and score them
+  (salience and outcome), but a pick no longer enters the loop, so nothing is
+  reflected or distilled for it and improve no longer rewrites assets on a
+  proactive cadence. `eligibilitySource` is now `signal-delta` or `scope`;
+  `proactive` and `high-salience` stay valid on the rows an older release wrote.
+  `--require-feedback-signal` still turns the lanes off.
+- **`distill.requirePlannedRefs` is `false` in the `default` and `thorough`
+  strategies** (the other presets inherit it from `default`). With reflect
+  planned only from negative feedback, `true` would have skipped distill on
+  every run where no ref has negative feedback; distill now keeps working
+  through memories with fresh feedback on each run. A strategy that sets it
+  `true` still skips distill when no ref is planned for reflect.
+- **`akm feedback`'s help and errors, both CLI hints, the stash README and the
+  docs say what each signal does:** `--negative --reason` flags the asset for
+  review and improve proposes a fix from the reason, so the reason should say
+  what is wrong and what should change; `--positive` raises the ranking and
+  does not trigger a rewrite. They also say that improve no longer rewrites on
+  a proactive cadence or from positive signals. The `default` and
+  `proactive-maintenance` strategy descriptions match.
+- **The reflect judge asks whether a rewrite is needed, and both judges pass
+  only when every criterion scores 4 or more.** Judging on the mean (3.5 or
+  more) let rewrites that only reworded a correct asset through. The reflect
+  judge's criteria are now **need** (does the revision fix a concrete problem
+  in the source: something the feedback reports, a factual error, or broken,
+  garbled, truncated or missing text, frontmatter fields included; rewording,
+  restating, reformatting or adding headings scores 1 or 2), **preservation**
+  and **quality**, replacing feedback alignment, preservation and quality, and
+  the "overlap with the source is expected" line is gone. Its JSON keys are
+  `need`, `preservation` and `quality`. The lesson judge passes only when
+  novelty and non-redundancy both score 4 or more. A verdict that does not
+  pass keeps its routing (a mean of 2.5 or more is a review, below that a
+  rejection) and the grounding rules are unchanged, grounding staying outside
+  the mean and the pass rule.
+- **A quality-judge pass keeps its evidence.** The `staged` decision the
+  quality gate stamps on a proposal now carries the per-criterion `scores` and
+  the judge's `judgeReason` (`gateDecision.scores`, `gateDecision.judgeReason`
+  in `akm proposal show --format json`), and they stay on the proposal when the
+  drain accepts it, so a later audit can read why a rewrite passed.
+- **Each accepted proposal is committed as it happens when its bundle is a git
+  repository.** Manual `akm proposal accept`, `akm proposal drain`, the improve
+  triage pre-pass and judgment accepts all commit exactly the paths the accept
+  wrote or removed, a retirement's archived copy and tombstone and the source
+  memory a consolidate promotion retires included, as one local commit
+  `akm accept: <generator> <proposal-id-8> <ref>`. Before, only a `kind: "git"`
+  bundle committed at accept; an accept into a filesystem bundle with a `.git`
+  directory (the working bundle `akm init` creates is one) stayed uncommitted
+  until a sync, and a standalone `akm proposal accept` never committed it. A
+  commit that fails warns and the accept stands. A non-git bundle is
+  unchanged.
+- **The end-of-run sync and `akm sync` commit even when they cannot push.** A
+  branch with no upstream, or behind or diverged from it, used to fail before
+  committing, leaving the run's changes in the working tree. They are now
+  committed and only the push is skipped, with `not pushed: ...` as the result's
+  `reason`. A branch ahead of its upstream (an accept commits locally) is pushed
+  along with the sync commit, where it used to be refused.
+
+### Fixed
+
+- **A dotted token no longer splits a synthesized description.** `akm
+  remember` ended a sentence at every `.`, so `192.168.0.203` became `192. 168.
+  0. 203` and `0.9.12` became `0. 9. 12`. A `.`, `!` or `?` now ends a sentence
+  only when whitespace or the end of the text follows it.
+- **The nightly commit message's `{accepted}` and the run metrics count the
+  proposals triage promoted.** `{accepted}`, `autoAcceptedCount` in
+  `improve_runs.metrics_json` and `improve.autoAccept.promoted` in `akm health`
+  read `gateAutoAcceptedCount`, which nothing has set since the confidence gate
+  was deleted, so they were always 0. They read the triage pre-pass's promoted
+  count, and the dead field is gone from the result type. A result row an older
+  akm wrote with the field still decodes in `akm health`: the decoder accepts
+  the key and ignores its value.
 
 ## [0.9.20] - 2026-09-30
 

package/dist/assets/hints/cli-hints-full.md

@@ -94,15 +94,20 @@ akm import ./doc.md --target my-other-bundle    # Route import to a named writab
 akm workflow create ship-release               # Create a workflow asset in the bundle
 akm lint --type workflows                      # Parse and compile every .md/.yml workflow source; list every error
 akm workflow run workflows/ship-release        # Start or resume and execute the workflow
-akm feedback skills/code-review --positive     # Record that an asset helped
-akm feedback agents/reviewer --negative --reason "wrong framework" # Record why an asset missed the mark
+akm feedback skills/code-review --positive     # Record that an asset helped (ranks it higher; no rewrite)
+akm feedback agents/reviewer --negative --reason "wrong framework" # Flag it for review: improve proposes a fix from the reason
 akm feedback memories/deployment-notes --positive # Works for memories too
 akm feedback env/prod --positive               # Records env feedback without surfacing values
 ```
 
 Use `akm feedback` whenever an asset's content materially helps, or proves wrong,
-stale or unhelpful, so future search ranking can learn from actual usage. An akm
-command that fails says nothing about the asset; don't record it as feedback.
+stale or unhelpful, so future search ranking can learn from actual usage.
+`akm feedback <ref> --negative --reason "<what is wrong and what should change>"`
+flags the asset for review: the next improve run proposes a fix based on your
+reason, so be specific. `--positive` records that an asset helped (it raises its
+ranking) and does not trigger a rewrite; improve no longer rewrites assets from
+positive signals or on a proactive cadence. An akm command that fails says
+nothing about the asset; don't record it as feedback.
 
 ## LLM Wiki bundles
 

package/dist/assets/hints/cli-hints-short.md

@@ -8,7 +8,7 @@ For any task, follow this loop:
 1. `akm curate "<task>"` — find the best matching asset
 2. `akm show <ref>` — read the schema (field names and structure)
 3. Edit the workspace file using schema field names + task-specific values from your README
-4. `akm feedback <ref> --positive` — record that the asset helped; use `--negative --reason "..."` when its content was wrong, stale or unhelpful. A failed akm command (e.g. `akm show` erroring) is not feedback on the asset — don't record it.
+4. `akm feedback <ref> --positive` — record that the asset helped (it raises its ranking and does not trigger a rewrite); when its content was wrong, stale or unhelpful, `akm feedback <ref> --negative --reason "<what is wrong and what should change>"` flags it for review: the next improve run proposes a fix based on your reason, so be specific. A failed akm command (e.g. `akm show` erroring) is not feedback on the asset — don't record it.
 
 For workflow tasks:
 1. `akm show workflows/<name>` — inspect the procedure before executing it
@@ -39,7 +39,8 @@ akm import ./doc.md --target my-bundle         # Route import to a named writabl
 akm proposal diff skills/akm-dream            # Diff proposal by ref, UUID, or 8-char prefix
 akm proposal accept 7c115132                  # Accept by UUID prefix
 akm proposal reject skills/my-skill --reason "..."  # Reject by ref
-akm feedback <ref> --positive|--negative      # Record whether an asset helped
+akm feedback <ref> --positive                 # Record that an asset helped (ranks it higher; no rewrite)
+akm feedback <ref> --negative --reason "..."  # Flag it for review: the next improve run proposes a fix from your reason
 akm bundle add <ref>                                 # Add a source (npm, GitHub, git, local dir)
 akm clone <ref>                               # Copy an asset to the working bundle (optional --dest arg to clone to specific location)
 akm sync                                      # Commit (and push if writable remote) changes in the primary bundle (--no-push to commit only)
@@ -65,8 +66,10 @@ akm search "<query>" --from registry          # Search all registries (registry
 
 When an asset's content meaningfully helps, or proves wrong, stale or unhelpful,
 record that with `akm feedback` so future search ranking can learn from real
-usage. An akm command that fails says nothing about the asset; don't record it
-as feedback.
+usage. Only negative feedback with a specific reason gets the asset reviewed and
+fixed: improve no longer rewrites assets from positive signals or on a
+proactive cadence. An akm command that fails says nothing about the asset;
+don't record it as feedback.
 
 ## Error Shapes and Exit Codes
 

package/dist/assets/improve-strategies/default.json

@@ -1,12 +1,12 @@
 {
-  "description": "Standard improve pass — reflect, distill, consolidation (promotion plus the reviewed pair-pass retire/supersede proposals), and validation. Memory inference is listed below but only runs when experimental.improveAutonomy is set; improve-stage extract and proactive maintenance off.",
+  "description": "Standard improve pass — reflect (rewrites only from negative feedback), distill, consolidation (promotion plus the reviewed pair-pass retire/supersede proposals), and validation. Memory inference is listed below but only runs when experimental.improveAutonomy is set; improve-stage extract and proactive maintenance off.",
   "processes": {
     "reflect": {
       "enabled": true,
       "limit": 25,
       "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
-    "distill": { "enabled": true, "allowedTypes": ["memory"], "requirePlannedRefs": true },
+    "distill": { "enabled": true, "allowedTypes": ["memory"], "requirePlannedRefs": false },
     "consolidate": { "enabled": true, "allowedTypes": ["memory"] },
     "memoryInference": { "enabled": true },
     "extract": { "enabled": false, "triage": { "enabled": true, "minScore": 2 } },

package/dist/assets/improve-strategies/proactive-maintenance.json

@@ -1,5 +1,5 @@
 {
-  "description": "Opt-in proactive-maintenance pass — reflect, distill, proposal triage (promote, high budget), and the proactive-maintenance lane (maxPerRun 100); consolidate/memoryInference/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
+  "description": "Opt-in proactive-maintenance pass — reflect (on negative feedback), distill, proposal triage (promote, high budget), and the proactive-maintenance lane (maxPerRun 100), which picks due assets for scoring but plans no rewrite; consolidate/memoryInference/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
   "processes": {
     "reflect": {
       "enabled": true,

package/dist/assets/improve-strategies/thorough.json

@@ -9,7 +9,7 @@
     "distill": {
       "enabled": true,
       "allowedTypes": ["memory"],
-      "requirePlannedRefs": true
+      "requirePlannedRefs": false
     },
     "consolidate": {
       "enabled": true,

package/dist/assets/stash-skeleton/README.md

@@ -77,9 +77,13 @@ akm search "<query>" --type skill
 ### Recording feedback and new knowledge
 
 ```sh
-# Mark an asset as helpful (improves future rankings)
+# Mark an asset as helpful (raises its ranking; does not trigger a rewrite)
 akm feedback <ref> --positive
 
+# Flag an asset for review: the next improve run proposes a fix based on your
+# reason, so be specific about what is wrong and what should change
+akm feedback <ref> --negative --reason "<what is wrong and what should change>"
+
 # Capture a durable lesson or memory from the current session
 akm remember "<fact or lesson>"
 ```

package/dist/commands/feedback-cli.js

@@ -190,6 +190,10 @@ export const feedbackCommand = defineJsonCommand({
     meta: {
         name: "feedback",
         description: "Record positive or negative feedback for any indexed bundle asset.\n\n" +
+            '`akm feedback <ref> --negative --reason "<what is wrong and what should change>"` flags\n' +
+            "the asset for review: the next improve run proposes a fix based on your reason, so be\n" +
+            "specific. `--positive` records that an asset helped (it raises its ranking) and does not\n" +
+            "trigger a rewrite.\n\n" +
             "Both signals adjust the asset's usefulness score right away, in the same\n" +
             "process: positive feedback raises it, negative lowers it, and recent\n" +
             "feedback counts for more than old feedback. No reindex is needed — the new\n" +
@@ -200,15 +204,19 @@ export const feedbackCommand = defineJsonCommand({
         // and throw a structured UsageError below so exit code is 2 (USAGE) rather
         // than citty's default 0 (help banner).
         ref: { type: "positional", description: "Asset ref ([bundle//]conceptId, e.g. lessons/deploy)", required: false },
-        positive: { type: "boolean", description: "Record positive feedback (boosts ranking immediately)", default: false },
+        positive: {
+            type: "boolean",
+            description: "Record that the asset helped (raises its ranking immediately; does not trigger a rewrite)",
+            default: false,
+        },
         negative: {
             type: "boolean",
-            description: "Record negative feedback (lowers ranking immediately, no reindex needed).",
+            description: "Flag the asset for review: the next improve run proposes a fix from --reason (also lowers its ranking immediately, no reindex needed).",
             default: false,
         },
         reason: {
             type: "string",
-            description: "What was wrong with (or right about) the asset's content (required for negative feedback by default; used by distillation). Not for akm command errors.",
+            description: "What is wrong with the asset's content and what should change; the next improve run proposes a fix from it, so be specific (required for negative feedback by default). Not for akm command errors.",
         },
         "failure-mode": {
             type: "string",
@@ -260,12 +268,12 @@ export const feedbackCommand = defineJsonCommand({
             const cfg = loadConfig();
             const requireReason = cfg.feedback?.requireReason ?? true; // Default: true (F-3 / #384)
             if (requireReason) {
-                throw new UsageError("Negative feedback requires --reason (structured failure signals are needed for distillation). " +
+                throw new UsageError("Negative feedback requires --reason: the next improve run proposes a fix from it, so say what is wrong and what should change. " +
                     "Use --failure-mode for a curated taxonomy or --reason for free text. " +
-                    "Set feedback.requireReason: false in akm.json to downgrade to a warning.", "MISSING_REQUIRED_ARGUMENT", `Hint: akm feedback ${ref} --negative --reason "..." [--failure-mode incorrect|outdated|dangerous|incomplete|redundant]`);
+                    "Set feedback.requireReason: false in akm.json to downgrade to a warning.", "MISSING_REQUIRED_ARGUMENT", `Hint: akm feedback ${ref} --negative --reason "<what is wrong and what should change>" [--failure-mode incorrect|outdated|dangerous|incomplete|redundant]`);
             }
             else {
-                warn("Warning: negative feedback without --reason provides less distillation signal.");
+                warn("Warning: negative feedback without --reason gives the next improve run nothing to base a fix on.");
             }
         }
         const rawTags = parseAllFlagValues("--tag");

package/dist/commands/health/improve-metrics.js

@@ -190,7 +190,7 @@ function projectRunMetrics(result) {
                 (metrics.actions.distill.skippedByReason[reason] ?? 0) + toFiniteNumber(count);
         }
     }
-    metrics.autoAccept.promoted += toFiniteNumber(result.gateAutoAcceptedCount);
+    metrics.autoAccept.promoted += toFiniteNumber(result.triage?.promoted);
     metrics.autoAccept.validationFailed += toFiniteNumber(result.gateAutoAcceptFailedCount);
     const memorySummary = result.memorySummary;
     if (memorySummary) {

package/dist/commands/improve/distill.js

@@ -434,6 +434,7 @@ function qualityGateEnabled(run) {
 async function judgeAndQueue(run, out) {
     let content = out.content;
     let confidence;
+    let judged;
     if (qualityGateEnabled(run)) {
         const similarLessons = await run.similar(content.slice(0, 500), 3);
         // The judge reads what the generator read: the source body, without its frontmatter (buildDistillPrompt).
@@ -452,6 +453,7 @@ async function judgeAndQueue(run, out) {
         }
         if (verdict.score > 0)
             confidence = verdict.score / 5;
+        judged = verdict;
     }
     let frontmatter;
     if (out.promotion) {
@@ -489,7 +491,7 @@ async function judgeAndQueue(run, out) {
         ...(run.options.eligibilitySource ? { eligibilitySource: run.options.eligibilitySource } : {}),
         // The ledger keys the attempt by the input, not the output.
         attemptedRefs: [run.ledgerRef],
-    }, { judged: confidence !== undefined });
+    }, { judged });
     persistOutputEncodingSalience(run, out.ref, content);
     const swapped = out.descriptionSwapped ? { descriptionSwapped: out.descriptionSwapped } : {};
     emitDistill(run, {

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

@@ -220,7 +220,7 @@ export const improveCommand = defineCommand({
         },
         "require-feedback-signal": {
             type: "boolean",
-            description: "Only process assets with recent feedback signals (disables the proactive/high-salience fallback lanes)",
+            description: "Turn the proactive/high-salience fallback lanes off (they only select and score assets; a rewrite needs negative feedback)",
             default: false,
         },
         "json-to-stdout": {

package/dist/commands/improve/improve.js

@@ -9,7 +9,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
-import { bundlesToSourceEntries, loadConfig, } from "../../core/config/config.js";
+import { bundlesToSourceEntries, loadConfig } from "../../core/config/config.js";
 import { ConfigError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { classifyImproveAction, foldDistillSkipped } from "../../core/improve-types.js";
@@ -39,13 +39,11 @@ import { akmDistill } from "./distill.js";
 import { collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
 import { eligibleRefCount, projectResolvedProcessRouting, resolveImprovePlan, resolveImproveStrategy, } from "./improve-strategies.js";
 import { buildImproveUsageReport } from "./improve-usage-report.js";
-import { lastAttemptByRef, loadLedgerSnapshot } from "./ledger.js";
 import { improveLockPath, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
 import { analyzeMemoryCleanup, purgeGracedArchive, RETIRE_GRACE_DAYS, } from "./memory/memory-improve.js";
 import { buildImproveExecutionPlan } from "./planner.js";
 import { CONSOLIDATION_CONFIG_KEYS, pickDefined, recordImproveSkip, runImprovePreparationStage } from "./preparation.js";
-import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js";
 import { akmReflect } from "./reflect.js";
 import { errMessage, noticeSet } from "./stage.js";
 export { runImproveMaintenancePasses } from "./loop-stages.js";
@@ -57,7 +55,7 @@ export function renderSyncCommitMessage(template, result, nowMs) {
         time: iso.slice(11, 19),
         scope: result.scope.value ?? result.scope.mode,
         refs: String(result.plannedRefs.length),
-        accepted: String(result.gateAutoAcceptedCount ?? 0),
+        accepted: String(result.triage?.promoted ?? 0),
         triage_promoted: String(result.triage?.promoted ?? 0),
         triage_rejected: String(result.triage?.rejected ?? 0),
         runId: result.runId ?? "",
@@ -758,25 +756,6 @@ function makeCommitStashBatch(deps) {
         }
     };
 }
-/**
- * Re-read the improve ledger under the lock and drop proactive refs another run
- * attempted after this one planned.
- */
-export function refilterProactiveLoopRefs(loopRefs, improveProfile, ledgerAccess) {
-    const proactiveLoopRefs = loopRefs.filter((r) => r.eligibilitySource === "proactive");
-    if (proactiveLoopRefs.length === 0 || !ledgerAccess.stashDir)
-        return loopRefs;
-    const ledger = loadLedgerSnapshot({ eventsCtx: ledgerAccess.eventsCtx }, ledgerAccess.stashDir, [
-        "reflect",
-        "distill",
-    ]);
-    const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, lastAttemptByRef(ledger, "reflect", proactiveLoopRefs), lastAttemptByRef(ledger, "distill", proactiveLoopRefs), improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS, Date.now()).map((r) => r.ref));
-    const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));
-    if (dropped.length === 0)
-        return loopRefs;
-    info(`[improve] post-lock cooldown re-filter: dropped ${dropped.length} proactive ref(s) claimed by concurrent run (${dropped.map((r) => r.ref).join(", ")})`);
-    return loopRefs.filter((r) => r.eligibilitySource !== "proactive" || stillDue.has(r.ref));
-}
 /**
  * The audit events for refs and lanes this run will not touch, then
  * preparation → loop → post-loop. No post-loop work starts past the budget; the
@@ -824,10 +803,7 @@ async function runImproveStageSequence(run, collected, preEnsureCleanupWarnings,
         options,
         reflectFn: run.reflectFn,
         distillFn: run.distillFn,
-        loopRefs: refilterProactiveLoopRefs(preparation.loopRefs, improveProfile, {
-            stashDir: primaryStashDir ?? options.stashDir,
-            eventsCtx,
-        }),
+        loopRefs: preparation.loopRefs,
         actions: preparation.actions,
         signalBearingSet: preparation.signalBearingSet,
         distillCooledRefs: preparation.distillCooledRefs,

package/dist/commands/improve/preparation.js

@@ -8,10 +8,11 @@
  *
  * 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. Refs without recent feedback can still be picked
- * by the fallback lanes (proactive maintenance, high salience); 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.
+ * 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
+ * by salience, checked on disk and capped. A plan-only run evaluates the same
+ * selectors against read snapshots and writes nothing.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -549,6 +550,7 @@ export function buildSnapshotManifest(args) {
     const candidates = args.postCleanupRefs.filter((r) => !args.validationFailureRefs.has(r.ref));
     const refByKey = new Map(candidates.map((r) => [keyOf(r), r.ref]));
     const latestFeedbackTs = new Map();
+    const latestNegativeTs = new Map();
     const feedback = new Map(candidates.map((r) => [r.ref, { hasSignal: false, positive: 0, negative: 0 }]));
     if (candidates.length > 0) {
         for (const e of readEvents({ type: "feedback" }, eventsCtx).events) {
@@ -557,12 +559,14 @@ export function buildSnapshotManifest(args) {
             if (!ref || !entry)
                 continue;
             const ts = e.ts ?? "";
+            const signal = e.metadata?.signal;
             if (ts >= feedbackSinceCutoff && isSignalEvent(e.metadata)) {
                 entry.hasSignal = true;
                 if (ts > (latestFeedbackTs.get(ref) ?? ""))
                     latestFeedbackTs.set(ref, ts);
+                if (signal === "negative" && ts > (latestNegativeTs.get(ref) ?? ""))
+                    latestNegativeTs.set(ref, ts);
             }
-            const signal = e.metadata?.signal;
             if (signal === "positive")
                 entry.positive++;
             else if (signal === "negative")
@@ -576,6 +580,7 @@ export function buildSnapshotManifest(args) {
         feedbackSinceCutoff,
         nowIso: new Date().toISOString(),
         latestFeedbackTs,
+        latestNegativeTs,
         ledger,
         lastReflectAttemptAt: lastAttemptByRef(ledger, "reflect", candidates),
         lastDistillAttemptAt: lastAttemptByRef(ledger, "distill", candidates),
@@ -584,19 +589,21 @@ export function buildSnapshotManifest(args) {
 }
 /**
  * Partition the post-cleanup refs against the ledger:
- *  - eligibleRefs: reflect's signal delta passes (distill may still be cooled);
- *  - distillOnlyRefs: only distill's passes, on a distill candidate;
+ *  - eligibleRefs: reflect's signal delta passes, which only fresh negative
+ *    feedback can do (distill may still be cooled);
+ *  - 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;
+ *    fallback lanes, which only score them;
  *  - fullySkippedCount: feedback on record but nothing new, or a live window.
  * An explicit `--scope <ref>` bypasses every gate.
  */
 export function partitionBySignalDelta(args) {
     const { postCleanupRefs, validationFailureRefs } = args;
-    const { latestFeedbackTs, ledger, nowIso } = args.snapshot;
-    // Newer feedback lifts a revisit window, never a rejection.
+    const { latestFeedbackTs, latestNegativeTs, ledger, nowIso } = args.snapshot;
+    // Newer feedback lifts a revisit window, never a rejection. Reflect reads negative feedback only.
     const deltaPasses = (candidate, source) => {
-        const feedbackAt = latestFeedbackTs.get(candidate.ref);
+        const feedbackAt = (source === "reflect" ? latestNegativeTs : latestFeedbackTs).get(candidate.ref);
         if (!feedbackAt)
             return false;
         const row = ledgerRowFor(ledger, source, candidate.ref, candidate.itemRef);
@@ -639,8 +646,8 @@ export function partitionBySignalDelta(args) {
 }
 /**
  * Pick the loop's refs: signal delta, the fallback lanes (unless
- * `--require-feedback-signal`), lane attribution, salience, the
- * no-op-dampened ranking, the disk check and the limit.
+ * `--require-feedback-signal`; they score, never plan), 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;
@@ -678,16 +685,13 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     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 usage signals gate the pool.
+    // 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 : options.requireFeedbackSignal ? signalFiltered : signalAndRetrievalRefs;
-    // Lane attribution, weakest first so the strongest wins: high-salience <
-    // proactive < signal-delta, and an explicit ref scope over everything.
+    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.
     const sourceByRef = new Map();
-    for (const r of highSalienceRefs)
-        sourceByRef.set(r.ref, "high-salience");
-    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")
@@ -695,7 +699,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, mergedRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
+    const salienceMap = scoreSalience(args, scoredRefs, 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) => {
@@ -724,8 +728,7 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     const deferred = actionableRefs.length - selection.loopRefs.length;
     info(`[improve] ${actionableRefs.length} actionable; ${selection.loopRefs.length} will be processed` +
         (options.limit && deferred > 0 ? ` (--limit ${options.limit} applied; ${deferred} deferred)` : ""));
-    // Skip observability waits until every fallback lane has finalized the
-    // survivors, so a rescued ref is never also reported skipped.
+    // Skip observability: every candidate that did not survive into the loop pool is reported skipped.
     const survivors = new Set(sorted.map((c) => c.ref));
     const skipped = fallbackEligible.filter((c) => !survivors.has(c.ref));
     const retrievalSkipped = skipped.filter((c) => outOfScope.has(c.ref));
@@ -770,7 +773,7 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
         {
             name: "signal",
             removed: signalSkipped.length,
-            reason: "no fresh signal since the last attempt (or an improve-ledger window) and no fallback lane selected the ref",
+            reason: "no fresh negative feedback (or, for distill, any signal) since the last attempt, or a ledger window holds it",
         },
         { name: "disk", removed: missing.length, reason: "backing asset is absent on disk" },
         { name: "limit", removed: selection.limitRemoved, reason: "deferred by the effective run limit" },
@@ -803,9 +806,11 @@ function fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, ev
     return out;
 }
 /**
- * Proactive maintenance (default off, whole-stash/type runs): revisit stable
- * assets on a schedule. The due gate doubles as the rotation cooldown: a
- * freshly reflected asset waits `dueDays` before it is picked again.
+ * 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.
  */
 function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, persist) {
     if (args.scope.mode === "ref" || !args.resolvedPlan.processes.proactiveMaintenance.enabled) {
@@ -856,7 +861,8 @@ 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.
+ * 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;

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

@@ -11,8 +11,8 @@ export const DEFAULT_MAX_PER_RUN = 25;
 /** Size floor for the cost term, so tiny files don't divide by ~0. */
 const SIZE_FLOOR_BYTES = 200;
 /**
- * The due gate, shared by selection and the post-lock re-filter: never touched,
- * or last touched more than `dueDays` ago. It doubles as the rotation cooldown.
+ * The due gate: never touched, or last touched more than `dueDays` ago. It
+ * doubles as the rotation cooldown.
  */
 function staleness(ref, lastReflectTs, lastDistillTs, dueDays, now) {
     const lastTouchMs = Math.max(0, Date.parse(lastReflectTs.get(ref) ?? "") || 0, Date.parse(lastDistillTs.get(ref) ?? "") || 0);
@@ -64,10 +64,3 @@ export function selectProactiveMaintenanceRefs(params) {
         scored,
     };
 }
-/**
- * Re-apply the due gate under the run lock with fresh timestamps, dropping refs
- * another run attempted after this one planned.
- */
-export function filterProactiveDue(selected, lastReflectTs, lastDistillTs, dueDays, now) {
-    return selected.filter((c) => staleness(c.ref, lastReflectTs, lastDistillTs, dueDays, now).due);
-}

package/dist/commands/improve/reflect.js

@@ -979,8 +979,9 @@ async function finalizeReflectProposal(args) {
         }, options.eventsCtx);
         return reflectFailure(run, result, "quality_rejected", message, false);
     };
+    let verdict;
     if (judged) {
-        const verdict = await runReflectQualityJudge(run.config, payload.content, assetContent ?? "", feedback, options.chat, {
+        verdict = await runReflectQualityJudge(run.config, payload.content, assetContent ?? "", feedback, options.chat, {
             runnerSelectionFrozen: true,
             ...(judge.runner ? { llmRunner: judge.runner } : {}),
             ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),
@@ -1045,7 +1046,7 @@ async function finalizeReflectProposal(args) {
                 ...(sanitized.sizeGuardRatio ? { measured: Math.round(sanitized.sizeGuardRatio.ratio * 100) } : {}),
             },
         }
-        : { judged });
+        : { judged: verdict });
     appendEvent({
         eventType: "reflect_completed",
         ref: proposal.ref,