akm-cli 0.9.16-alpha.2 → 0.9.17-alpha.1

package/dist/commands/improve/distill/promote-memory.js

@@ -54,6 +54,39 @@ export async function planMemoryKnowledgePromotion(ctx) {
     }
     return { promotion: promotion, existingKnowledgeContent };
 }
+/**
+ * PRECHECK (tier3-0917): read-only classification of whether distill would
+ * promote this memory to knowledge — used by the improve loop's distill
+ * pre-generation proposal guard (`loop-stages.ts`) to pre-check the SAME ref
+ * {@link planMemoryKnowledgePromotion} will target at dispatch time
+ * (knowledgeRef when this resolves `true`, the derived lesson ref
+ * otherwise), rather than guessing which of the two a guard hit applies to.
+ * Delegates to {@link planMemoryKnowledgePromotion} itself so the
+ * classification can never drift from the real dispatch decision — no LLM
+ * call, no side effect. Every {@link PromoteMemoryContext} field this
+ * classification does not read (chat, fetchSimilarLessonsFn,
+ * existingRefVocabulary, …) is a safe placeholder here.
+ */
+export async function wouldPromoteMemoryToKnowledge(args) {
+    const plan = await planMemoryKnowledgePromotion({
+        targetKind: "auto",
+        inputRef: args.inputRef,
+        durableInputRef: args.durableInputRef,
+        assetContent: args.assetContent,
+        filteredEvents: args.feedbackEvents,
+        config: args.config,
+        stash: args.stash,
+        lookup: args.lookup,
+        fetchSimilarLessonsFn: () => Promise.resolve([]),
+        existingRefVocabulary: new Set(),
+        outcomeWeightEnabled: false,
+        eligMeta: {},
+        exclusionSetSize: 0,
+        filteredFeedbackCount: 0,
+        feedbackFullyFiltered: false,
+    });
+    return plan !== null;
+}
 /** Whether a classified promotion will actually call merge generation and/or the judge. */
 export function memoryKnowledgePromotionRequiresDispatch(ctx, plan) {
     const hasRunner = Boolean(ctx.llmRunner);
@@ -205,11 +238,16 @@ export async function promoteMemoryToKnowledge(ctx, planned) {
             ...(ctx.onNotices ? { onNotices: ctx.onNotices } : {}),
         });
         if (!judgeResult.pass) {
+            const proposalOpts = {
+                ...(ctx.proposalsCtx ? { proposalsCtx: ctx.proposalsCtx } : {}),
+                ...(ctx.sourceRun !== undefined ? { sourceRun: ctx.sourceRun } : {}),
+                ...(ctx.llmRunner?.connection.model ? { modelId: ctx.llmRunner.connection.model } : {}),
+            };
             if (judgeResult.reviewNeeded) {
                 // Uncertainty band (2.5–3.5): queue as review_needed instead of rejecting.
-                return writeQualityRejection(stash, inputRef, promotion.knowledgeRef, resolvedPromotionContent, judgeResult.score, judgeResult.reason, { reviewNeeded: true }, ctx.eligibilitySource, ctx.eventsCtx);
+                return writeQualityRejection(stash, inputRef, promotion.knowledgeRef, resolvedPromotionContent, judgeResult.score, judgeResult.reason, { reviewNeeded: true, ...(judgeResult.criteria ? { criteria: judgeResult.criteria } : {}) }, ctx.eligibilitySource, ctx.eventsCtx, proposalOpts);
             }
-            return writeQualityRejection(stash, inputRef, promotion.knowledgeRef, resolvedPromotionContent, judgeResult.score, judgeResult.reason, {}, ctx.eligibilitySource, ctx.eventsCtx);
+            return writeQualityRejection(stash, inputRef, promotion.knowledgeRef, resolvedPromotionContent, judgeResult.score, judgeResult.reason, judgeResult.criteria ? { criteria: judgeResult.criteria } : {}, ctx.eligibilitySource, ctx.eventsCtx, proposalOpts);
         }
         // Normalize 1-5 judge score to [0, 1]. Only a real passing verdict reaches
         // here (07 P0-2: the judge now fails CLOSED on no-LLM / timeout / parse

package/dist/commands/improve/distill/quality-gate.js

@@ -17,11 +17,14 @@ import { appendEvent } from "../../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
 import { getDistillRejectedDir } from "../../../core/paths.js";
 import { withStateDb } from "../../../core/state-db.js";
+import { warn } from "../../../core/warn.js";
 import { recordWrittenPath } from "../../../core/write-provenance.js";
 import { callStructured } from "../../../llm/structured-call.js";
