akm-cli 0.9.20 → 0.9.22

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/proposal/validators/proposals.js

@@ -25,7 +25,9 @@ export function validateProposal(proposal) {
  * Normalize line endings and complete a truncated frontmatter `description`
  * (`repairTruncatedDescription`, with the body as context). Nothing else: an
  * earlier repair that deleted body lines gutted any asset documenting
- * frontmatter. Callers re-validate the result.
+ * frontmatter. Only a single-line description is repaired: one YAML wrapped
+ * over indented lines (`yaml.stringify` does that past ~80 columns) has a
+ * first line that merely looks truncated. Callers re-validate the result.
  */
 export function repairProposalContent(content) {
     if (typeof content !== "string" || content.trim() === "")
@@ -34,5 +36,9 @@ export function repairProposalContent(content) {
     const { fmText, body } = splitFrontmatter(repaired);
     if (fmText === null)
         return repaired;
-    return repaired.replace(/^(description:\s*)(.*?)(\r?\n)/m, (_match, prefix, rawDesc, nl) => `${prefix}${repairTruncatedDescription(rawDesc.trim(), body)}${nl}`);
+    if (/^description:.*\n[ \t]/m.test(fmText))
+        return repaired;
+    // The frontmatter block only: a body line starting with `description:` is not the description.
+    const frontmatter = repaired.slice(0, repaired.length - body.length);
+    return (frontmatter.replace(/^(description:[ \t]*)(.*?)(\r?\n)/m, (_match, prefix, rawDesc, nl) => `${prefix}${repairTruncatedDescription(rawDesc.trim(), body)}${nl}`) + body);
 }

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