akm-cli 0.9.20 → 0.9.21

package/CHANGELOG.md

@@ -4,7 +4,91 @@ 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.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,

package/dist/commands/improve/stage.js

@@ -120,29 +120,31 @@ export function rejectedProposalContext(stash, ref, ctx, eventsCtx) {
 }
 // ── Mint ─────────────────────────────────────────────────────────────────────
 /**
- * Create a stage's proposal. `judged` stamps a `staged` gate decision with the
- * judged content's hash (the triage drain accepts it while the content still
- * matches); `review` leaves it `deferred` for a human (`review_needed` in the
- * improve ledger).
+ * Create a stage's proposal. `judged` (the passing verdict) stamps a `staged`
+ * gate decision with the judged content's hash and the judge's scores and reason
+ * (the triage drain accepts it while the content still matches); `review`
+ * leaves it `deferred` for a human (`review_needed` in the improve ledger).
  */
 export function mintProposal(stash, proposalsCtx, input, verdict = {}) {
     const proposal = createProposal(stash, input, proposalsCtx);
     if (verdict.review) {
         return recordGateDecision(stash, proposal.id, { outcome: "deferred", ...verdict.review }, proposalsCtx) ?? proposal;
     }
-    return verdict.judged ? stageJudgedProposal(stash, proposal, proposalsCtx) : proposal;
+    return verdict.judged ? stageJudgedProposal(stash, proposal, verdict.judged, proposalsCtx) : proposal;
 }
 /**
  * Stamp a proposal the quality judge passed. Best-effort: a failed stamp only
  * means the triage drain judges it again.
  */