+import { archiveProposal, isProposalSkipped, recordGateDecision, } from "../../proposal/repository.js";
 import { akmSearch } from "../../read/search.js";
 import { scoreEncodingSalience } from "../encoding-salience.js";
 import { resolveImproveLlmExecution } from "../execution.js";
+import { emitProposal } from "../proposal-envelope.js";
 import { computeSalience, upsertAssetSalience } from "../salience.js";
 // ── D-4 / #390: Top-3 similar lessons retrieval ──────────────────────────────
 /**
@@ -75,8 +78,7 @@ export function buildJudgePrompt(lessonContent, sourceContent, similarLessons) {
         "",
         "Score this lesson on each criterion from 1 (poor) to 5 (excellent):",
         "1. NOVELTY: Does the lesson add information not already present in the source asset?",
-        "2. ACTIONABILITY: Can an agent follow this lesson without additional context?",
-        "3. NON-REDUNDANCY: Is this lesson meaningfully different from what the source already says?",
+        "2. NON-REDUNDANCY: Is this lesson meaningfully different from what the source already says?",
         "",
         "Source asset content:",
         "```",
@@ -99,7 +101,7 @@ export function buildJudgePrompt(lessonContent, sourceContent, similarLessons) {
     lines.push(lessonContent.slice(0, 1000));
     lines.push("```");
     lines.push("");
-    lines.push('Return ONLY valid JSON, no prose: {"score": <average score 1-5 as float>, "reason": "<one sentence>"}');
+    lines.push('Return ONLY valid JSON, no prose: {"scores": {"novelty": <1-5 integer>, "nonRedundancy": <1-5 integer>}, "reason": "<one sentence>"}');
     return lines.join("\n");
 }
 function boundedDocument(content, maxChars = 6000) {
@@ -156,10 +158,89 @@ export function buildReflectJudgePrompt(candidateContent, sourceContent, feedbac
         buildChangedRegion(sourceContent, candidateContent),
         "```",
         "",
-        'Return ONLY valid JSON, no prose: {"score": <average score 1-5 as float>, "reason": "<one sentence>"}',
+        'Return ONLY valid JSON, no prose: {"scores": {"feedbackAlignment": <1-5 integer>, "preservation": <1-5 integer>, "quality": <1-5 integer>}, "reason": "<one sentence>"}',
     ].join("\n");
 }
-async function runQualityJudge(feature, config, prompt, chat, options = {}) {
+/**
+ * Criterion keys `buildJudgePrompt` asks the lesson judge to score.
+ * R16: ACTIONABILITY dropped (splinter measured AUC 0.46 against accept/reject
+ * outcomes — no signal — and averaging it pulled scores toward the review band).
+ */
+const LESSON_JUDGE_CRITERIA_KEYS = ["novelty", "nonRedundancy"];
+/** Criterion keys `buildReflectJudgePrompt` asks the reflect judge to score. */
+const REFLECT_JUDGE_CRITERIA_KEYS = ["feedbackAlignment", "preservation", "quality"];
+/**
+ * R16 / r2-2 / JUDGE2: parse the judge's JSON response, accepting either the
+ * current per-criterion shape (`{"scores": {...}, "reason"}`, averaged in
+ * code) or the old averaged-float shape (`{"score": 1-5, "reason"}`) a model
+ * may still return. `expectedCriteriaKeys` names the criteria this judge's
+ * prompt asked for; only those keys are read, validated, and averaged — a
+ * `scores` object missing any of them is a parse failure (a truncated or
+ * partial response can't auto-pass on whatever keys happened to arrive), and
+ * any OTHER key present (e.g. a model spelling a key differently, or echoing
+ * a criterion the prompt didn't ask for) is silently ignored rather than
+ * changing the score or failing the parse. Each expected criterion (or the
+ * bare score) must be a finite number in 1..5; anything else — an
+ * out-of-range or non-finite value, a non-string `reason` — is a parse
+ * failure so the caller routes to review exactly as before.
+ */
+function parseJudgeResponse(raw, expectedCriteriaKeys) {
+    const parsed = parseEmbeddedJsonResponse(raw);
+    if (!parsed || typeof parsed.reason !== "string")
+        return undefined;
+    const reason = parsed.reason;
+    if (parsed.scores !== undefined) {
+        if (typeof parsed.scores !== "object" || parsed.scores === null || Array.isArray(parsed.scores))
+            return undefined;
+        const scores = parsed.scores;
+        const criteria = {};
+        let sum = 0;
+        for (const key of expectedCriteriaKeys) {
+            const value = scores[key];
+            if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || value > 5)
+                return undefined;
+            criteria[key] = value;
+            sum += value;
+        }
+        const score = sum / expectedCriteriaKeys.length;
+        return { score, reason, criteria };
+    }
+    if (typeof parsed.score === "number" && Number.isFinite(parsed.score) && parsed.score >= 1 && parsed.score <= 5) {
+        return { score: parsed.score, reason };
+    }
+    return undefined;
+}
+/**
+ * JUDGE2: strict JSON Schema for a judge response, sent through the same
+ * `supportsJsonSchema`-gated `request.responseSchema` path
+ * `src/llm/graph-extract.ts` (`GRAPH_EXTRACTION_JSON_SCHEMA`) uses — a
+ * provider that doesn't opt in (`runner.connection.supportsJsonSchema`) sees
+ * no change. Built from `expectedCriteriaKeys` so each judge's schema matches
+ * exactly the criteria its own prompt asks for; `additionalProperties: false`
+ * at both levels means a model that spells a key differently is rejected by
+ * a schema-enforcing provider rather than silently producing a parse failure.
+ */
+function buildJudgeResponseSchema(expectedCriteriaKeys) {
+    const properties = {};
+    for (const key of expectedCriteriaKeys) {
+        properties[key] = { type: "integer", minimum: 1, maximum: 5 };
+    }
+    return {
+        type: "object",
+        required: ["scores", "reason"],
+        additionalProperties: false,
+        properties: {
+            scores: {
+                type: "object",
+                required: [...expectedCriteriaKeys],
+                additionalProperties: false,
+                properties,
+            },
+            reason: { type: "string" },
+        },
+    };
+}
+async function runQualityJudge(feature, config, prompt, expectedCriteriaKeys, chat, options = {}) {
     const resolvedDefault = !options.runnerSelectionFrozen && !options.llmRunner
         ? resolveImproveLlmExecution({ config, processName: `${feature}-judge` })
         : null;
@@ -183,6 +264,13 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
             ],
             request: {
                 enableThinking: false,
+                // R13: the judge must not inherit the generation runner's temperature
+                // (measured: 10/16 verdict flips at 0.3, 0/16 at 0). Pinned regardless
+                // of what `engines.<name>.temperature` the runner resolves.
+                temperature: 0,
+                // JUDGE2: bounds the response to exactly this judge's criteria on
+                // providers that opt into structured output; a no-op otherwise.
+                responseSchema: buildJudgeResponseSchema(expectedCriteriaKeys),
                 ...(Object.hasOwn(options, "timeoutMs") ? { timeoutMs: options.timeoutMs } : {}),
                 ...(options.signal ? { signal: options.signal } : {}),
                 ...(chat ? { chat } : {}),
@@ -193,26 +281,20 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
             fallback: "",
             ...(options.onNotices ? { onNotices: options.onNotices } : {}),
         });