-export function stageJudgedProposal(stash, proposal, proposalsCtx) {
+export function stageJudgedProposal(stash, proposal, judged, proposalsCtx) {
     try {
         return (recordGateDecision(stash, proposal.id, {
             outcome: "staged",
             reason: "quality-judge",
             gate: "quality-gate",
             contentHash: proposalContentHash(proposal),
+            ...(judged?.criteria ? { scores: judged.criteria } : {}),
+            ...(judged ? { judgeReason: judged.reason } : {}),
         }, proposalsCtx) ?? proposal);
     }
     catch (error) {
@@ -196,17 +198,15 @@ function buildChangedRegion(sourceContent, candidateContent) {
     const added = candidate.slice(prefix, candidate.length - suffix).join("\n");
     return boundedDocument(`Removed or replaced:\n${removed || "(none)"}\n\nAdded or replacement:\n${added || "(none)"}`);
 }
-/** Judge prompt for an in-place revision (overlap with the source is expected). */
+/** Judge prompt for an in-place revision. */
 export function buildReflectJudgePrompt(candidateContent, sourceContent, feedback) {
     return [
         "You are evaluating a proposed revision to an existing akm asset.",
         "",
         "Score this revision on each criterion from 1 (poor) to 5 (excellent):",
-        "1. FEEDBACK ALIGNMENT: Does the revision address the supplied feedback or improve retrieval and clarity?",
-        "2. PRESERVATION: Does it retain the source's concrete facts, code, commands, examples, and structure without truncation?",
-        "3. QUALITY: Is the revision coherent, actionable, complete, and free of unsupported claims?",
-        "",
-        "Overlap with the source is expected and must not lower the score by itself; this is an in-place revision, not a new lesson.",
+        "1. NEED: Does the revision fix a concrete problem in the source? Concrete problems are: something the feedback reports as wrong or missing; a factual error; or broken, garbled, truncated or missing text, including frontmatter fields such as description or when_to_use. Score 4-5 when it fixes one, even a small one. Score 1-2 when the source was already correct and the revision only rewords, restates, reformats, or adds headings, an introduction or a table of contents.",
+        "2. PRESERVATION: Does it keep every concrete fact, identifier, command, path, number and example from the source, without truncation?",
+        "3. QUALITY: Is it coherent and accurate, with no claims, steps or details that the source or the feedback does not support?",
         "",
         "Feedback:",
         "```",
@@ -228,13 +228,13 @@ export function buildReflectJudgePrompt(candidateContent, sourceContent, feedbac
         buildChangedRegion(sourceContent, candidateContent),
         "```",
         "",
-        'Return ONLY valid JSON, no prose: {"scores": {"feedbackAlignment": <1-5 integer>, "preservation": <1-5 integer>, "quality": <1-5 integer>}, "reason": "<one sentence>"}',
+        'Return ONLY valid JSON, no prose: {"scores": {"need": <1-5 integer>, "preservation": <1-5 integer>, "quality": <1-5 integer>}, "reason": "<one sentence>"}',
     ].join("\n");
 }
 /**
  * `grounding` is scored with the other lesson criteria but left out of their
  * mean: a lesson about a different subject than its source reads as novel and
- * non-redundant, so the mean would pass it (or, in the review band, mint it as
+ * non-redundant, so they would pass it (or, in the review band, mint it as
  * a pending proposal). The rubric reserves 1-2 for a different subject. A score
  * of {@link UNGROUNDED_MAX_SCORE} or less is a rejection whatever the mean says
  * (#999). A higher score up to {@link BORDERLINE_GROUNDING_MAX_SCORE} is only
@@ -250,12 +250,12 @@ const GROUNDING_CRITERION = "grounding";
 const UNGROUNDED_MAX_SCORE = 1;
 const BORDERLINE_GROUNDING_MAX_SCORE = 2;
 const LESSON_JUDGE_CRITERIA = ["novelty", "nonRedundancy", GROUNDING_CRITERION];
-const REFLECT_JUDGE_CRITERIA = ["feedbackAlignment", "preservation", "quality"];
+const REFLECT_JUDGE_CRITERIA = ["need", "preservation", "quality"];
 /**
  * Read a judge response: the per-criterion shape (averaged here, `grounding`
- * aside) or the older `{"score"}` shape. Only the expected criteria are read;
- * any missing or out-of-range (1..5) value is a parse failure, extra keys are
- * ignored.
+ * aside; `lowest` is the lowest score in that mean) or the older `{"score"}`
+ * shape. Only the expected criteria are read; any missing or out-of-range
+ * (1..5) value is a parse failure, extra keys are ignored.
  */
 function parseJudgeResponse(raw, keys) {
     const parsed = parseEmbeddedJsonResponse(raw);
@@ -277,9 +277,14 @@ function parseJudgeResponse(raw, keys) {
         const averaged = Object.entries(criteria)
             .filter(([key]) => key !== GROUNDING_CRITERION)
             .map(([, value]) => value);
-        return { score: averaged.reduce((a, b) => a + b, 0) / averaged.length, reason, criteria };
+        return {
+            score: averaged.reduce((a, b) => a + b, 0) / averaged.length,
+            lowest: Math.min(...averaged),
+            reason,
+            criteria,
+        };
     }
-    return inRange(parsed.score) ? { score: parsed.score, reason } : undefined;
+    return inRange(parsed.score) ? { score: parsed.score, lowest: parsed.score, reason } : undefined;
 }
 function judgeResponseSchema(keys) {
     return {
@@ -299,14 +304,14 @@ function judgeResponseSchema(keys) {
 }
 /**
  * The quality judge. Fails closed: no runner, an unparseable verdict or a
- * provider failure never passes content. Bands: >= 3.5 pass, 2.5-3.5 review,
- * < 2.5 reject; a `grounding` score of {@link UNGROUNDED_MAX_SCORE} or less
- * rejects whatever the mean is, and one of {@link BORDERLINE_GROUNDING_MAX_SCORE}
- * routes a lesson the mean would pass to review (a mean that rejects stays a
- * rejection). Temperature is set to 0, which reduces run-to-run variation but
- * does not remove it: on some servers (llama.cpp batching, for one) the same
- * request can score a point apart, so the routing rules are chosen with that
- * margin in mind.
+ * provider failure never passes content. Bands: every criterion in the mean
+ * >= 4 passes, otherwise a mean >= 2.5 is review and a lower one reject; a
+ * `grounding` score of {@link UNGROUNDED_MAX_SCORE} or less rejects whatever
+ * the mean is, and one of {@link BORDERLINE_GROUNDING_MAX_SCORE} routes a lesson
+ * that would pass to review (a mean that rejects stays a rejection).
+ * Temperature is set to 0, which reduces run-to-run variation but does not
+ * remove it: on some servers (llama.cpp batching, for one) the same request can
+ * score a point apart, so the routing rules are chosen with that margin in mind.
  */
 async function runQualityJudge(feature, config, prompt, keys, chat, options) {
     const resolved = !options.runnerSelectionFrozen && !options.llmRunner
@@ -338,7 +343,7 @@ async function runQualityJudge(feature, config, prompt, keys, chat, options) {
     const parsed = parseJudgeResponse(outcome.raw, keys);
     if (!parsed)
         return { pass: false, score: -1, reason: "judge parse failed — routed to review", reviewNeeded: true };
-    const { score, reason, criteria } = parsed;
+    const { score, lowest, reason, criteria } = parsed;
     const grounding = criteria?.[GROUNDING_CRITERION];
     if (criteria && grounding !== undefined && grounding <= UNGROUNDED_MAX_SCORE) {
         return {
@@ -348,8 +353,8 @@ async function runQualityJudge(feature, config, prompt, keys, chat, options) {
             criteria,
         };
     }
-    const verdict = score >= 3.5 ? { pass: true } : score >= 2.5 ? { pass: false, reviewNeeded: true } : { pass: false };
-    // Borderline grounding is a person's call even when the mean would pass; a mean that rejects stays rejected.
+    const verdict = lowest >= 4 ? { pass: true } : score >= 2.5 ? { pass: false, reviewNeeded: true } : { pass: false };
+    // Borderline grounding is a person's call even when the lesson would pass; a mean that rejects stays rejected.
     if (criteria &&
         grounding !== undefined &&
         grounding <= BORDERLINE_GROUNDING_MAX_SCORE &&

package/dist/commands/proposal/repository.js

@@ -28,7 +28,7 @@ import { canonicalBundleIdForTarget, resolveBundleWriteTarget } from "../../core
 import { getStateDbPath, withImmediateTransaction, withStateDb } from "../../core/state-db.js";
 import { warn } from "../../core/warn.js";
 import { recordWrittenPath } from "../../core/write-provenance.js";
-import { assertAkmAssetWrite, commitWriteTargetBoundary, prepareWriteTargetForMutation, resolveWriteTarget, } from "../../core/write-source.js";
+import { assertAkmAssetWrite, commitAcceptedPaths, commitWriteTargetBoundary, prepareWriteTargetForMutation, resolveWriteTarget, } from "../../core/write-source.js";
 import { withAssetMutationLease } from "../../indexer/index-writer-lock.js";
 import { indexWrittenAssets } from "../../indexer/index-written-assets.js";
 import { deriveInstallations } from "../../indexer/installations.js";
@@ -708,6 +708,9 @@ function persistProposalDecision(stashDir, proposal, decision, ctx) {
                 ...(decision.gateDecision
                     ? {
                         gateDecision: {
+                            // The drain's verdict replaces the quality judge's stamp; the judge's evidence stays on the row.
+                            ...(current.gateDecision?.scores ? { scores: current.gateDecision.scores } : {}),
+                            ...(current.gateDecision?.judgeReason ? { judgeReason: current.gateDecision.judgeReason } : {}),
                             ...decision.gateDecision,
                             decidedAt: decision.gateDecision.decidedAt ?? decision.decidedAt,
                         },
@@ -1040,6 +1043,10 @@ function requireAcceptedTarget(proposal) {
     }
     return proposal.acceptedTarget;
 }
+/** An accept's commit subject: the generator, the proposal id's first 8 characters and the asset ref. */
+function acceptCommitMessage(proposal) {
+    return `akm accept: ${proposal.source} ${proposal.id.slice(0, 8)} ${proposal.ref}`;
+}
 /**
  * O1 (alpha.9): an accepted consolidate PROMOTION retires its source memory
  * (and its `.derived` twin), so promotion no longer leaves a memory/
@@ -1059,7 +1066,7 @@ function requireAcceptedTarget(proposal) {
  * existed carries no hash at all, so it is treated the same way: never
  * archived, not verified against a hash that was never recorded.
  */
-function retirePromotionSource(mutationTarget, accepted) {
+function retirePromotionSource(mutationTarget, accepted, paths) {
     if (!accepted.promotionSource)
         return;
     try {
@@ -1086,17 +1093,12 @@ function retirePromotionSource(mutationTarget, accepted) {
             successorRefs: [accepted.ref],
         };
         const record = archiveCleanupCandidate(mutationTarget.source.path, candidate, sourcePath);
-        const paths = [
-            sourcePath,
-            path.join(mutationTarget.source.path, record.archivedPath),
-            path.join(mutationTarget.source.path, record.auditPath),
-        ];
+        paths.push(sourcePath, path.join(mutationTarget.source.path, record.archivedPath), path.join(mutationTarget.source.path, record.auditPath));
         const twin = derivedTwinPath(sourcePath, sourceRef.type);
         if (twin) {
             const twinRecord = archiveCleanupCandidate(mutationTarget.source.path, candidate, twin);
             paths.push(twin, path.join(mutationTarget.source.path, twinRecord.archivedPath), path.join(mutationTarget.source.path, twinRecord.auditPath));
         }
-        commitWriteTargetBoundary(mutationTarget, `Retire promoted source ${accepted.promotionSource}`, { paths });
     }
     catch (error) {
         warn(`[proposal] O1: failed to retire promotion source ${accepted.promotionSource} for ${accepted.id}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1133,7 +1135,6 @@ async function promoteProposalWithLease(stashDir, config, id, options, ctx) {
     const decidedAt = nowIso(ctx);
     const content = preflight.stampedContent.endsWith("\n") ? preflight.stampedContent : `${preflight.stampedContent}\n`;
     writeProposalAssetFile(assetPath, content);
-    commitWriteTargetBoundary(mutationTarget, `Update ${proposalForMutation.ref}`, { paths: [assetPath] });
     const accepted = persistProposalDecision(stashDir, proposalForMutation, {
         operation: "accept",
         target: mutationTarget,
@@ -1146,8 +1147,10 @@ async function promoteProposalWithLease(stashDir, config, id, options, ctx) {
         decidedAt,
     }, ctx);
     await indexWrittenProposalAsset(mutationTarget, assetPath);
+    const paths = [assetPath];
     if (accepted.status === "accepted" && accepted.source === "consolidate")
-        retirePromotionSource(mutationTarget, accepted);
+        retirePromotionSource(mutationTarget, accepted, paths);
+    commitAcceptedPaths(mutationTarget, acceptCommitMessage(accepted), paths);
     return { proposal: accepted, assetPath, ref: accepted.ref };
 }
 /**
@@ -1406,7 +1409,7 @@ async function retireProposalWithLease(stashDir, config, proposal, options, ctx)
         paths.push(twinPath, path.join(mutationTarget.source.path, twinRecord.archivedPath), path.join(mutationTarget.source.path, twinRecord.auditPath));
     }
     if (paths.length > 0)
-        commitWriteTargetBoundary(mutationTarget, `Retire ${proposal.ref}`, { paths });
+        commitAcceptedPaths(mutationTarget, acceptCommitMessage(proposal), paths);
     if (archiveDirs.length === 0) {
         // Recorded intent, but neither file is at its original location NOR
         // archived under this proposal's id: something else removed the target

package/dist/commands/remember.js

@@ -101,7 +101,9 @@ export function readMemoryContent(contentArg) {
  * Split `text` into sentence-shaped chunks on `.`/`!`/`?`, swallowing any
  * immediately-trailing closing quotes/brackets/repeated terminators into the
  * same sentence (so `Alice said, "hi there."` ends the sentence at the
- * closing quote, not the period).
+ * closing quote, not the period). A terminator ends a sentence only when
+ * whitespace or the end of the text follows, so `192.168.0.203`, `0.9.12`,
+ * `example.com` and `notes.md` stay whole.
  *
  * Ported from akm-eval's memory backend (`splitIntoSentences` /
  * `firstSentencesCapped` in akm-eval/src/memory/backends/akm.ts), which
@@ -119,6 +121,10 @@ function splitIntoSentences(text) {
             let end = i + 1;
             while (end < text.length && /["'”’)\]!?.]/.test(text.charAt(end)))
                 end += 1;
+            if (end < text.length && !/\s/.test(text.charAt(end))) {
+                i = end;
+                continue;
+            }
             sentences.push(text.slice(start, end));
             while (end < text.length && /\s/.test(text.charAt(end)))
                 end += 1;

package/dist/core/improve-result.js

@@ -49,6 +49,10 @@ const COMMON_FIELDS = [
     "reflectCooldownActions",
     "reflectSkippedActions",
     "reflectGuardRejectedActions",
+    // No longer written (nothing has set it since the confidence gate was
+    // deleted), but kept in the allow-list so `decodeImproveResult` still reads
+    // the improve_runs rows an older release wrote with it, its value ignored —
+    // AGENTS.md "Reading persisted data".
     "gateAutoAcceptedCount",
     "gateAutoAcceptFailedCount",
     "triage",
@@ -494,7 +498,6 @@ function validateCommon(value) {
         "reflectCooldownActions",
         "reflectSkippedActions",
         "reflectGuardRejectedActions",
-        "gateAutoAcceptedCount",
         "gateAutoAcceptFailedCount",
     ]) {
         if (value[field] !== undefined && typeof value[field] !== "number")

package/dist/core/write-source.js

@@ -20,7 +20,9 @@
  * Nothing commits per asset (issue #507). Callers write and delete through
  * {@link writeAssetToSource} / {@link deleteAssetFromSource}, then fire
  * {@link commitWriteTargetBoundary} once — or wrap a custom mutation in
- * {@link withWriteTargetMutation}, which does both under the asset lease.
+ * {@link withWriteTargetMutation}, which does both under the asset lease. An
+ * accepted proposal commits its own paths ({@link commitAcceptedPaths}), on a
+ * filesystem stash that is a git repository too.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -394,11 +396,12 @@ export function withWriteTargetMutation(target, paths, options, mutate) {
  * Commit a git target's recorded paths plus `options.paths` (absolute or
  * repository-relative) as one commit, and push it with `--force-with-lease`
  * when the target is writable, has an upstream, and `push !== false`. A no-op
- * for filesystem targets. Ignored paths stay local: they are dropped from the
- * commit with a warning rather than failing a write that already landed.
+ * for filesystem targets unless `filesystem` is set. Ignored paths stay local:
+ * they are dropped from the commit with a warning rather than failing a write
+ * that already landed.
  */
 export function commitWriteTargetBoundary(target, message, options) {
-    if (target.source.kind !== "git")
+    if (target.source.kind !== "git" && !options?.filesystem)
         return;
     const repoDir = repoDirFor(target.source);
     const recorded = pendingGitPaths.get(repoDir) ?? new Set();
@@ -417,11 +420,13 @@ export function commitWriteTargetBoundary(target, message, options) {
     if (committable.length === 0)
         return;
     try {
-        saveGitStash(undefined, message, resolveWritable(target.config), {
+        const saved = saveGitStash(undefined, message, resolveWritable(target.config), {
             repoDir,
             paths: committable,
             ...(options?.push === undefined ? {} : { push: options.push }),
         });
+        if (saved.reason)
+            warn(`warning: "${target.source.name}" ${saved.reason}`);
     }
     catch (error) {
         if (error instanceof GitStashPushError) {
@@ -432,3 +437,21 @@ export function commitWriteTargetBoundary(target, message, options) {
         throw error;
     }
 }
+/**
+ * Commit exactly the paths an accepted proposal wrote or removed, when the
+ * target is a git repository: a filesystem stash with a `.git` too, which the
+ * boundary commit skips, locally (the end-of-run sync pushes). A failed commit
+ * only warns, since the accept already landed.
+ */
+export function commitAcceptedPaths(target, message, paths) {
+    try {
+        commitWriteTargetBoundary(target, message, {
+            paths,
+            filesystem: true,
+            ...(target.source.kind === "git" ? {} : { push: false }),
+        });
+    }
+    catch (error) {
+        warn(`warning: could not commit the accept (${message}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/scripts/akm-migrate-node.js

@@ -31339,14 +31339,14 @@ var consolidate_default = {
 };
 // src/assets/improve-strategies/default.json
 var default_default = {
-  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 } },
@@ -31358,7 +31358,7 @@ var default_default = {
 };
 // src/assets/improve-strategies/proactive-maintenance.json
 var proactive_maintenance_default = {
-  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,
@@ -31441,7 +31441,7 @@ var thorough_default = {
     distill: {
       enabled: true,
       allowedTypes: ["memory"],
-      requirePlannedRefs: true
+      requirePlannedRefs: false
     },
     consolidate: {
       enabled: true,

package/dist/scripts/akm-migrate.js

@@ -30667,14 +30667,14 @@ var consolidate_default = {
 };
 // src/assets/improve-strategies/default.json
 var default_default = {
-  description: "Standard improve pass \u2014 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 \u2014 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 } },
@@ -30686,7 +30686,7 @@ var default_default = {
 };
 // src/assets/improve-strategies/proactive-maintenance.json
 var proactive_maintenance_default = {
-  description: "Opt-in proactive-maintenance pass \u2014 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 \u2014 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,
@@ -30769,7 +30769,7 @@ var thorough_default = {
     distill: {
       enabled: true,
       allowedTypes: ["memory"],
-      requirePlannedRefs: true
+      requirePlannedRefs: false
     },
     consolidate: {
       enabled: true,

package/dist/sources/providers/git-stash.js

@@ -167,7 +167,9 @@ export function resolveWritableOverride(config) {
  *   - Not a git repo → skipped (no-op)
  *   - Git repo, no remote → commit only
  *   - Git repo, has remote, but stash is not writable → commit only
- *   - Git repo, has remote, stash is writable → commit + push
+ *   - Git repo, has remote, stash is writable → commit + push, unless the
+ *     branch has no upstream or is behind or diverged from it: then commit
+ *     only, and `reason` says why
  *
  * When `name` is omitted the primary stash directory is used.
  * When `message` is omitted a timestamp is used.
@@ -288,7 +290,9 @@ export function saveGitStash(name, message, writableOverride, options) {
         throw new Error(`git remote failed: ${remoteResult.stderr?.trim() || "unknown error"}`);
     }
     const hasRemote = remoteResult.stdout.trim().length > 0;
-    const pushTarget = hasRemote && writable && allowPush ? readActualUpstream(repoDir, baseHead) : undefined;
+    // A branch that cannot be pushed still gets its commit: only the push is skipped, and the result says why.
+    const upstream = hasRemote && writable && allowPush ? readActualUpstream(repoDir, baseHead) : undefined;
+    const pushTarget = typeof upstream === "object" ? upstream : undefined;
     const exactCommit = createExactPathCommit(repoDir, {
         baseHead,
         commitMessage,
@@ -304,6 +308,7 @@ export function saveGitStash(name, message, writableOverride, options) {
             committed: true,
             pushed: false,
             skipped: false,
+            ...(typeof upstream === "string" ? { reason: `not pushed: ${upstream}` } : {}),
             output: `commit ${exactCommit}`,
             commit: exactCommit,
         };
@@ -387,20 +392,22 @@ function readBranchRef(repoDir) {
     }
     return result.stdout.trim();
 }
+/**
+ * Where a commit on top of `baseHead` can be pushed: the branch's upstream, as
+ * long as it is an ancestor of `baseHead` (ahead is fine, the push fast-forwards
+ * it). Otherwise why not: no upstream, or behind or diverged from it.
+ */
 function readActualUpstream(repoDir, baseHead) {
-    if (!baseHead)
-        throw new UsageError(`Writable Git target at ${repoDir} has no commit to publish.`);
     const branchRef = readBranchRef(repoDir);
     const branch = branchRef.replace(/^refs\/heads\//, "");
     const remote = runGit(["-C", repoDir, "config", "--get", `branch.${branch}.remote`]);
     const merge = runGit(["-C", repoDir, "config", "--get", `branch.${branch}.merge`]);
     const upstream = runGit(["-C", repoDir, "rev-parse", "--verify", "@{u}"]);
-    if (remote.status !== 0 || merge.status !== 0 || upstream.status !== 0) {
-        throw new UsageError(`Writable Git target at ${repoDir} has no configured upstream branch.`);
-    }
+    if (remote.status !== 0 || merge.status !== 0 || upstream.status !== 0)
+        return "no upstream branch is configured";
     const upstreamHead = upstream.stdout.trim();
-    if (!upstreamHead || upstreamHead !== baseHead) {
-        throw new UsageError(`Writable Git target at ${repoDir} is not synchronized with its actual upstream.`);
+    if (!baseHead || runGit(["-C", repoDir, "merge-base", "--is-ancestor", upstreamHead, baseHead]).status !== 0) {
+        return "the branch is behind its upstream or has diverged from it";
     }
     return { remote: remote.stdout.trim(), mergeRef: merge.stdout.trim(), upstreamHead };
 }

package/dist/storage/repositories/improve-runs-repository.js

@@ -16,7 +16,6 @@ export function computeImproveRunMetrics(result) {
     let acceptedCount = 0;
     let rejectedCount = 0;
     let skippedCount = 0;
-    let autoAcceptedCount = 0;
     let errorCount = 0;
     for (const action of actions) {
         // Bucketing delegated to the shared classifyImproveAction so this aggregate
@@ -42,8 +41,7 @@ export function computeImproveRunMetrics(result) {
                 break;
         }
     }
-    // Add gate-promoted count from the unified PostPhaseAutoAcceptGate (all phases).
-    autoAcceptedCount += result.gateAutoAcceptedCount ?? 0;
+    const autoAcceptedCount = result.triage?.promoted ?? 0;
     // C1 (13-bus-factor): distill-skipped rows are folded into the bounded
     // `distillSkipped` aggregate and no longer live in `actions`. Add the
     // aggregate total to the skipped + total-actions counters so metrics_json

package/docs/reference/cli.md

@@ -1395,6 +1395,8 @@ value also looks like a format token.
 | Git repo, no remote | Stage and commit only |
 | Git repo, has remote, not writable | Stage and commit only |
 | Git repo, has remote, `writable: true` | Stage, commit, and push |
+| Writable with a remote, but no upstream branch, or behind or diverged from it | Stage and commit; the push is skipped and `reason` says `not pushed: ...` |
+| Writable with a remote and ahead of its upstream | Stage, commit, and push, unpushed commits included |
 | Any writable repo with `--no-push` | Stage and commit only (push suppressed) |
 
 **Primary bundle writable config:**
@@ -1592,9 +1594,12 @@ preserves it byte-for-byte.
 
 ### feedback
 
-Record positive or negative feedback for any indexed bundle asset. Feedback
-influences utility scores during the next index run, causing highly-rated
-assets to rank higher in search results over time.
+Record positive or negative feedback for any indexed bundle asset.
+`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. Both signals update the asset's
+utility score right away, so highly-rated assets rank higher in search results.
 
 ```sh
 akm feedback scripts/deploy.sh --positive
@@ -1608,9 +1613,9 @@ akm feedback skills/code-review --negative --reason "flaky" --tag slice:train --
 
 | Flag | Description |
 | --- | --- |
-| `--positive` | Record positive feedback (use when an asset was helpful) |
-| `--negative` | Record negative feedback (use when an asset was not useful) |
-| `--reason` | What was wrong with (or right about) the asset's content; not for `akm` command errors. Attached to the feedback event (required for negative feedback by default) |
+| `--positive` | Record that an asset helped: it raises its ranking and does not trigger a rewrite |
+| `--negative` | Flag the asset for review: the next improve run proposes a fix based on `--reason`, so be specific |
+| `--reason` | What is wrong with the asset's content and what should change; not for `akm` command errors. Attached to the feedback event and read by the next improve run's fix proposal (required for negative feedback by default) |
 | `--failure-mode` | Structured failure-mode taxonomy for negative feedback: `incorrect`, `outdated`, `dangerous`, `incomplete`, `redundant`. Stored alongside `--reason` in event metadata for the distill pipeline. |
 | `--tag` | Tag to attach to the feedback (repeatable, e.g. `--tag slice:train --tag team:platform`) |
 | `--applied-to <ref>` | Credit a `lessons/<name>` lesson that helped resolve this task. When combined with `--positive`, appends this feedback ref to the target lesson's `lessonStrength[]` frontmatter array (dedup, idempotent). A non-lesson target, or a missing `--positive`, produces a warning rather than silently doing nothing. |
@@ -1618,6 +1623,11 @@ akm feedback skills/code-review --negative --reason "flaky" --tag slice:train --
 Specify exactly one of `--positive` or `--negative`. The ref must already be
 present in the current local index.
 
+Only negative feedback with a specific reason gets an asset reviewed and fixed:
+`akm improve` plans a rewrite (reflect) only for an asset with fresh negative
+feedback, or for an explicit ref. A positive or note-only signal never plans
+one, and improve no longer rewrites assets on a proactive cadence.
+
 The `--applied-to` flag records the lesson-strength signal: each credit is
 kept in the lesson's `lessonStrength[]` frontmatter. Search ranking does not
 use it.
@@ -2432,7 +2442,7 @@ akm improve report --since 7d          # ...aggregated over every real run start
 | `--bundle` | Select the bundle the run improves and writes to (default: `defaultWriteTarget`, else the working bundle); only that bundle's assets are planned. When the ref scope is bundle-qualified, it must name the same bundle |
 | `--limit <n>` | Cap the refs the run processes, highest salience first (refs routed to distill only come last). Overrides the strategy's `processes.reflect.limit` and `limit` |
 | `--timeout-ms <ms>` | Wall-clock budget for the run (default: `7200000` = 2 hours) |
-| `--require-feedback-signal` | Only process assets with recent feedback signals: turns the fallback lanes (high salience, proactive maintenance) off for the run |
+| `--require-feedback-signal` | Turn the fallback lanes (high salience, proactive maintenance) off for the run: they only select and score assets, and a rewrite needs negative feedback |
 | `--strategy <name>` | Override the active improve strategy (a built-in or entry under `improve.strategies`) |
 | `--json-to-stdout` | Also emit the full persisted JSON result on stdout for a live run. Without this flag, stdout stays empty. Dry-runs always emit their result and are never persisted. |
 | `--skip-if-locked` | If another improve run already holds the lock, skip gracefully (exit 0) instead of failing with "already running" (exit 75, `TransientError`, code `IMPROVE_LOCK_HELD` — field follow-up to #948: two legitimate `improve` invocations colliding on this lock is ordinary, retryable contention, not a broken config file). Use for high-frequency scheduled runs so they don't pile up failures while a longer run is in progress. |
@@ -2481,7 +2491,8 @@ vector (semantic search off, or the memory not indexed yet) that check does
 nothing and the exact slug and whole-body checks still apply.
 
 No built-in strategy turns the improve-stage extract process on, and only
-`proactive-maintenance` turns proactive maintenance on. Use that strategy or
+`proactive-maintenance` turns proactive maintenance on, which selects and
+scores due assets but plans no rewrite. Use that strategy or
 set the selected strategy's process `enabled: true` to opt in. The stage toggle does not disable a direct
 `akm proposal extract --type <harness>` or `akm proposal extract --auto`
 invocation.
@@ -2502,16 +2513,22 @@ the drain engine. Reflect still emits a `confidence` score (0..1) in its JSON
 response schema; it is recorded on the proposal for triage and ranking, but no
 threshold auto-accepts anything.
 
-Selection picks the refs with feedback (a signal or a note, in the last 30
-days) newer than the stage's last ledger attempt. Two fallback lanes add refs
-with no such feedback: high salience (content-scored refs at or above
+Selection plans a reflect (a proposed rewrite) only for refs with negative
+feedback in the last 30 days newer than the stage's last ledger attempt, or for
+an explicit ref scope. A positive or note-only signal never plans one, so
+improve does not rewrite an asset from a positive signal. Distill keeps its own
+trigger: a memory with feedback of any kind (a signal or a note) in that window,
+newer than distill's last attempt. Two fallback lanes pick refs with no such
+feedback: high salience (content-scored refs at or above
 `improve.salience.salienceThreshold`, default `0.75`, that were never reflected,
 capped at 10% of the limit, at least one ref) and, in a strategy that enables
-`proactiveMaintenance`, refs due for a revisit. Both pick only refs in the
+`proactiveMaintenance`, refs due for a revisit. They only select and score refs
+(salience and outcome) and plan nothing, so improve does not rewrite on a
+proactive cadence; they pick only refs in the
 [retrieval scope](https://github.com/itlackey/akm/blob/main/docs/architecture/improvement.md#retrieval-scope): returned by
 `search`, `curate` or `show`, or named by feedback, in the last 90 days, or new
-material no improve stage has processed. The picks are ranked by salience and
-cut to the limit; an explicit ref scope bypasses every gate. Use
+material no improve stage has processed. The planned refs are ranked by salience
+and cut to the limit; an explicit ref scope bypasses every gate. Use
 `--require-feedback-signal` to turn the fallback lanes off for the run.
 
 When the active strategy enables a process (or the triage judgment engine)
@@ -2818,6 +2835,14 @@ Bulk-accept all pending proposals from one generator with `--generator <name>`
 (e.g. `reflect`, `distill`) and no positional id. Bulk accept requires
 `-y`/`--yes` in non-interactive shells.
 
+When the destination bundle is a git repository (a `.git` directory, whatever
+its source kind), each accept is committed as it happens, with exactly the paths
+it wrote or removed and the subject `akm accept: <generator> <proposal-id-8>
+<ref>`. A retirement's archived copy and tombstone, and the source memory a
+consolidate promotion retires, are part of the same commit. The commit is local:
+`akm sync`, or the end-of-run sync of `akm improve`, pushes it. A commit that
+fails warns and the accept stands.
+
 #### proposal reject
 
 Reject a proposal and archive the reason. Accepts a full UUID, an 8-character
@@ -3039,7 +3064,8 @@ akm proposal drain --strategy default --promote -y  # Read the triage block from
 
 `akm feedback` accepts an optional `--reason <text>` flag whose value is
 forwarded into feedback metadata and consumed by improve/distill proposal
-prompts. Negative feedback requires a reason by default.
+prompts. Negative feedback requires a reason by default: the next improve run
+proposes a fix from it, so say what is wrong and what should change.
 
 Write the reason about the asset's content. Reflect treats it as an unverified
 report to investigate, not a fact to insert, and is told to leave the section

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.20",
+  "version": "0.9.21",
   "type": "module",
   "description": "akm (Agent Knowledge Manager) — a portable, local-first capability library for AI agents. Discover, load, share, and improve reusable skills, scripts, workflows, and knowledge across any shell-capable coding agent, including Claude Code, OpenCode, and Cursor.",
   "keywords": [