-        const parsed = parseEmbeddedJsonResponse(raw);
-        if (!parsed ||
-            typeof parsed.score !== "number" ||
-            !Number.isFinite(parsed.score) ||
-            parsed.score < 1 ||
-            parsed.score > 5 ||
-            typeof parsed.reason !== "string") {
+        const parsed = parseJudgeResponse(raw, expectedCriteriaKeys);
+        if (!parsed) {
             return { pass: false, score: -1, reason: "judge parse failed — routed to review", reviewNeeded: true };
         }
         // D-5 / #388: Three-band system (MT-Bench arXiv:2306.05685 — ~±0.5 judge variance).
         //   >= 3.5: auto-queue as pending (pass: true)
         //   2.5–3.5: review-needed band — uncertain, escalate to human (reviewNeeded: true)
         //   < 2.5: auto-reject (pass: false)
-        const score = parsed.score;
-        const reason = parsed.reason ?? "";
+        const { score, reason, criteria } = parsed;
         if (score >= 3.5)
-            return { pass: true, score, reason };
+            return { pass: true, score, reason, ...(criteria ? { criteria } : {}) };
         if (score >= 2.5)
-            return { pass: false, score, reason, reviewNeeded: true };
-        return { pass: false, score, reason };
+            return { pass: false, score, reason, reviewNeeded: true, ...(criteria ? { criteria } : {}) };
+        return { pass: false, score, reason, ...(criteria ? { criteria } : {}) };
     }
     catch (error) {
         // Invalid symbolic credentials are configuration failures, not a negative
@@ -235,17 +317,37 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
  * stash. The rejection is `quality_rejected`, not `review_needed`.
  */
 export async function runLessonQualityJudge(config, lessonContent, sourceContent, chat, options = {}) {
-    return runQualityJudge("lesson_quality_gate", config, buildJudgePrompt(lessonContent, sourceContent, options.similarLessons), chat, options);
+    return runQualityJudge("lesson_quality_gate", config, buildJudgePrompt(lessonContent, sourceContent, options.similarLessons), LESSON_JUDGE_CRITERIA_KEYS, chat, options);
 }
 /** Judge an in-place reflect revision without applying new-lesson novelty criteria. */
 export async function runReflectQualityJudge(config, candidateContent, sourceContent, feedback, chat, options = {}) {
-    return runQualityJudge("proposal_quality_gate", config, buildReflectJudgePrompt(candidateContent, sourceContent, feedback), chat, options);
+    return runQualityJudge("proposal_quality_gate", config, buildReflectJudgePrompt(candidateContent, sourceContent, feedback), REFLECT_JUDGE_CRITERIA_KEYS, chat, options);
 }
 // ── Quality-rejection helper ─────────────────────────────────────────────────
 /**
  * Write a rejected lesson to `$STATE/improve/distill-rejected/<stash>/`
- * (itlackey/akm#890), append a `distill_invoked` quality-rejected event, and
- * return the `quality_rejected` envelope.
+ * (itlackey/akm#890), persist it as a real `proposals` row, append a
+ * `distill_invoked` quality-rejected event, and return the `quality_rejected`
+ * envelope.
+ *
+ * R10: the proposal row is minted through the same `createProposal`
+ * (`emitProposal`) path every other distill proposal takes, so `source:
+ * "distill"` fingerprint/backoff bookkeeping (proposal/repository.ts
+ * `checkFingerprintAndBackoff`) and the Reflexion "previously rejected"
+ * context (distill.ts's `buildDistillMessages`, reflect.ts's
+ * `readRejectedProposals`) can see it — before this, a quality rejection
+ * left only an event and a `$STATE`-side file nothing read, so the same ref
+ * was re-selected and re-rejected on every run. `review_needed` stays
+ * `pending` for a human to triage in the normal queue (matching what
+ * promote-memory.ts's comment always claimed) and is stamped with a
+ * `quality-gate` gate decision so the triage drain's `classifyPendingProposals`
+ * (proposal/drain.ts) leaves it pending instead of deferring it to the
+ * judgment tier, which could auto-accept it with no human in the loop;
+ * `quality_rejected` is minted pending, then immediately archived to
+ * `rejected` with the judge's reason.
+ * A fingerprint/backoff guard hit here (rare pre-R9; the pre-generation
+ * guard is item R9) just means no new row — the envelope + event below are
+ * written either way.
  *
  * @param stash     - Root stash directory.
  * @param inputRef  - The original input ref (for the event).
@@ -255,15 +357,75 @@ export async function runReflectQualityJudge(config, candidateContent, sourceCon
  * @param reason    - Human-readable rejection reason.
  * @param extraMeta - Optional additional metadata for the event.
  * @param eventsCtx - Events context so the emit takes appendEvent's fast path (R25).
+ * @param proposalOpts - Test seam / attribution passthrough for the minted proposal row.
  */
-export function writeQualityRejection(stash, inputRef, proposalRef, content, score, reason, extraMeta = {}, eligibilitySource, eventsCtx) {
+export function writeQualityRejection(stash, inputRef, proposalRef, content, score, reason, extraMeta = {}, eligibilitySource, eventsCtx, proposalOpts = {}) {
     // D-5 / #388: reviewNeeded flag selects "review_needed" vs "quality_rejected" outcome.
     const outcome = extraMeta.reviewNeeded ? "review_needed" : "quality_rejected";
+    // r2-1: the mint-time canonical validator inside createProposal (via
+    // emitProposal) throws UsageError for structurally-invalid content (e.g. a
+    // lessons/ ref missing description/when_to_use). The proposal row here is
+    // bookkeeping for backoff/Reflexion, never the authoritative record of the
+    // rejection, so a validator throw degrades to "no row minted" — the same
+    // bucket as the fingerprint/backoff skip below, not a caller-visible error.
+    // r3-1: the archiveProposal call below is guarded the same way, for the
+    // same reason.
+    let mintedProposal;
+    try {
+        mintedProposal = emitProposal({ stashDir: stash, ...(proposalOpts.proposalsCtx ? { proposalsCtx: proposalOpts.proposalsCtx } : {}) }, {
+            ref: proposalRef,
+            source: "distill",
+            ...(proposalOpts.sourceRun !== undefined ? { sourceRun: proposalOpts.sourceRun } : {}),
+            ...(proposalOpts.modelId !== undefined ? { modelId: proposalOpts.modelId } : {}),
+            payload: { content },
+            ...(eligibilitySource ? { eligibilitySource } : {}),
+        });
+    }
+    catch {
+        mintedProposal = undefined;
+    }
+    let proposal;
+    if (mintedProposal && !isProposalSkipped(mintedProposal)) {
+        if (outcome === "quality_rejected") {
+            try {
+                proposal = archiveProposal(stash, mintedProposal.id, "rejected", reason, proposalOpts.proposalsCtx);
+            }
+            catch (error) {
+                warn(`[akm] writeQualityRejection: failed to archive proposal ${mintedProposal.id} as rejected: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            proposal = mintedProposal;
+            // REVIEW: stamp the mint so the triage drain's `classifyPendingProposals`
+            // skips it instead of deferring it to the judgment tier, which could
+            // auto-accept it under `applyMode: promote` with no human ever seeing
+            // the review-band content the gate explicitly refused to auto-queue.
+            // Best-effort like the mint/archive tolerance above: a stamp failure
+            // warns and continues rather than blocking the rejection envelope.
+            try {
+                proposal =
+                    recordGateDecision(stash, mintedProposal.id, { outcome: "deferred", reason: "quality-review", gate: "quality-gate" }, proposalOpts.proposalsCtx) ?? proposal;
+            }
+            catch (error) {
+                warn(`[akm] writeQualityRejection: failed to stamp gate decision for ${mintedProposal.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
     const rejectDir = getDistillRejectedDir(stash);
     fs.mkdirSync(rejectDir, { recursive: true });
     const ts = timestampForFilename();
     const rejectPath = path.join(rejectDir, `${ts}-${proposalRef.replace(/[:/\\]/g, "-")}.md`);
-    fs.writeFileSync(rejectPath, `---\nscore: ${score}\nreason: ${reason}\noutcome: ${outcome}\n---\n\n${content}`, "utf8");
+    // R16: surface the judge's per-criterion scores in the envelope frontmatter
+    // when the caller supplied them (a judge-based rejection), same as the event.
+    const criteria = extraMeta.criteria && typeof extraMeta.criteria === "object" && !Array.isArray(extraMeta.criteria)
+        ? extraMeta.criteria
+        : undefined;
+    const criteriaFrontmatter = criteria
+        ? `criteria:\n${Object.entries(criteria)
+            .map(([key, value]) => `  ${key}: ${value}`)
+            .join("\n")}\n`
+        : "";
+    fs.writeFileSync(rejectPath, `---\nscore: ${score}\nreason: ${reason}\noutcome: ${outcome}\n${criteriaFrontmatter}---\n\n${content}`, "utf8");
     // #652 / itlackey/akm#890: journal it even though it now lands under
     // `$STATE`, outside the stash's git repo — `result.writtenPaths` reports
     // every path a run touched, in or out of the stash (describeRunWrittenPaths
@@ -295,6 +457,7 @@ export function writeQualityRejection(stash, inputRef, proposalRef, content, sco
         proposalRef,
         score,
         reason,
+        ...(proposal ? { proposalId: proposal.id, proposal } : {}),
         ...extraMeta,
     };
 }

package/dist/commands/improve/distill.js

@@ -68,7 +68,8 @@ import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/
 import { callStructured, preflightStructuredLlmRunner } from "../../llm/structured-call.js";
 import { closeDatabase, openReadonlyExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
-import { isProposalSkipped, listProposals, listProposalsReadOnly, proposalContent, } from "../proposal/repository.js";
+import { isStaleTargetRejection } from "../proposal/proposal-types.js";
+import { isProposalSkipped, listProposals, listProposalsReadOnly, } from "../proposal/repository.js";
 import { stripFrontmatterBody as stripBodyForFidelity } from "./content-hash.js";
 import { autoRepairLessonFrontmatter, autoSwapDescriptionWhenToUse, collectLessonQualityFindings, repairLessonDescriptionTruncation, } from "./distill/content-repair.js";
 import { memoryKnowledgePromotionRequiresDispatch, planMemoryKnowledgePromotion, promoteMemoryToKnowledge, } from "./distill/promote-memory.js";
@@ -790,6 +791,8 @@ export async function akmDistill(options) {
             eligMeta,
             eventsCtx: options.eventsCtx,
             stash,
+            ...(options.ctx ? { proposalsCtx: options.ctx } : {}),
+            ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
         });
         if ("rejection" in assembled)
             return withNotices(assembled.rejection);
@@ -868,7 +871,11 @@ async function emitDistillLessonProposal(args) {
                     reviewNeeded: true,
                     fidelityContradiction: true,
                     ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-                }, options.eligibilitySource, options.eventsCtx);
+                }, options.eligibilitySource, options.eventsCtx, {
+                    ...(options.ctx ? { proposalsCtx: options.ctx } : {}),
+                    ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
+                    ...(distillRunner?.connection.model ? { modelId: distillRunner.connection.model } : {}),
+                });
             }
         }
         catch {
@@ -972,7 +979,7 @@ async function emitDistillLessonProposal(args) {
  * throwing a `UsageError` on any finding. Extracted verbatim from `akmDistill`.
  */
 function assembleAndValidateDistillContent(args) {
-    const { raw, effectiveProposalKind, inputRef, durableInputRef, itemRef, effectiveLessonRef, exclusionSet, filteredFeedbackCount, eligMeta, eventsCtx, stash, } = args;
+    const { raw, effectiveProposalKind, inputRef, durableInputRef, itemRef, effectiveLessonRef, exclusionSet, filteredFeedbackCount, eligMeta, eventsCtx, stash, proposalsCtx, sourceRun, } = args;
     // Structured-output path: when the provider honoured the JSON schema, `raw`
     // is a JSON object string (not a markdown blob). Try to parse it and assemble
     // the canonical `---\nfm\n---\n\nbody` form before using the markdown
@@ -1046,7 +1053,10 @@ function assembleAndValidateDistillContent(args) {
                 proposalKind: effectiveProposalKind,
                 findingKinds: qualityFindings.map((f) => f.kind),
                 ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
-            }, eligMeta.eligibilitySource, eventsCtx),
+            }, eligMeta.eligibilitySource, eventsCtx, {
+                ...(proposalsCtx ? { proposalsCtx } : {}),
+                ...(sourceRun !== undefined ? { sourceRun } : {}),
+            }),
         };
     }
     return { content, descriptionSwapped };
@@ -1185,16 +1195,25 @@ async function applyDistillQualityGate(args) {
         onNotices,
     });
     if (!judgeResult.pass) {
+        const proposalOpts = {
+            ...(options.ctx ? { proposalsCtx: options.ctx } : {}),
+            ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
+            ...(distillRunner?.connection.model ? { modelId: distillRunner.connection.model } : {}),
+        };
         if (judgeResult.reviewNeeded) {
             return {
                 rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {
                     reviewNeeded: true,
+                    ...(judgeResult.criteria ? { criteria: judgeResult.criteria } : {}),
                     ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-                }, options.eligibilitySource, options.eventsCtx),
+                }, options.eligibilitySource, options.eventsCtx, proposalOpts),
             };
         }
         return {
-            rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}, options.eligibilitySource, options.eventsCtx),
+            rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {
+                ...(judgeResult.criteria ? { criteria: judgeResult.criteria } : {}),
+                ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
+            }, options.eligibilitySource, options.eventsCtx, proposalOpts),
         };
     }
     // Normalize 1-5 judge score to [0, 1]. Only a real passing verdict
@@ -1240,12 +1259,21 @@ async function buildDistillMessages(args) {
     const { options, stash, inputRef, assetContent, feedback, effectiveProposalKind, effectiveLessonRef, fetchSimilarLessonsFn, } = args;
     // Inject last 1–3 rejected proposals for this ref as Reflexion-style
     // verbal-RL context so the LLM avoids regenerating refused proposals.
+    // Exclude the drain's stale-target auto-rejects (STALE, R20): those are a
+    // procedural refusal (the target changed after mint), not a judgement on
+    // the content, and would mislead this Reflexion-style "don't repeat this"
+    // context.
     const rejectedForRef = listProposalsReadOnly(stash, { ref: inputRef, status: "rejected", includeArchive: true }, options.ctx)
+        .filter((p) => !isStaleTargetRejection(p))
         .sort((a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime())
         .slice(0, MAX_REJECTED_PROPOSALS)
         .map((p) => ({
         reason: p.review?.reason ?? "no reason given",
-        contentPreview: proposalContent(p).slice(0, 500),
+        // #legacy: `changes` is empty for pre-existing rows (storedToChanges),
+        // which makes `proposalContent` throw before reflect dispatch even
+        // runs. `payload.content` is populated for every row regardless, so
+        // read the preview from there instead.
+        contentPreview: p.payload.content.slice(0, 500),
     }));
     // WS-3b CLS interleaving (step 9).
     // When cls.enabled, inject embedding-retrieved adjacent lessons/knowledge
@@ -1282,7 +1310,13 @@ async function buildDistillMessages(args) {
         { role: "user", content: userPrompt },
     ];
 }
-async function defaultLookup(ref, stashDir) {
+/**
+ * Exported (PRECHECK, tier3-0917) so the improve loop's distill
+ * pre-generation guard (`loop-stages.ts`) can resolve the same asset path
+ * `akmDistill` would when checking whether a memory promotes to knowledge —
+ * without duplicating the resolution logic.
+ */
+export async function defaultLookup(ref, stashDir) {
     return resolveAssetPath(ref, {
         stashDir,
         mode: "disk-only",

package/dist/commands/improve/eligibility.js

@@ -467,12 +467,22 @@ export function buildLatestProposalTsMap(refs, source, itemRefByRef, eventsCtx)
         if (!ref)
             continue;
         // For distill_invoked we only count attempts that produced (or attempted
-        // to produce) a real proposal — config_disabled / parse-error outcomes
-        // should not move the signal-delta cursor forward.
+        // to produce) a real proposal — config_disabled outcomes (no LLM work was
+        // actually invoked) and llm_failed (transport/timeout — nothing to show
+        // for the attempt) should not move the signal-delta cursor forward.
+        // R10: quality_rejected and review_needed now also mint a real proposal
+        // row (see quality-gate.ts's `writeQualityRejection`), so — like queued —
+        // a real attempt was made and the cursor must advance, or the same
+        // already-rejected ref is re-selected and re-rejected on every run.
         if (eventType === "distill_invoked") {
             const outcome = e.metadata?.outcome;
-            if (outcome !== "queued" && outcome !== "skipped" && outcome !== "validation_failed")
+            if (outcome !== "queued" &&
+                outcome !== "skipped" &&
+                outcome !== "validation_failed" &&
+                outcome !== "quality_rejected" &&
+                outcome !== "review_needed") {
                 continue;
+            }
         }
         const ts = e.ts ?? "";
         if (ts > (out.get(ref) ?? ""))

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

@@ -128,26 +128,47 @@ function collectRequiredEngineTargets(plan) {
  * insufficient here: a gateway can list a model while its upstream completion
  * route is dead (#980). Deduplicate by endpoint + model, not endpoint alone,
  * because model backends behind one gateway can fail independently.
+ *
+ * R17: a probe that PASSES used to leave no trace — a slow or flapping
+ * gateway was invisible in the improve result. On success, return one
+ * {@link EngineProbeOutcome} per target (process, engine, endpoint,
+ * reachable, latencyMs) so the caller can record it on the run result;
+ * targets sharing a deduplicated probe share its measured latency.
+ *
+ * Exported for unit tests, which inject a fake `probeReachable` (the
+ * "probe seam") instead of hitting a real endpoint.
  */
-async function assertRequiredEnginesReachable(plan, probeReachable = (connection) => probeLlmReachable(connection, 3_000)) {
+export async function assertRequiredEnginesReachable(plan, probeReachable = (connection) => probeLlmReachable(connection, 3_000)) {
     const targets = collectRequiredEngineTargets(plan);
     if (targets.length === 0)
-        return;
+        return [];
     const probesByConnection = new Map();
     const probed = await Promise.all(targets.map(async (target) => {
         const key = `${target.connection.endpoint.replace(/\/+$/, "")}|${target.connection.model}`;
         let pending = probesByConnection.get(key);
         if (!pending) {
-            pending = probeReachable(target.connection);
+            const probeStartedAt = Date.now();
+            pending = probeReachable(target.connection).then((reach) => ({
+                reach,
+                latencyMs: Date.now() - probeStartedAt,
+            }));
             probesByConnection.set(key, pending);
         }
-        return { ...target, reach: await pending };
+        const { reach, latencyMs } = await pending;
+        return { ...target, reach, latencyMs };
     }));
     const unreachable = probed.filter((item) => !item.reach.reachable);
-    if (unreachable.length === 0)
-        return;
-    const lines = unreachable.map((item) => `  - ${item.process} (engine "${item.engine}", ${item.connection.endpoint}): ${item.reach.error ?? "did not respond"}`);
-    throw new ConfigError(`--require-engines: ${unreachable.length} improve process${unreachable.length === 1 ? "" : "es"} cannot run because ${unreachable.length === 1 ? "its" : "their"} engine completion path is not reachable:\n${lines.join("\n")}`, "LLM_NOT_CONFIGURED");
+    if (unreachable.length > 0) {
+        const lines = unreachable.map((item) => `  - ${item.process} (engine "${item.engine}", ${item.connection.endpoint}): ${item.reach.error ?? "did not respond"}`);
+        throw new ConfigError(`--require-engines: ${unreachable.length} improve process${unreachable.length === 1 ? "" : "es"} cannot run because ${unreachable.length === 1 ? "its" : "their"} engine completion path is not reachable:\n${lines.join("\n")}`, "LLM_NOT_CONFIGURED");
+    }
+    return probed.map((item) => ({
+        process: item.process,
+        engine: item.engine,
+        endpoint: item.connection.endpoint,
+        reachable: item.reach.reachable,
+        latencyMs: item.latencyMs,
+    }));
 }
 /**
  * `--show-prompt` (#952): render the composed reflect prompt for one asset ref
@@ -343,9 +364,10 @@ export const improveCommand = defineCommand({
                 await runShowPromptCli(scopeArg, scopeRef, taskArg, targetArg, resolvedPlan);
                 return;
             }
+            let engineProbe;
             if (args["require-engines"]) {
                 assertRequiredEnginesAvailable(resolvedPlan);
-                await assertRequiredEnginesReachable(resolvedPlan);
+                engineProbe = await assertRequiredEnginesReachable(resolvedPlan);
             }
             const selectedStrategyName = resolvedPlan.strategy.name;
             const sensitiveValues = collectEngineCredentialValues(effectiveConfig);
@@ -422,6 +444,7 @@ export const improveCommand = defineCommand({
                         ...(requireFeedbackSignal ? { requireFeedbackSignal } : {}),
                         ...(skipIfLocked ? { skipIfLocked } : {}),
                         ...(strategyArg !== undefined ? { strategy: strategyArg } : {}),
+                        ...(engineProbe !== undefined ? { engineProbe } : {}),
                         ...(Object.keys(syncOverride).length > 0 ? { sync: syncOverride } : {}),
                         consolidateOptions: {
                             target: targetArg,

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

@@ -9,7 +9,7 @@ import proactiveMaintenance from "../../assets/improve-strategies/proactive-main
 import quick from "../../assets/improve-strategies/quick.json" with { type: "json" };
 import reflectDistill from "../../assets/improve-strategies/reflect-distill.json" with { type: "json" };
 import thorough from "../../assets/improve-strategies/thorough.json" with { type: "json" };
-import { parseRefInput } from "../../core/asset/resolve-ref.js";
+import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { ImproveProfileConfigSchema } from "../../core/config/config-schema.js";
 import { deepMergeConfig } from "../../core/config/deep-merge.js";
 import { BUILTIN_IMPROVE_STRATEGY_NAMES, IMPROVE_PROCESS_ENGINE_CAPABILITIES, } from "../../core/config/engine-semantics.js";
@@ -27,6 +27,14 @@ export function resolveProcessEnabled(processName, strategy) {
     const processes = strategy.processes;
     return processes?.[processName]?.enabled === true;
 }
+/** `bundle//conceptId` -> bare `conceptId`, for an `excludeRefPrefixes` entry. */
+function stripBundlePrefix(value) {
+    const boundary = value.indexOf("//");
+    const stripped = boundary >= 0 ? value.slice(boundary + 2) : value;
+    // A trailing `/` (e.g. "knowledge/wikis/articles/raw/") would otherwise turn the
+    // segment-boundary check below into `startsWith(".../raw//")`, which never matches.
+    return stripped.replace(/\/+$/, "");
+}
 export function shouldSkipRef(ref, processName, strategy) {
     const process = strategy.processes?.[processName];
     if (process?.enabled === false)
@@ -35,6 +43,20 @@ export function shouldSkipRef(ref, processName, strategy) {
     const allowed = process?.allowedTypes ?? DEFAULT_ALLOWED_TYPES[processName];
     if (!allowed.includes(parsed.type))
         return { skip: true, reason: "type-filter" };
+    // R12: reflect only — raw wiki-ingest snapshots are type `knowledge`, so
+    // allowedTypes alone can't exclude them (distill/consolidate are memory-only).
+    if (processName === "reflect") {
+        const excludePrefixes = strategy.processes?.reflect?.excludeRefPrefixes;
+        if (excludePrefixes && excludePrefixes.length > 0) {
+            const conceptId = conceptIdFromTypeName(parsed.type, parsed.name);
+            const excluded = excludePrefixes.some((prefix) => {
+                const stripped = stripBundlePrefix(prefix);
+                return conceptId === stripped || conceptId.startsWith(`${stripped}/`);
+            });
+            if (excluded)
+                return { skip: true, reason: "exclude-filter" };
+        }
+    }
     return { skip: false, reason: "" };
 }
 export function isStrategyFilteredForAllPasses(ref, strategy) {