akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/improve/distill.js

@@ -2,49 +2,15 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * `akm distill <ref>` — feedback distillation into lesson proposals (#228).
+ * `akm distill <ref>` — distil an asset and its feedback into a lesson (or,
+ * for a reinforced memory, a knowledge) proposal. One bounded LLM call, then
+ * the shared judge → mint path in `./stage`; the proposal queue is the only
+ * way to a live asset. Every invocation emits one `distill_invoked` event
+ * carrying its `outcome` (config-disabled runs emit none).
  *
- * The command reads a target asset and any recent feedback events about it,
- * asks an LLM to distil a *lesson* (per v1 spec §13) the agent should
- * remember next time, and queues the result as a {@link Proposal} (source
- * `"distill"`). The proposal queue is the *only* path to a live asset — this
- * command never mutates source files directly. Acceptance is a human (or
- * automated) decision via `akm proposal accept`.
- *
- * # Architectural seams
- *
- *   - **Single bounded in-tree LLM call.** Routed through `callStructured`
- *     under the `distill` gate (v1 spec §14; 0.8.0 unified the orchestration
- *     and LLM-call gates under `processes.distill.enabled`). The wrapper
- *     enforces a hard timeout (default 600s / 10 min — overridable via
- *     `opts.timeoutMs`) and converts disable / throw / timeout
- *     into a `null` return from `fn`, which we treat as a graceful
- *     "skipped" outcome (exit 0, no proposal, `distill_invoked` event with
- *     `outcome: "skipped"`).
- *   - **Stateless.** No module-level state — every callable is a pure
- *     function of its arguments and an injectable `chat` seam. The
- *     architecture seam test (`tests/architecture/llm-stateless-seam.test.ts`)
- *     applies.
- *   - **Output substrate.** Proposal creation goes through the `proposals`
- *     module so distill shares its persistence + validation pipeline with
- *     `akm reflect` / `akm propose`. Validation failures (LLM returned a
- *     lesson without required `description` / `when_to_use` frontmatter) are
- *     a *different* graceful path: no proposal is created, the structured
- *     error is surfaced, and the command exits non-zero.
- *
- * # Lesson-name derivation rule
- *
- * A nested input preserves its first legitimate scope segment
- * (`memories/project-a/deploy` → `lessons/project-a/memory-deploy-lesson`). An
- * unscoped input stays flat; asset types are not project scopes. Origin prefixes
- * remain durable provenance but are not embedded in the output path.
- *
- * # Why we do not call `runAgent`
- *
- * Distillation is in-tree per the v1 spec ("bounded in-tree LLM call"). The
- * agent dispatch path is a heavier shell-out used by the curator/agent
- * surfaces — distill must be cheap, deterministic-ish, and bounded so it can
- * be invoked from CI / automation without spinning up an agent harness.
+ * Lesson refs: a nested input keeps its first scope segment
+ * (`memories/project-a/deploy` → `lessons/project-a/memory-deploy-lesson`); an
+ * unscoped input stays flat.
  */
 import fs from "node:fs";
 import distillKnowledgeSystemPrompt from "../../assets/prompts/distill-knowledge-system.md" with { type: "text" };
@@ -54,6 +20,7 @@ import { parseFrontmatter, writeSalienceToFrontmatter } from "../../core/asset/f
 import { stripMarkdownFences } from "../../core/asset/markdown.js";
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { authoringRulesForType } from "../../core/authoring-rules.js";
+import { resolveStashDir } from "../../core/common.js";
 import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
@@ -62,110 +29,47 @@ import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { getDbPath } from "../../core/paths.js";
 import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { withStateDb } from "../../core/state-db.js";
-import { warnVerbose } from "../../core/warn.js";
+import { warn, warnVerbose } from "../../core/warn.js";
+import { recordWrittenPath } from "../../core/write-provenance.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
-import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
-import { callStructured, preflightStructuredLlmRunner } from "../../llm/structured-call.js";
+import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.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 { stripFrontmatterBody as stripBodyForFidelity } from "./content-hash.js";
+import { listProposals } from "../proposal/repository.js";
+import { detectDoubleFrontmatter, isValidDescription } from "../proposal/validators/proposal-quality-validators.js";
+import { akmSearch } from "../read/search.js";
+import { stripFrontmatterBody } from "./content-hash.js";
 import { autoRepairLessonFrontmatter, autoSwapDescriptionWhenToUse, collectLessonQualityFindings, repairLessonDescriptionTruncation, } from "./distill/content-repair.js";
-import { memoryKnowledgePromotionRequiresDispatch, planMemoryKnowledgePromotion, promoteMemoryToKnowledge, } from "./distill/promote-memory.js";
-import { fetchTopSimilarLessons, persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection, } from "./distill/quality-gate.js";
 import { buildClsContext, checkDistillFidelity, DEFAULT_CLS_ADJACENT_COUNT } from "./distill-guards.js";
-import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
+import { assessMemoryKnowledgePromotionCandidate, deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { buildRefVocabulary, scoreEncodingSalience } from "./encoding-salience.js";
-import { resolveImproveLlmExecution } from "./execution.js";
 import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
-import { emitProposal } from "./proposal-envelope.js";
-import { createRunContext, resolveRunStashDir } from "./run-context.js";
+import { recordLedgerAttempt } from "./ledger.js";
 import { computeSalience, upsertAssetSalience } from "./salience.js";
-import { MAX_REJECTED_PROPOSALS } from "./shared.js";
-import { durableImproveRef } from "./source-identity.js";
+import { callStage, mintProposal, noticeSet, rejectedProposalContext, runLessonQualityJudge, stageRunner, } from "./stage.js";
 /**
- * Asset-ref types that `akm distill` structurally refuses as inputs.
- *
- * Distill *produces* lessons from non-lesson sources (memory, skill, knowledge,
- * etc.). Calling distill on an existing `lessons/*` ref would derive
- * `lessons/lesson-<name>-lesson-lesson` (double `-lesson` suffix) — the
- * recursive-ref defect observed across 323 archived rejected proposals.
- *
- * 08-F2: `env` and `secret` are refused as a STRUCTURAL floor — distill reads
- * the input asset's bytes via `readFileSync` and hands them to the LLM, so
- * secret material must never be a distill input. This gate is code, not config:
- * it holds even when `allowedTypes` config is mis-set in unattended cron.
- *
- * The runtime gate inside {@link akmDistill} still refuses these inputs
- * defensively (returning an `outcome: "skipped"` envelope with `skipReason:
- * "recursive_lesson_input"`). This exported set is the planner-side companion:
- * callers that schedule distill attempts (e.g. `akm improve`'s distill queue)
- * import it so refs of these types never enter the queue in the first place.
- *
- * Source of truth: this set drives the gate in `akmDistill` and is consumed
- * directly by the improve planner. Adding a new structurally-refused input
- * type means updating this constant — the planner picks the change up for
- * free.
+ * Input types distill structurally refuses: a lesson is the distilled form
+ * (distilling one would mint `lessons/lesson-…-lesson`), and env/secret bytes
+ * must never reach the model. The improve planner skips these before queuing.
  */
 export const DISTILL_REFUSED_INPUT_TYPES = new Set(["lesson", "env", "secret"]);
-/**
- * Returns true when `type` is structurally refused as an input by
- * {@link akmDistill}. See {@link DISTILL_REFUSED_INPUT_TYPES}.
- */
 export function isDistillRefusedInputType(type) {
     return DISTILL_REFUSED_INPUT_TYPES.has(type);
 }
-// ── Lesson-ref derivation ───────────────────────────────────────────────────
-/** Derive the proposed lesson ref from the input ref. See module docblock. */
+/** Derive the proposed lesson ref from the input ref. */
 export function deriveLessonRef(inputRef) {
     const parsed = parseRefInput(inputRef);
-    // Strip the bundle: a feedback signal recorded against `team//skills/deploy`
-    // distils into the same lesson namespace as `skills/deploy`. The proposal
-    // id (a UUID) keeps the queue entries distinct, so collisions are not a
-    // problem — and reviewers want to see them next to each other anyway.
     const parts = parsed.name.split("/");
     const scope = parts.length > 1 ? parts.shift() : undefined;
-    const slug = `${parsed.type}-${parts.join("-")}`.toLowerCase();
-    // Replace anything outside the canonical asset-name charset with `-`. Keep
-    // it deterministic so re-runs produce the same ref.
-    const safe = slug
+    const clean = (value) => value
+        .toLowerCase()
         .replace(/[^a-z0-9-]+/g, "-")
         .replace(/-+/g, "-")
         .replace(/^-|-$/g, "");
-    const safeScope = scope
-        ?.toLowerCase()
-        .replace(/[^a-z0-9-]+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-|-$/g, "");
-    return `lessons/${safeScope ? `${safeScope}/` : ""}${safe}-lesson`;
+    const safeScope = scope ? clean(scope) : "";
+    return `lessons/${safeScope ? `${safeScope}/` : ""}${clean(`${parsed.type}-${parts.join("-")}`)}-lesson`;
 }
-// ── Content quality validators ──────────────────────────────────────────────
-//
-// The actual implementations now live in `core/proposal-quality-validators.ts`
-// so the same checks run inside `runProposalValidators` on `proposal accept`.
-import { detectDoubleFrontmatter, isValidDescription } from "../proposal/validators/proposal-quality-validators.js";
-// ── Prompt assembly ─────────────────────────────────────────────────────────
-const LESSON_SYSTEM_PROMPT = distillLessonSystemPrompt;
-const KNOWLEDGE_SYSTEM_PROMPT = distillKnowledgeSystemPrompt;
-// ── Structured-output schemas (responseSchema lift) ─────────────────────────
-//
-// PR 1 of the asset-writers decision (see knowledge/projects/akm/
-// asset-writers-investigation/00-synthesis): on providers that honour
-// `response_format: json_schema`, ask the LLM for a typed JSON object and
-// re-assemble the markdown locally. The "emit raw markdown with embedded
-// frontmatter" path supports providers that ignore
-// the schema (and for the `chat` test seam, which is wired to return strings
-// today). Shape-level rejection codes — MALFORMED_FRONTMATTER_BLOCK,
-// FRONTMATTER_NOT_OBJECT, INVALID_YAML, UNBALANCED_CODE_FENCE — become
-// unreachable on the structured path. Content-quality validators
-// (isValidDescription / isValidWhenToUse) keep firing post-assembly because
-// the LLM still controls the string contents of typed fields.
-/**
- * JSON Schema for structured lesson distillation. Mirrors the LESSON_SYSTEM_PROMPT
- * frontmatter contract. Required: description, when_to_use, body. Optional:
- * tags (string array) so providers that volunteer categorisation hints survive
- * the round-trip without being rejected as additionalProperties.
- */
+// ── Output contract ──────────────────────────────────────────────────────────
 export const DISTILL_LESSON_JSON_SCHEMA = {
     type: "object",
     required: ["description", "when_to_use", "body"],
@@ -193,21 +97,12 @@ export const DISTILL_LESSON_JSON_SCHEMA = {
         },
     },
 };
-/**
- * JSON Schema for structured knowledge distillation. Mirrors the
- * KNOWLEDGE_SYSTEM_PROMPT contract. Required: description, body. Optional:
- * tags, sources.
- */
 export const DISTILL_KNOWLEDGE_JSON_SCHEMA = {
     type: "object",
     required: ["description", "body"],
     additionalProperties: false,
     properties: {
-        description: {
-            type: "string",
-            minLength: 1,
-            description: "One-line summary of the knowledge asset.",
-        },
+        description: { type: "string", minLength: 1, description: "One-line summary of the knowledge asset." },
         body: {
             type: "string",
             minLength: 1,
@@ -226,38 +121,31 @@ export const DISTILL_KNOWLEDGE_JSON_SCHEMA = {
     },
 };
 /**
- * Assemble a markdown asset from a structured-output payload. Returns `null`
- * when the payload is missing required fields — the caller then falls through
- * to the prompt-contract markdown path. We deliberately do NOT validate
- * content quality here (isValidDescription / isValidWhenToUse run downstream
- * on the assembled content); this helper only catches shape-level emptiness
- * that the schema may not have rejected (e.g. a provider that ignored
- * `minLength` but still returned the field).
+ * Assemble markdown from a structured-output payload, or `null` when a
+ * required field is empty (the caller then treats the response as markdown).
  */
 export function assembleStructuredDistillMarkdown(payload, kind) {
     if (payload === null || typeof payload !== "object")
         return null;
-    const description = typeof payload.description === "string" ? payload.description.trim() : "";
-    const body = typeof payload.body === "string" ? payload.body.trim() : "";
-    if (description.length === 0 || body.length === 0)
+    const text = (value) => (typeof value === "string" ? value.trim() : "");
+    const list = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.trim().length > 0) : [];
+    const description = text(payload.description);
+    const body = text(payload.body);
+    if (!description || !body)
         return null;
     const fm = { description };
     if (kind === "lesson") {
-        const whenToUse = typeof payload.when_to_use === "string" ? payload.when_to_use.trim() : "";
-        if (whenToUse.length === 0)
+        const whenToUse = text(payload.when_to_use);
+        if (!whenToUse)
             return null;
         fm.when_to_use = whenToUse;
     }
-    if (Array.isArray(payload.tags)) {
-        const tags = payload.tags.filter((t) => typeof t === "string" && t.trim().length > 0);
-        if (tags.length > 0)
-            fm.tags = tags;
-    }
-    if (kind === "knowledge" && Array.isArray(payload.sources)) {
-        const sources = payload.sources.filter((s) => typeof s === "string" && s.trim().length > 0);
-        if (sources.length > 0)
-            fm.xrefs = sources;
-    }
+    const tags = list(payload.tags);
+    if (tags.length > 0)
+        fm.tags = tags;
+    const sources = kind === "knowledge" ? list(payload.sources) : [];
+    if (sources.length > 0)
+        fm.xrefs = sources;
     return assembleAssetFromString(serializeFrontmatterQuoted(fm), body);
 }
 function validateKnowledgeContent(content, inputRef) {
@@ -270,1017 +158,673 @@ function validateKnowledgeContent(content, inputRef) {
             message: `Distilled knowledge for ${inputRef} must include a non-empty markdown body.`,
         });
     }
-    // Knowledge proposals don't strictly require a description, but if one is
-    // present it must be a real summary — not a placeholder like `---` or a
-    // truncated heading. Without this check, distill can land knowledge assets
-    // with `description: ---` (observed in the wild when the LLM has nothing
-    // meaningful to say about a session-checkpoint memory).
-    const fm = (parsed.data ?? {});
-    if (fm.description !== undefined) {
-        // Knowledge can legitimately mention the topic name in its description, so
-        // suppress the ref-restatement heuristic that's tuned for lesson assets.
-        const descCheck = isValidDescription(fm.description, inputRef, { skipRefTailCheck: true });
-        if (!descCheck.ok) {
+    // A present description must be a real summary (not `---` or a heading fragment).
+    const description = parsed.data?.description;
+    if (description !== undefined) {
+        const check = isValidDescription(description, inputRef, { skipRefTailCheck: true });
+        if (!check.ok) {
             findings.push({
                 kind: "invalid-description",
                 field: "description",
-                message: `Distilled knowledge for ${inputRef} has an invalid description: ${descCheck.reason}.`,
+                message: `Distilled knowledge for ${inputRef} has an invalid description: ${check.reason}.`,
             });
         }
     }
-    // Double-frontmatter pollution shows up in knowledge too — the LLM sometimes
-    // re-emits the source asset's frontmatter inside its own response, leaving
-    // two `---`-delimited blocks back-to-back.
-    const dfm = detectDoubleFrontmatter(content);
-    if (dfm) {
+    const doubled = detectDoubleFrontmatter(content);
+    if (doubled) {
         findings.push({
-            kind: dfm.kind,
+            kind: doubled.kind,
             field: "body",
-            message: `Distilled knowledge for ${inputRef}: ${dfm.message}`,
+            message: `Distilled knowledge for ${inputRef}: ${doubled.message}`,
         });
     }
     return findings;
 }
 /**
- * Pure: build the user-prompt body. Exported for tests.
- *
- * D-3 (#371): restructures the feedback section from raw JSON event lines into
- * a Reflexion-style verbal contrast (`## What worked` / `## What failed`).
- * The verbal format allows LLMs to use feedback as gradient signal rather than
- * just metadata — capturing the +8% AlfWorld lift from arXiv:2303.11366 and
- * the contrast-based rule-learning gain from ExpeL arXiv:2308.10144.
+ * The distill user prompt. Feedback is rendered as "What worked" / "What
+ * failed" contrast when it carries signals, else as a flat event list.
  */
 export function buildDistillPrompt(input) {
-    const lines = [];
-    lines.push(`Asset ref: ${input.inputRef}`);
-    lines.push("");
+    const lines = [`Asset ref: ${input.inputRef}`, ""];
     if (input.standardsContext?.trim()) {
-        lines.push("Standards to follow (the rulebook for this target):");
-        lines.push(input.standardsContext.trim());
-        lines.push("");
-    }
-    {
-        const authoringRules = authoringRulesForType(input.proposalKind ?? "lesson");
-        if (authoringRules) {
-            lines.push(authoringRules);
-            lines.push("");
-        }
+        lines.push("Standards to follow (the rulebook for this target):", input.standardsContext.trim(), "");
     }
+    const authoringRules = authoringRulesForType(input.proposalKind ?? "lesson");
+    if (authoringRules)
+        lines.push(authoringRules, "");
     lines.push("Asset content:");
     if (input.assetContent) {
-        // The output contract also uses YAML fences. Feeding source frontmatter
-        // verbatim caused local models to copy it into the lesson body, producing
-        // deterministic double-frontmatter rejection. Distillation needs the
-        // source body; its metadata is not evidence to reproduce.
-        const body = parseFrontmatter(input.assetContent).content.trim().slice(0, 3000);
-        lines.push("```");
-        lines.push(body);
-        lines.push("```");
+        // Source frontmatter is not evidence; fed verbatim, models copied it into the body.
+        lines.push("```", parseFrontmatter(input.assetContent).content.trim().slice(0, 3000), "```");
     }
     else {
         lines.push("(asset is not currently indexed; distil from feedback signal alone)");
     }
     lines.push("");
+    const flat = (event) => `- ${event.ts} ${event.eventType}${event.metadata ? ` ${JSON.stringify(event.metadata)}` : ""}`;
     if (input.feedback.length === 0) {
         lines.push("Recent feedback: (no feedback events recorded — distil from the asset itself)");
     }
     else {
-        // D-3 (#371): verbal contrast format for Reflexion verbal-gradient lift.
-        // Partition events into positive ("what worked") and negative ("what failed").
-        const positive = [];
-        const negative = [];
-        const neutral = [];
+        const worked = [];
+        const failed = [];
+        const other = [];
         for (const event of input.feedback) {
-            const meta = (event.metadata ?? {});
-            const signal = typeof meta.signal === "string" ? meta.signal : undefined;
-            const reason = typeof meta.reason === "string" ? meta.reason : "";
-            const note = typeof meta.note === "string" ? meta.note : "";
-            const detail = reason || note;
-            const line = detail ? `- ${event.ts}: ${detail}` : `- ${event.ts}: feedback received`;
-            if (signal === "positive")
-                positive.push(line);
-            else if (signal === "negative")
-                negative.push(line);
+            const meta = event.metadata ?? {};
+            const detail = (typeof meta.reason === "string" ? meta.reason : "") || (typeof meta.note === "string" ? meta.note : "");
+            const line = `- ${event.ts}: ${detail || "feedback received"}`;
+            if (meta.signal === "positive")
+                worked.push(line);
+            else if (meta.signal === "negative")
+                failed.push(line);
             else
-                neutral.push(`- ${event.ts} ${event.eventType}${event.metadata ? ` ${JSON.stringify(event.metadata)}` : ""}`);
+                other.push(flat(event));
         }
-        if (positive.length > 0 || negative.length > 0) {
-            if (positive.length > 0) {
-                lines.push("## What worked");
-                for (const l of positive)
-                    lines.push(l);
-                lines.push("");
-            }
-            if (negative.length > 0) {
-                lines.push("## What failed");
-                for (const l of negative)
-                    lines.push(l);
-                lines.push("");
-            }
-            if (neutral.length > 0) {
-                lines.push("## Other signals");
-                for (const l of neutral)
-                    lines.push(l);
-                lines.push("");
+        if (worked.length > 0 || failed.length > 0) {
+            for (const [heading, section] of [
+                ["## What worked", worked],
+                ["## What failed", failed],
+                ["## Other signals", other],
+            ]) {
+                if (section.length > 0)
+                    lines.push(heading, ...section, "");
             }
         }
         else {
-            // No positive/negative signals — fall back to the pre-D3 flat format for
-            // non-feedback event types (e.g. reflect_invoked, distill_invoked).
-            lines.push("Recent feedback events (most recent last):");
-            for (const event of input.feedback) {
-                const meta = event.metadata ? ` ${JSON.stringify(event.metadata)}` : "";
-                lines.push(`- ${event.ts} ${event.eventType}${meta}`);
-            }
-            lines.push("");
+            lines.push("Recent feedback events (most recent last):", ...input.feedback.map(flat), "");
         }
     }
     if (input.rejectedProposals && input.rejectedProposals.length > 0) {
-        lines.push("");
-        lines.push("Previously rejected proposals for this ref (Reflexion context):");
-        lines.push("The following proposals were already reviewed and rejected. " +
+        lines.push("", "Previously rejected proposals for this ref (Reflexion context):", "The following proposals were already reviewed and rejected. " +
             "Your new proposal MUST differ meaningfully in approach, framing, or evidence.");
         for (const rp of input.rejectedProposals) {
             lines.push(`- Rejection reason: ${rp.reason}`);
-            if (rp.contentPreview) {
+            if (rp.contentPreview)
                 lines.push(`  Content preview: ${rp.contentPreview.slice(0, 200).replace(/\n/g, " ")}`);
-            }
         }
     }
-    if (input.proposalKind === "knowledge") {
-        lines.push("Produce the knowledge markdown file now. Start your response with `---` on the first line, followed by a `description:` field whose value is a 1-sentence summary (20–400 chars). Never use placeholder values like `---`, `tbd`, `n/a`, or a single dash. If the source has nothing meaningful to summarize, do NOT produce a proposal — return an empty response instead. The frontmatter block ends with a second `---` line; do not emit any additional `---` fences in the body.");
-    }
-    else {
-        lines.push("Produce the lesson markdown file now. Start your response with `---` on the first line, followed by `description:` and `when_to_use:` fields. Both must be real one-sentence summaries (20–400 chars) — never placeholder values like `---`, `tbd`, or `n/a`. The frontmatter block ends with a second `---` line; do not emit any additional `---` fences in the body.");
-    }
+    lines.push(input.proposalKind === "knowledge"
+        ? "Produce the knowledge markdown file now. Start your response with `---` on the first line, followed by a `description:` field whose value is a 1-sentence summary (20–400 chars). Never use placeholder values like `---`, `tbd`, `n/a`, or a single dash. If the source has nothing meaningful to summarize, do NOT produce a proposal — return an empty response instead. The frontmatter block ends with a second `---` line; do not emit any additional `---` fences in the body."
+        : "Produce the lesson markdown file now. Start your response with `---` on the first line, followed by `description:` and `when_to_use:` fields. Both must be real one-sentence summaries (20–400 chars) — never placeholder values like `---`, `tbd`, or `n/a`. The frontmatter block ends with a second `---` line; do not emit any additional `---` fences in the body.");
     return lines.join("\n");
 }
-// ── Main entry point ────────────────────────────────────────────────────────
-/**
- * Run a single bounded distillation pass for `ref`. Always emits exactly one
- * `distill_invoked` event (with `outcome` in the metadata) regardless of the
- * branch taken — so observers can count invocations cheaply.
- */
-/**
- * Best-effort load of the distill INPUT asset plus the #608 encoding-time
- * salience scoring: read the source, build the once-per-invocation bigram ref
- * vocabulary, then score the asset (novelty×0.40 + magnitude×0.35 +
- * predictionError×0.25) and mirror the result to both the asset frontmatter and
- * `state.db :: asset_salience`. Every write is best-effort. Extracted verbatim
- * from `akmDistill`; returns the (possibly salience-stamped) content plus the
- * ref vocabulary the caller reuses when scoring the distilled OUTPUT (G4).
- */
-async function loadAndScoreInputSalience(args) {
-    const { inputRef, durableInputRef, salienceWriteKey, stash, outcomeWeightEnabled, lookup, ctx } = args;
-    // Best-effort load: when the asset is not yet indexed we still proceed —
-    // the LLM is asked to distil from "available signal" (feedback alone).
-    let assetContent = null;
-    let assetFilePath = null;
-    try {
-        const filePath = await lookup(durableInputRef);
-        if (filePath && fs.existsSync(filePath)) {
-            assetFilePath = filePath;
-            assetContent = ctx.readAsset(filePath);
-        }
-    }
-    catch {
-        assetContent = null;
-    }
-    // ── #608: Encoding-time salience scoring ────────────────────────────────
-    // Score the source asset with the three-signal model (novelty × 0.40 +
-    // magnitude × 0.35 + predictionError × 0.25) and persist the result to:
-    //   1. The asset's frontmatter (human-readable mirror; idempotent delta gate).
-    //   2. state.db :: asset_salience (canonical; feeds improve's high-salience gate).
-    // Both writes are best-effort — a DB error never blocks distillation.
-    //
-    // The bigram ref vocabulary is built ONCE per invocation — the novelty signal
-    // reuses it when scoring the distilled OUTPUT at proposal creation (G4).
-    let existingRefVocabulary = new Set();
-    try {
-        const indexDb = openReadonlyExistingDatabase(getDbPath(), { isolatedSnapshot: true });
-        if (indexDb) {
-            try {
-                const allRefs = getAllEntries(indexDb).map((e) => e.itemRef);
-                existingRefVocabulary = buildRefVocabulary(allRefs);
-            }
-            finally {
-                closeDatabase(indexDb);
-            }
-        }
-    }
-    catch {
-        // Index not available — novelty defaults to type-floor.
-    }
-    if (args.persistSalience !== false && assetContent && assetFilePath) {
-        try {
-            const parsedRef = parseRefInput(inputRef);
-            // G4: predictionError decays with revision count — the prior hardcoded
-            // `revisionCount: 0` made it a dead constant 1.0. Use the number of
-            // proposals ever raised against this ref as the revision proxy.
-            let revisionCount = 0;
-            try {
-                revisionCount = listProposals(stash, { ref: inputRef, includeArchive: true }).length;
-            }
-            catch {
-                // best-effort: unknown history scores as a first encounter
-            }
-            const salienceResult = scoreEncodingSalience({
-                body: assetContent,
-                type: parsedRef.type,
-                existingRefVocabulary,
-                revisionCount,
-            });
-            // 1. Write salience to the source asset frontmatter (idempotent).
-            const updatedContent = writeSalienceToFrontmatter(assetContent, salienceResult.score, salienceResult);
-            if (updatedContent !== assetContent) {
-                ctx.writeAsset(assetFilePath, updatedContent);
-                assetContent = updatedContent;
-            }
-            // 2. Persist encoding_salience to state.db.
-            try {
-                withStateDb((stateDb) => {
-                    const vector = computeSalience({
-                        ref: inputRef,
-                        type: parsedRef.type,
-                        retrievalFreq: 0,
-                        encodingSalience: salienceResult.score,
-                        outcomeWeightEnabled,
-                    });
-                    upsertAssetSalience(stateDb, salienceWriteKey, vector);
-                });
-            }
-            catch {
-                // State DB unavailable — frontmatter mirror is the only persistence.
-            }
-        }
-        catch {
-            // Scoring errors never block distillation.
-        }
-    }
-    return { assetContent, existingRefVocabulary };
+// ── Invocation ───────────────────────────────────────────────────────────────
+const DISABLED_MESSAGE = "distill is disabled in config; enable processes.distill.enabled to activate.";
+function emitDistill(run, meta) {
+    appendEvent({ eventType: "distill_invoked", ref: run.ledgerRef, metadata: { ...meta, ...run.eligMeta } }, run.options.eventsCtx);
 }
-/**
- * Recursive-distillation + secret-material input guard. Distill produces
- * *lessons* from non-lesson sources; a lesson input would derive a recursive
- * `lessons/lesson-<name>` ref (the 323-archived-proposals defect) and
- * env/secret inputs must never be read or sent to the LLM. Emits the
- * `distill_invoked(skipped)` event and returns the terminal skipped result,
- * or `null` when the input type is allowed. Extracted verbatim from
- * `akmDistill` (R25/R31 — the events-ctx threading pushed it over the bar).
- */
-function refuseDisallowedDistillInput(args) {
-    const { options, parsedInputRef, inputRef, durableInputRef, eligMeta } = args;
-    if (!isDistillRefusedInputType(parsedInputRef.type))
-        return null;
-    // 08-F2: env/secret are a secret-material refusal (never read the bytes);
-    // lesson is the recursive-form refusal. Both skip BEFORE any readFileSync.
-    const isSecretInput = parsedInputRef.type === "env" || parsedInputRef.type === "secret";
-    const skippedRef = isSecretInput ? inputRef : conceptIdFromTypeName("lesson", parsedInputRef.name);
-    const message = isSecretInput
-        ? `Distill refuses ${parsedInputRef.type} inputs — secret material must never be sent to the LLM.`
-        : "Distill refuses lesson inputs — lessons are the distilled form, not a source.";
-    appendEvent({
-        eventType: "distill_invoked",
-        // Key on item_ref when the planner resolved one, otherwise the conceptId.
-        ref: options.itemRef ?? durableInputRef,
-        metadata: {
-            outcome: "skipped",
-            proposalRef: skippedRef,
-            message,
-            skipReason: isSecretInput ? "refused_secret_input" : "recursive_lesson_input",
-            ...eligMeta,
-        },
-    }, options.eventsCtx);
-    return {
-        schemaVersion: 1,
-        ok: true,
-        outcome: "skipped",
-        inputRef,
-        proposalRef: skippedRef,
-        skipReason: isSecretInput ? "refused_secret_input" : "recursive_lesson_input",
-        message,
-    };
-}
-async function prepareDistillExecution(args) {
-    const { options, config, inputRef, durableInputRef, salienceWriteKey } = args;
-    const stash = resolveRunStashDir(options.stashDir);
-    const chat = options.chat;
-    const executionNotices = new Map();
-    const collectNotices = (notices) => {
-        for (const notice of notices)
-            executionNotices.set(JSON.stringify(notice), notice);
-    };
-    const resolvedExecution = !Object.hasOwn(options, "llmRunner")
-        ? resolveImproveLlmExecution({
-            config,
-            profile: options.improveProfile,
-            process: getImproveProcessConfig("distill", options.improveProfile),
-            processName: "distill",
-        })
-        : null;
-    if (resolvedExecution)
-        collectNotices(resolvedExecution.notices);
-    const distillRunner = Object.hasOwn(options, "llmRunner")
-        ? (options.llmRunner ?? undefined)
-        : resolvedExecution?.runner;
-    const withNotices = (result) => executionNotices.size > 0 ? { ...result, notices: Object.freeze([...executionNotices.values()]) } : result;
-    const lookup = options.lookupFn ?? ((ref) => defaultLookup(ref, stash));
-    const readEventsImpl = options.readEventsFn ??
-        ((readOptions) => readEvents(readOptions, { readOnly: true }));
-    const outcomeWeightEnabled = config.improve?.salience?.outcomeWeightEnabled !== false;
-    const fetchSimilarLessonsFn = options.fetchSimilarLessonsFn ?? ((query, n) => fetchTopSimilarLessons(query, n, options.stashDir));
-    const assetCtx = createRunContext({
-        stashDir: stash,
-        config,
-        eventsCtx: options.eventsCtx ?? {},
-        proposalsCtx: options.ctx ?? {},
-        chat,
-        getLlmRunner: () => distillRunner ?? null,
-        sourceRun: options.sourceRun ?? `distill-${Date.now()}`,
-        dryRun: false,
-        signal: options.signal,
-    }).withFreshAssetMemo();
-    const initialSalience = await loadAndScoreInputSalience({
-        inputRef,
-        durableInputRef,
-        salienceWriteKey,
-        stash,
-        config,
-        outcomeWeightEnabled,
-        lookup,
-        ctx: assetCtx,
-        persistSalience: false,
-    });
-    const assetState = { ...initialSalience };
-    const persistInputSalience = async () => {
-        const scored = await loadAndScoreInputSalience({
-            inputRef,
-            durableInputRef,
-            salienceWriteKey,
-            stash,
-            config,
-            outcomeWeightEnabled,
-            lookup,
-            ctx: assetCtx,
-        });
-        assetState.assetContent = scored.assetContent ?? assetState.assetContent;
-        assetState.existingRefVocabulary = scored.existingRefVocabulary;
-    };
-    const feedbackState = readDistillFeedback({ readEventsImpl, options, durableInputRef });
-    const feedback = feedbackState.filteredEvents.slice(-20).map((event) => ({
-        ts: event.ts,
-        eventType: event.eventType,
-        ...(event.metadata !== undefined ? { metadata: event.metadata } : {}),
-    }));
-    return {
-        stash,
-        chat,
-        collectNotices,
-        distillRunner,
-        withNotices,
-        lookup,
-        outcomeWeightEnabled,
-        fetchSimilarLessonsFn,
-        assetState,
-        persistInputSalience,
-        feedback,
-        ...feedbackState,
-    };
+/** The exclusion diagnostics for an event (count only) or a result (count + fully-filtered). */
+function exclusionMeta(run, forResult) {
+    if (!run.exclusion)
+        return {};
+    return forResult ? { ...run.exclusion } : { filteredFeedbackCount: run.exclusion.filteredFeedbackCount };
 }
 export async function akmDistill(options) {
     const inputRef = options.ref.trim();
     if (!inputRef) {
         throw new UsageError("Asset ref is required. Usage: akm distill <ref>", "MISSING_REQUIRED_ARGUMENT");
     }
-    // Validate the ref shape up front so a typo never reaches the LLM.
     const parsedInputRef = parseRefInput(inputRef);
-    const durableInputRef = durableImproveRef(inputRef);
-    // The input asset's durable salience write key is item_ref when resolved,
-    // otherwise the input conceptId.
-    const salienceWriteKey = options.itemRef ?? durableInputRef;
-    const targetKind = options.proposalKind ?? "lesson";
     const config = options.config ?? loadConfig();
-    const improveProfile = options.improveProfile ?? resolveImproveStrategy(undefined, config).config;
-    options = { ...options, improveProfile };
-    if (!resolveProcessEnabled("distill", improveProfile)) {
-        const proposalKind = targetKind === "knowledge" ? "knowledge" : "lesson";
+    const profile = options.improveProfile ?? resolveImproveStrategy(undefined, config).config;
+    options = { ...options, improveProfile: profile };
+    const targetKind = options.proposalKind ?? "lesson";
+    const kind = targetKind === "knowledge" ? "knowledge" : "lesson";
+    const outputRef = kind === "knowledge" ? deriveKnowledgeRef(inputRef) : deriveLessonRef(inputRef);
+    if (!resolveProcessEnabled("distill", profile)) {
         return {
             schemaVersion: 1,
             ok: true,
             outcome: "config_disabled",
             inputRef,
-            proposalRef: proposalKind === "knowledge" ? deriveKnowledgeRef(inputRef) : deriveLessonRef(inputRef),
-            proposalKind,
-            message: "distill is disabled in config; enable processes.distill.enabled to activate.",
+            proposalRef: outputRef,
+            proposalKind: kind,
+            message: DISABLED_MESSAGE,
         };
     }
-    // Attribution tagging: spread into every distill_invoked event's metadata so
-    // the lane that selected this asset is recorded uniformly across all outcome
-    // branches. Empty object when no lane was supplied (direct `akm distill`).
-    const eligMeta = options.eligibilitySource
-        ? { eligibilitySource: options.eligibilitySource }
-        : {};
-    // Recursive-distillation guard (see refuseDisallowedDistillInput). The
-    // refused-type set is exported as {@link DISTILL_REFUSED_INPUT_TYPES} so
-    // the improve planner can skip these refs before queuing distill attempts;
-    // this runtime check stays as a defensive backstop for direct callers.
-    const refused = refuseDisallowedDistillInput({ options, parsedInputRef, inputRef, durableInputRef, eligMeta });
-    if (refused)
-        return refused;
-    const prepared = await prepareDistillExecution({
+    const ledgerRef = options.itemRef ?? inputRef;
+    const eligMeta = options.eligibilitySource ? { eligibilitySource: options.eligibilitySource } : {};
+    if (isDistillRefusedInputType(parsedInputRef.type)) {
+        const secret = parsedInputRef.type === "env" || parsedInputRef.type === "secret";
+        const proposalRef = secret ? inputRef : conceptIdFromTypeName("lesson", parsedInputRef.name);
+        const skipReason = secret ? "refused_secret_input" : "recursive_lesson_input";
+        const message = secret
+            ? `Distill refuses ${parsedInputRef.type} inputs — secret material must never be sent to the LLM.`
+            : "Distill refuses lesson inputs — lessons are the distilled form, not a source.";
+        emitDistill({ ledgerRef, eligMeta, options }, { outcome: "skipped", proposalRef, message, skipReason });
+        return { schemaVersion: 1, ok: true, outcome: "skipped", inputRef, proposalRef, skipReason, message };
+    }
+    const stash = options.stashDir ?? resolveStashDir();
+    const notices = noticeSet();
+    const lookup = options.lookupFn ?? ((ref) => defaultLookup(ref, stash));
+    const asset = await loadInput(lookup, inputRef);
+    const run = {
         options,
-        config,
         inputRef,
-        durableInputRef,
-        salienceWriteKey,
-    });
-    const { stash, chat, collectNotices, distillRunner, withNotices, lookup, outcomeWeightEnabled, fetchSimilarLessonsFn, assetState, persistInputSalience, feedback, filteredEvents, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered, } = prepared;
-    const promotionContext = {
-        targetKind,
-        inputRef,
-        durableInputRef,
-        ...(options.itemRef ? { itemRef: options.itemRef } : {}),
-        assetContent: assetState.assetContent,
-        filteredEvents,
-        config,
-        strategy: options.improveProfile,
-        llmRunner: distillRunner,
-        signal: options.signal,
-        chat,
+        ledgerRef,
         stash,
-        lookup,
-        fetchSimilarLessonsFn,
-        existingRefVocabulary: assetState.existingRefVocabulary,
-        outcomeWeightEnabled,
+        config,
+        profile,
+        runner: stageRunner(options, config, profile, "distill", notices.add),
+        notices,
         eligMeta,
-        eligibilitySource: options.eligibilitySource,
-        sourceRun: options.sourceRun,
-        proposalsCtx: options.ctx,
-        eventsCtx: options.eventsCtx,
-        exclusionSetSize: exclusionSet.size,
-        filteredFeedbackCount,
-        feedbackFullyFiltered,
-        onNotices: collectNotices,
+        asset,
+        vocabulary: loadRefVocabulary(),
+        outcomeWeightEnabled: config.improve?.salience?.outcomeWeightEnabled !== false,
+        similar: options.fetchSimilarLessonsFn ?? fetchTopSimilarLessons,
+        lookup,
     };
-    const promotionPlan = await planMemoryKnowledgePromotion(promotionContext);
-    let dispatchLease;
-    try {
-        // Memory→knowledge promotion branch (D-1/#369). When the target ref is a
-        // reinforced memory, distill graduates it into a knowledge proposal instead
-        // of a lesson — the whole branch (LLM contradiction-merge, quality gate,
-        // proposal creation, event emit) lives in `promoteMemoryToKnowledge` and is
-        // terminal when it fires. A `null` return means "not a promotion candidate";
-        // fall through to the ordinary lesson/knowledge distillation path.
-        if (promotionPlan && distillRunner && memoryKnowledgePromotionRequiresDispatch(promotionContext, promotionPlan)) {
-            dispatchLease = await preflightStructuredLlmRunner(distillRunner);
-        }
-        const promotionResult = await promoteMemoryToKnowledge({ ...promotionContext, ...(dispatchLease ? { lease: dispatchLease } : {}) }, promotionPlan);
-        if (promotionResult) {
-            await persistInputSalience();
-            return withNotices(promotionResult);
-        }
-        const effectiveProposalKind = targetKind === "knowledge" ? "knowledge" : "lesson";
-        const effectiveLessonRef = effectiveProposalKind === "knowledge" ? deriveKnowledgeRef(inputRef) : deriveLessonRef(inputRef);
-        const messages = await buildDistillMessages({
-            options,
-            stash,
-            inputRef,
-            assetContent: assetState.assetContent,
-            feedback,
-            effectiveProposalKind,
-            effectiveLessonRef,
-            fetchSimilarLessonsFn,
-        });
-        if (!dispatchLease && distillRunner)
-            dispatchLease = await preflightStructuredLlmRunner(distillRunner);
-        const { raw, fallbackReason } = await runDistillLlmCall({
-            config,
-            options,
-            distillRunner,
-            lease: dispatchLease,
-            messages,
-            effectiveProposalKind,
-            onNotices: collectNotices,
-        });
-        await persistInputSalience();
-        if (raw === null || raw.trim() === "") {
-            return withNotices(distillEmptyResponseResult({
-                fallbackReason,
-                inputRef,
-                durableInputRef,
-                ...(options.itemRef ? { itemRef: options.itemRef } : {}),
-                effectiveLessonRef,
-                effectiveProposalKind,
-                exclusionSet,
-                filteredFeedbackCount,
-                feedbackFullyFiltered,
-                eligMeta,
-                eventsCtx: options.eventsCtx,
-            }));
-        }
-        const assembled = assembleAndValidateDistillContent({
-            raw,
-            effectiveProposalKind,
-            inputRef,
-            durableInputRef,
-            ...(options.itemRef ? { itemRef: options.itemRef } : {}),
-            effectiveLessonRef,
-            exclusionSet,
-            filteredFeedbackCount,
-            eligMeta,
-            eventsCtx: options.eventsCtx,
-            stash,
-        });
-        if ("rejection" in assembled)
-            return withNotices(assembled.rejection);
-        const { content, descriptionSwapped } = assembled;
-        const gate = await applyDistillQualityGate({
-            config,
-            options,
-            content,
-            assetContent: assetState.assetContent,
-            chat,
-            distillRunner,
-            lease: dispatchLease,
-            fetchSimilarLessonsFn,
-            stash,
-            inputRef,
-            effectiveLessonRef,
-            exclusionSet,
-            filteredFeedbackCount,
-            feedbackFullyFiltered,
-            onNotices: collectNotices,
-        });
-        if ("rejection" in gate)
-            return withNotices(gate.rejection);
-        const lessonJudgeConfidence = gate.confidence;
-        return withNotices(await emitDistillLessonProposal({
-            content,
-            options,
-            distillRunner,
-            assetContent: assetState.assetContent,
-            inputRef,
-            durableInputRef,
-            effectiveLessonRef,
-            effectiveProposalKind,
-            stash,
-            exclusionSet,
-            filteredFeedbackCount,
-            feedbackFullyFiltered,
-            lessonJudgeConfidence,
-            existingRefVocabulary: assetState.existingRefVocabulary,
-            outcomeWeightEnabled,
-            descriptionSwapped,
-            eligMeta,
-        }));
-    }
-    finally {
-        if (dispatchLease)
-            disposeLoweredExecutionDispatchLease(dispatchLease);
-    }
+    const feedbackEvents = readDistillFeedback(run);
+    const result = await distill(run, targetKind, kind, outputRef, feedbackEvents);
+    return { ...result, ...notices.fields() };
 }
-// ── Helpers ─────────────────────────────────────────────────────────────────
-/**
- * The distill-propose pass: the optional WS-3b distill→source fidelity check
- * (routes contradictions to human review), provenance xref round-trip, proposal
- * creation, and the queued/skipped `distill_invoked` emit + output salience
- * scoring (G4). Extracted verbatim from `akmDistill`; every outcome shape and
- * event is byte-identical.
- */
-async function emitDistillLessonProposal(args) {
-    const { options, distillRunner, assetContent, inputRef, durableInputRef, effectiveLessonRef, effectiveProposalKind, stash, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered, lessonJudgeConfidence, existingRefVocabulary, outcomeWeightEnabled, descriptionSwapped, eligMeta, } = args;
-    let content = args.content;
-    // WS-3b: Distill→source fidelity check (step 10).
-    // When fidelityCheck.enabled, check the distill proposal against its cited
-    // source memories. A contradiction flag routes to human review (not auto-accept).
-    // DEFAULT OFF. Fail-open: any error is treated as no-contradiction.
-    const fidelityConfig = getImproveProcessConfig("distill", options.improveProfile)?.fidelityCheck ??
-        {};
-    if (fidelityConfig.enabled && assetContent) {
-        try {
-            const proposalBody = stripBodyForFidelity(content);
-            const sourceBodies = [stripBodyForFidelity(assetContent)];
-            const fidelityResult = checkDistillFidelity(proposalBody, sourceBodies, fidelityConfig);
-            if (fidelityResult.contradictionDetected) {
-                // Route to human review by writing a quality rejection with reviewNeeded=true.
-                return writeQualityRejection(stash, inputRef, effectiveLessonRef, content, 2.0, // below auto-accept threshold, signals review needed
-                fidelityResult.reason ?? "Proposal may contradict cited source memories.", {
-                    reviewNeeded: true,
-                    fidelityContradiction: true,
-                    ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-                }, options.eligibilitySource, options.eventsCtx);
-            }
-        }
-        catch {
-            // Fail open — fidelity check is supplemental.
-        }
-    }
-    // Round-trip the parsed frontmatter so the proposal carries it as a
-    // structured payload alongside the raw content (matches the shape used by
-    // other proposal sources).
-    //
-    // Serialize canonical provenance into the content that promotion writes.
-    const parsed = parseFrontmatter(content);
-    const existingXrefs = Array.isArray(parsed.data.xrefs) ? parsed.data.xrefs.map(String) : [];
-    const frontmatterWithXrefs = {
-        ...parsed.data,
-        xrefs: [...new Set([...existingXrefs, durableInputRef])],
-    };
-    delete frontmatterWithXrefs.sources;
-    content = assembleAsset(frontmatterWithXrefs, parsed.content);
-    const proposalResult2 = emitProposal({ stashDir: stash, proposalsCtx: options.ctx }, {
-        ref: effectiveLessonRef,
-        // §23.6 fingerprint model-id term (WI-6.4). Uses the RESOLVED connection
-        // (profile/config fallback included), not the raw option — a standalone
-        // `akm distill` run must fingerprint under the model that actually
-        // generated the content, matching the promote-memory branch.
-        ...(distillRunner?.connection.model ? { modelId: distillRunner.connection.model } : {}),
-        source: "distill",
-        ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
-        payload: {
-            content,
-            frontmatter: frontmatterWithXrefs,
-        },
-        ...(lessonJudgeConfidence !== undefined ? { confidence: lessonJudgeConfidence } : {}),
-        // Attribution tagging: persist the eligibility lane on the proposal.
-        ...(options.eligibilitySource ? { eligibilitySource: options.eligibilitySource } : {}),
-    });
-    if (isProposalSkipped(proposalResult2)) {
-        appendEvent({
-            eventType: "distill_invoked",
-            // Use item_ref when resolved, otherwise the input conceptId.
-            ref: options.itemRef ?? durableInputRef,
-            metadata: {
-                outcome: "skipped",
-                proposalRef: effectiveLessonRef,
-                message: proposalResult2.message,
-                skipReason: proposalResult2.reason,
-                ...eligMeta,
+async function distill(run, targetKind, kind, outputRef, feedbackEvents) {
+    // A reinforced memory graduates to knowledge without a generation call.
+    const promotion = targetKind === "lesson" ? null : await planPromotion(run, feedbackEvents);
+    if (promotion) {
+        if (run.runner && (promotion.existing || qualityGateEnabled(run)))
+            assertRunnerCredentials(run.runner);
+        const promoted = await promoteToKnowledge(run, promotion);
+        stampInputSalience(run);
+        return promoted;
+    }
+    const feedback = feedbackEvents.slice(-20).map((event) => ({
+        ts: event.ts,
+        eventType: event.eventType,
+        ...(event.metadata !== undefined ? { metadata: event.metadata } : {}),
+    }));
+    const { system, prompt } = await buildDistillMessages(run, feedback, kind, outputRef);
+    const call = run.runner
+        ? await callStage({
+            feature: "distill",
+            runner: run.runner,
+            system,
+            prompt,
+            gate: { config: run.config, enabled: true },
+            // The injected test transport never sees the schema.
+            request: {
+                ...(run.options.chat === undefined
+                    ? { responseSchema: kind === "knowledge" ? DISTILL_KNOWLEDGE_JSON_SCHEMA : DISTILL_LESSON_JSON_SCHEMA }
+                    : { chat: run.options.chat }),
+                ...(run.options.signal ? { signal: run.options.signal } : {}),
             },
-        }, options.eventsCtx);
+            onNotices: run.notices.add,
+        })
+        : { ok: false, reason: "error" };
+    // Durable input salience waits until the credential-bearing dispatch returned.
+    stampInputSalience(run);
+    if (!call.ok || call.raw.trim() === "") {
+        if (!call.ok)
+            warnVerbose(`[akm] LLM fallback for distill: ${call.reason}`);
+        emitDistill(run, {
+            outcome: "llm_failed",
+            proposalRef: outputRef,
+            proposalKind: kind,
+            ...exclusionMeta(run, false),
+        });
         return {
             schemaVersion: 1,
             ok: true,
-            outcome: "skipped",
-            inputRef,
-            proposalRef: effectiveLessonRef,
-            skipReason: proposalResult2.reason,
-            message: proposalResult2.message,
+            outcome: "llm_failed",
+            inputRef: run.inputRef,
+            proposalRef: outputRef,
+            proposalKind: kind,
+            message: "LLM call returned no usable output (timeout, empty, or error).",
+            ...exclusionMeta(run, true),
         };
     }
-    const proposal2 = proposalResult2;
-    // G4: content-score the distilled OUTPUT so it carries a real encoding
-    // salience (encoding_source='content') from creation — lessons never get
-    // another chance (they are refused as distill inputs).
-    persistOutputEncodingSalience(durableImproveRef(effectiveLessonRef), content, existingRefVocabulary, outcomeWeightEnabled);
-    appendEvent({
-        eventType: "distill_invoked",
-        // Use item_ref when resolved, otherwise the input conceptId.
-        ref: options.itemRef ?? durableInputRef,
-        metadata: {
-            outcome: "queued",
-            proposalRef: effectiveLessonRef,
-            proposalKind: effectiveProposalKind,
-            proposalId: proposal2.id,
-            // R3: judge verdicts are longitudinally queryable, not just a one-shot
-            // proposal.confidence write (normalized 1–5 score / 5).
-            ...(lessonJudgeConfidence !== undefined ? { judgeConfidence: lessonJudgeConfidence } : {}),
-            ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
-            ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
-            ...(descriptionSwapped > 0 ? { descriptionSwapped } : {}),
-            ...eligMeta,
-        },
-    }, options.eventsCtx);
-    return {
-        schemaVersion: 1,
-        ok: true,
-        outcome: "queued",
-        inputRef,
-        proposalRef: effectiveLessonRef,
-        proposalKind: effectiveProposalKind,
-        proposalId: proposal2.id,
-        proposal: proposal2,
-        ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-        ...(descriptionSwapped > 0 ? { descriptionSwapped } : {}),
-    };
+    const assembled = assembleDistilledContent(run, call.raw, kind, outputRef);
+    if ("rejection" in assembled)
+        return assembled.rejection;
+    return judgeAndQueue(run, {
+        ref: outputRef,
+        kind,
+        content: assembled.content,
+        source: run.asset.content,
+        descriptionSwapped: assembled.descriptionSwapped,
+    });
 }
-/**
- * Turn the raw LLM response into validated proposal content: prefer the
- * structured-JSON assembly, else strip markdown fences; run the lesson-only
- * auto-repair chain (frontmatter repair, description↔when_to_use swap, truncation
- * repair); then lint/validate, emitting `distill_invoked(validation_failed)` and
- * 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;
-    // 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
-    // response path. Failure here (non-JSON response, missing
-    // required field, unexpected types) is non-fatal — we drop down to the
-    // markdown path which has its own auto-repair + lint pass.
-    let content;
-    const structuredCandidate = parseEmbeddedJsonResponse(raw);
-    const structuredAssembled = structuredCandidate && !Array.isArray(structuredCandidate)
-        ? assembleStructuredDistillMarkdown(structuredCandidate, effectiveProposalKind)
-        : null;
-    if (structuredAssembled !== null) {
-        content = structuredAssembled;
-    }
-    else {
-        // Strip any stray fence the LLM might have added around the markdown.
-        content = stripMarkdownFences(raw);
-    }
-    // Lesson-path content normalization (see distill/content-repair): auto-repair
-    // missing frontmatter, description↔when_to_use auto-swap, and truncation
-    // repair. Knowledge output skips all three (no lesson frontmatter contract).
-    if (effectiveProposalKind !== "knowledge") {
-        content = autoRepairLessonFrontmatter(content, inputRef);
-    }
+/** Turn the response into validated content: structured JSON or markdown, then lesson repairs and lint. */
+function assembleDistilledContent(run, raw, kind, outputRef) {
+    const structured = parseEmbeddedJsonResponse(raw);
+    let content = (structured && !Array.isArray(structured) ? assembleStructuredDistillMarkdown(structured, kind) : null) ??
+        stripMarkdownFences(raw);
     let descriptionSwapped = 0;
-    if (effectiveProposalKind !== "knowledge") {
-        const swapResult = autoSwapDescriptionWhenToUse(content, inputRef);
-        content = swapResult.content;
-        descriptionSwapped = swapResult.swapped;
-    }
-    if (effectiveProposalKind !== "knowledge") {
+    if (kind === "lesson") {
+        content = autoRepairLessonFrontmatter(content, run.inputRef);
+        ({ content, swapped: descriptionSwapped } = autoSwapDescriptionWhenToUse(content, run.inputRef));
         content = repairLessonDescriptionTruncation(content);
     }
-    // Parse + lint the lesson before creating the proposal. The lint is the
-    // canonical gate for required frontmatter (v1 spec §13): a field that is
-    // genuinely missing or empty means there is no valid asset to write, so
-    // that failure stays a hard reject — but still emit `distill_invoked` so
-    // the failure is observable.
-    const structuralFindings = effectiveProposalKind === "knowledge"
-        ? validateKnowledgeContent(content, inputRef)
-        : lintLessonContent(content, `distill:${inputRef}`).findings;
-    // Additional lesson-only quality validators — reject the systematic failure
-    // modes seen across 323 archived rejected proposals (see distill/content-repair).
-    const qualityFindings = effectiveProposalKind !== "knowledge" && structuralFindings.length === 0
-        ? collectLessonQualityFindings(content, inputRef)
-        : [];
-    if (structuralFindings.length > 0) {
-        appendEvent({
-            eventType: "distill_invoked",
-            // Use item_ref when resolved, otherwise the input conceptId.
-            ref: itemRef ?? durableInputRef,
-            metadata: {
-                outcome: "validation_failed",
-                proposalRef: effectiveLessonRef,
-                proposalKind: effectiveProposalKind,
-                findingKinds: structuralFindings.map((f) => f.kind),
-                ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
-                ...eligMeta,
-            },
-        }, eventsCtx);
-        const message = structuralFindings.map((f) => f.message).join("\n");
-        throw new UsageError(`Distilled ${effectiveProposalKind} failed validation:\n${message}`, "MISSING_REQUIRED_ARGUMENT", effectiveProposalKind === "knowledge"
+    // Required structure missing means there is no asset to write: a hard reject.
+    const structural = kind === "knowledge"
+        ? validateKnowledgeContent(content, run.inputRef)
+        : lintLessonContent(content, `distill:${run.inputRef}`).findings;
+    if (structural.length > 0) {
+        emitDistill(run, {
+            outcome: "validation_failed",
+            proposalRef: outputRef,
+            proposalKind: kind,
+            findingKinds: structural.map((f) => f.kind),
+            ...exclusionMeta(run, false),
+        });
+        throw new UsageError(`Distilled ${kind} failed validation:\n${structural.map((f) => f.message).join("\n")}`, "MISSING_REQUIRED_ARGUMENT", kind === "knowledge"
             ? "Knowledge proposals require a non-empty markdown body."
             : "Lessons require non-empty `description` and `when_to_use` frontmatter fields. See v1 spec §13.");
     }
-    if (qualityFindings.length > 0) {
+    // Heuristic quality findings go to a human, not the bin.
+    const quality = kind === "lesson" ? collectLessonQualityFindings(content, run.inputRef) : [];
+    if (quality.length > 0) {
         return {
-            rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, 2.0, // below auto-accept threshold, signals review needed — no judge score exists for a structural/heuristic finding
-            qualityFindings.map((f) => f.message).join("\n"), {
+            rejection: rejectDistilled(run, outputRef, content, 2.0, quality.map((f) => f.message).join("\n"), {
                 reviewNeeded: true,
-                proposalKind: effectiveProposalKind,
-                findingKinds: qualityFindings.map((f) => f.kind),
-                ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
-            }, eligMeta.eligibilitySource, eventsCtx),
+                proposalKind: kind,
+                findingKinds: quality.map((f) => f.kind),
+            }),
         };
     }
     return { content, descriptionSwapped };
 }
+function qualityGateEnabled(run) {
+    return run.profile.processes?.distill?.qualityGate?.enabled ?? true;
+}
 /**
- * The single bounded distill LLM call: gate-checked via `callStructured`
- * (R26 migration off the raw `chatCompletion` scaffold), passing the
- * lesson/knowledge JSON schema on the production path and keeping the
- * injected test fake schema-blind. Returns the raw response (or `null`) and
- * the fallback reason.
+ * Judge the distilled content, then queue it. A rejected, uncertain or
+ * source-contradicting result is recorded instead (see {@link writeQualityRejection}).
  */
-async function runDistillLlmCall(args) {
-    const { config, options, distillRunner, lease, messages, effectiveProposalKind, onNotices } = args;
-    const distillSchema = effectiveProposalKind === "knowledge" ? DISTILL_KNOWLEDGE_JSON_SCHEMA : DISTILL_LESSON_JSON_SCHEMA;
-    let fallbackReason;
-    const enabled = resolveProcessEnabled("distill", options.improveProfile ?? resolveImproveStrategy(undefined, config).config);
-    const recordFallback = (feature, reason) => {
-        fallbackReason = reason;
-        // Log the fallback reason; the caller (raw === null path) handles
-        // emitting the distill_invoked event so we don't double-emit here.
-        warnVerbose(`[akm] LLM fallback for ${feature}: ${reason}`);
-    };
-    if (enabled && !distillRunner) {
-        // No LLM connection configured. At HEAD this threw a ConfigError inside
-        // the gated fn and tryLlmFeature routed it through the "error" fallback;
-        // reproduce that terminal state directly (the gate-disabled case above
-        // still dominates: when disabled, callStructured takes the "disabled"
-        // fallback before any LLM lookup, exactly as before).
-        recordFallback("distill", "error");
-        return { raw: null, fallbackReason };
+async function judgeAndQueue(run, out) {
+    let content = out.content;
+    let confidence;
+    if (qualityGateEnabled(run)) {
+        const similarLessons = await run.similar(content.slice(0, 500), 3);
+        const verdict = await runLessonQualityJudge(run.config, content, out.source ?? "", run.options.chat, {
+            ...(similarLessons.length > 0 ? { similarLessons } : {}),
+            ...(run.runner ? { llmRunner: run.runner } : {}),
+            ...(run.options.signal ? { signal: run.options.signal } : {}),
+            onNotices: run.notices.add,
+        });
+        if (!verdict.pass) {
+            return rejectDistilled(run, out.ref, content, verdict.score, verdict.reason, {
+                ...(verdict.reviewNeeded ? { reviewNeeded: true } : {}),
+                ...(verdict.criteria ? { criteria: verdict.criteria } : {}),
+            });
+        }
+        if (verdict.score > 0)
+            confidence = verdict.score / 5;
+    }
+    let frontmatter;
+    if (out.promotion) {
+        const data = parseFrontmatter(content).data;
+        if (Object.keys(data).length > 0)
+            frontmatter = data;
     }
-    const raw = await callStructured({
-        feature: "distill",
-        akmConfig: config,
-        enabled,
-        // Safe: when the gate is open, distillRunner is defined (guard above); when
-        // it is closed, the transport never runs and the runner is never read.
-        runner: distillRunner,
-        ...(lease ? { lease } : {}),
-        messages,
-        request: options.chat === undefined
-            ? // Production path: pass the JSON schema so providers that honour
-                // `response_format: json_schema` enforce shape upstream. Providers
-                // that ignore the option fall through to the prompt-contract
-                // markdown path.
-                {
-                    responseSchema: distillSchema,
-                    ...(options.signal ? { signal: options.signal } : {}),
+    else {
+        // Optional check against the cited source; a contradiction goes to a human.
+        const fidelity = getImproveProcessConfig("distill", run.profile)?.fidelityCheck ?? {};
+        if (fidelity.enabled && out.source) {
+            try {
+                const verdict = checkDistillFidelity(stripFrontmatterBody(content), [stripFrontmatterBody(out.source)], fidelity);
+                if (verdict.contradictionDetected) {
+                    return rejectDistilled(run, out.ref, content, 2.0, verdict.reason ?? "Proposal may contradict cited source memories.", { reviewNeeded: true, fidelityContradiction: true });
                 }
-            : // Test seam: keep the injected fake as the transport; fakes never
-                // see the schema (they return markdown strings).
-                { chat: options.chat, ...(options.signal ? { signal: options.signal } : {}) },
-        parse: (raw) => raw ?? null,
-        onError: (_cls, err) => {
-            // At HEAD a transport throw escaped to tryLlmFeature's catch, which
-            // fired onFallback("error"); reproduce that observable state.
-            void err;
-            recordFallback("distill", "error");
-            return null;
-        },
-        fallback: null,
-        onFallback: (evt) => recordFallback(evt.feature, evt.reason),
-        onNotices,
+            }
+            catch {
+                // The fidelity check is supplemental.
+            }
+        }
+        // Canonical provenance goes into the content promotion writes.
+        const parsed = parseFrontmatter(content);
+        const xrefs = Array.isArray(parsed.data.xrefs) ? parsed.data.xrefs.map(String) : [];
+        frontmatter = { ...parsed.data, xrefs: [...new Set([...xrefs, run.inputRef])] };
+        delete frontmatter.sources;
+        content = assembleAsset(frontmatter, parsed.content);
+    }
+    const proposal = mintProposal(run.stash, run.options.ctx, {
+        ref: out.ref,
+        source: "distill",
+        ...(run.options.sourceRun !== undefined ? { sourceRun: run.options.sourceRun } : {}),
+        payload: { content, ...(frontmatter ? { frontmatter } : {}) },
+        ...(confidence !== undefined ? { confidence } : {}),
+        ...(run.options.eligibilitySource ? { eligibilitySource: run.options.eligibilitySource } : {}),
+        // The ledger keys the attempt by the input, not the output.
+        attemptedRefs: [run.ledgerRef],
+    }, { judged: confidence !== undefined });
+    persistOutputEncodingSalience(run, out.ref, content);
+    const swapped = out.descriptionSwapped ? { descriptionSwapped: out.descriptionSwapped } : {};
+    emitDistill(run, {
+        outcome: "queued",
+        proposalRef: out.ref,
+        proposalKind: out.kind,
+        proposalId: proposal.id,
+        ...(confidence !== undefined ? { judgeConfidence: confidence } : {}),
+        ...(run.options.sourceRun !== undefined ? { sourceRun: run.options.sourceRun } : {}),
+        ...exclusionMeta(run, false),
+        ...swapped,
+    });
+    return {
+        schemaVersion: 1,
+        ok: true,
+        outcome: "queued",
+        inputRef: run.inputRef,
+        proposalRef: out.ref,
+        proposalKind: out.kind,
+        proposalId: proposal.id,
+        proposal,
+        ...exclusionMeta(run, true),
+        ...swapped,
+    };
+}
+function rejectDistilled(run, proposalRef, content, score, reason, meta) {
+    return writeQualityRejection({
+        stash: run.stash,
+        inputRef: run.inputRef,
+        proposalRef,
+        content,
+        score,
+        reason,
+        meta: { ...meta, ...exclusionMeta(run, true) },
+        eligibilitySource: run.options.eligibilitySource,
+        eventsCtx: run.options.eventsCtx,
+        proposalsCtx: run.options.ctx,
+        sourceRun: run.options.sourceRun,
+        ledgerRef: run.ledgerRef,
     });
-    return { raw, fallbackReason };
 }
 /**
- * Build the terminal result for an empty/failed distill LLM response,
- * distinguishing the config-gate-off branch (event suppressed) from a real
- * transport/timeout/empty failure (emits `distill_invoked(llm_failed)`).
- * Extracted verbatim from `akmDistill`.
+ * Record a distill quality-gate outcome and return its envelope.
+ * `quality_rejected` lands in the improve ledger under the input's key (its
+ * rejection window keeps selection from regenerating it); `review_needed`
+ * mints a pending proposal for a human, stamped `deferred`/`quality-gate` so
+ * the triage drain leaves it alone. Content the mint refuses still records
+ * the attempt.
  */
-function distillEmptyResponseResult(args) {
-    const { fallbackReason, inputRef, durableInputRef, itemRef, effectiveLessonRef, effectiveProposalKind, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered, eligMeta, eventsCtx, } = args;
-    // Distinguish "config gate disabled" from "LLM call failed". For the
-    // config-disabled branch, we ALSO suppress the `distill_invoked` event
-    // because no LLM work was actually invoked — emitting the event causes
-    // the planner to accumulate phantom invocations that drown out real
-    // signal.
-    if (fallbackReason === "disabled") {
-        return {
-            schemaVersion: 1,
-            ok: true,
-            outcome: "config_disabled",
-            inputRef,
-            proposalRef: effectiveLessonRef,
-            proposalKind: effectiveProposalKind,
-            message: "distill is disabled in config; enable processes.distill.enabled to activate.",
-            ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-        };
+export function writeQualityRejection(args) {
+    const meta = args.meta ?? {};
+    const outcome = meta.reviewNeeded ? "review_needed" : "quality_rejected";
+    const ledgerRef = args.ledgerRef ?? args.inputRef;
+    const access = { proposalsCtx: args.proposalsCtx, eventsCtx: args.eventsCtx };
+    const attempt = { stashDir: args.stash, ref: ledgerRef, source: "distill", detail: args.reason };
+    let proposal;
+    if (outcome === "quality_rejected") {
+        recordLedgerAttempt(access, { ...attempt, outcome: "quality_rejected" });
+    }
+    else {
+        try {
+            proposal = mintProposal(args.stash, args.proposalsCtx, {
+                ref: args.proposalRef,
+                source: "distill",
+                ...(args.sourceRun !== undefined ? { sourceRun: args.sourceRun } : {}),
+                payload: { content: args.content },
+                attemptedRefs: [ledgerRef],
+                ...(args.eligibilitySource ? { eligibilitySource: args.eligibilitySource } : {}),
+            }, { review: { reason: "quality-review", gate: "quality-gate" } });
+        }
+        catch (error) {
+            warn(`[akm] writeQualityRejection: failed to queue ${args.proposalRef} for review: ${error instanceof Error ? error.message : String(error)}`);
+            recordLedgerAttempt(access, { ...attempt, outcome: "review_needed" });
+        }
     }
-    // LLM was actually invoked but produced nothing usable (transport error,
-    // timeout, or empty/whitespace response). Emit the event so the failure
-    // is observable.
+    const eligMeta = args.eligibilitySource ? { eligibilitySource: args.eligibilitySource } : {};
     appendEvent({
         eventType: "distill_invoked",
-        // Use item_ref when resolved, otherwise the input conceptId.
-        ref: itemRef ?? durableInputRef,
+        ref: ledgerRef,
         metadata: {
-            outcome: "llm_failed",
-            proposalRef: effectiveLessonRef,
-            proposalKind: effectiveProposalKind,
-            ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
+            outcome,
+            proposalRef: args.proposalRef,
+            score: args.score,
+            reason: args.reason,
+            ...meta,
             ...eligMeta,
         },
-    }, eventsCtx);
+    }, args.eventsCtx);
     return {
         schemaVersion: 1,
         ok: true,
-        outcome: "llm_failed",
-        inputRef,
-        proposalRef: effectiveLessonRef,
-        proposalKind: effectiveProposalKind,
-        message: "LLM call returned no usable output (timeout, empty, or error).",
-        ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
+        outcome,
+        inputRef: args.inputRef,
+        proposalRef: args.proposalRef,
+        score: args.score,
+        reason: args.reason,
+        ...(proposal ? { proposalId: proposal.id, proposal } : {}),
+        ...meta,
     };
 }
+async function planPromotion(run, feedbackEvents) {
+    const assessment = assessMemoryKnowledgePromotionCandidate({
+        inputRef: run.inputRef,
+        assetContent: run.asset.content,
+        feedbackEvents,
+    });
+    if (!assessment.promote || !assessment.content)
+        return null;
+    const existingPath = await run.lookup(assessment.knowledgeRef);
+    let existing = null;
+    try {
+        if (existingPath && fs.existsSync(existingPath))
+            existing = fs.readFileSync(existingPath, "utf8");
+    }
+    catch {
+        existing = null;
+    }
+    return { knowledgeRef: assessment.knowledgeRef, content: assessment.content, existing };
+}
 /**
- * The P2-B LLM-as-judge quality gate (fail-CLOSED; D-5/#388 three-band). Returns
- * a terminal rejection result when the judge rejects (or routes to review), or
- * the normalized [0,1] confidence to carry onto the proposal. Extracted verbatim
- * from `akmDistill`.
+ * Promote a reinforced memory to knowledge. An existing destination is
+ * reconciled by the model (ADD/UPDATE swap content in, NOOP keeps what is
+ * there); without a model the existing content is appended for the reviewer.
  */
-async function applyDistillQualityGate(args) {
-    const { config, options, content, assetContent, chat, distillRunner, lease, fetchSimilarLessonsFn, stash, inputRef, effectiveLessonRef, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered, onNotices, } = args;
-    if (!(options.improveProfile?.processes?.distill?.qualityGate?.enabled ?? true)) {
-        return { confidence: undefined };
-    }
-    // D-4 / #390: retrieve top-3 similar lessons for dedup check in judge.
-    const similarLessons = await fetchSimilarLessonsFn(content.slice(0, 500), 3);
-    const judgeResult = await runLessonQualityJudge(config, content, assetContent ?? "", chat, {
-        ...(similarLessons.length > 0 ? { similarLessons } : {}),
-        ...(distillRunner ? { llmRunner: distillRunner } : {}),
-        ...(lease ? { lease } : {}),
-        ...(options.signal ? { signal: options.signal } : {}),
-        onNotices,
-    });
-    if (!judgeResult.pass) {
-        if (judgeResult.reviewNeeded) {
+async function promoteToKnowledge(run, plan) {
+    let content = plan.content;
+    if (plan.existing && run.runner) {
+        const merged = await callStage({
+            feature: "distill",
+            runner: run.runner,
+            system: "Return only valid JSON. No prose.",
+            prompt: [
+                "You are merging two versions of a knowledge document.",
+                "Existing content is already committed; new content comes from a memory distillation run.",
+                "Choose one of: ADD (combine both), UPDATE (replace existing with new), NOOP (keep existing unchanged).",
+                'Return ONLY valid JSON: {"action": "ADD"|"UPDATE"|"NOOP", "content": "<merged markdown if ADD/UPDATE, empty string if NOOP>"}',
+                "",
+                "## Existing knowledge content",
+                "```",
+                plan.existing.slice(0, 3000),
+                "```",
+                "",
+                "## New content from distillation",
+                "```",
+                plan.content.slice(0, 3000),
+                "```",
+            ].join("\n"),
+            request: {
+                ...(run.options.signal ? { signal: run.options.signal } : {}),
+                ...(run.options.chat ? { chat: run.options.chat } : {}),
+            },
+            onNotices: run.notices.add,
+        });
+        const decision = merged.ok
+            ? parseEmbeddedJsonResponse(merged.raw)
+            : undefined;
+        if (decision?.action === "NOOP") {
+            emitDistill(run, {
+                outcome: "skipped",
+                proposalRef: plan.knowledgeRef,
+                message: "D-1: LLM resolved destination conflict as NOOP — existing content kept",
+            });
             return {
-                rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {
-                    reviewNeeded: true,
-                    ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-                }, options.eligibilitySource, options.eventsCtx),
+                schemaVersion: 1,
+                ok: true,
+                outcome: "skipped",
+                inputRef: run.inputRef,
+                proposalRef: plan.knowledgeRef,
+                skipReason: "conflict_noop",
+                message: "Existing knowledge content unchanged (contradiction resolution: NOOP)",
             };
         }
-        return {
-            rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}, options.eligibilitySource, options.eventsCtx),
-        };
+        if ((decision?.action === "ADD" || decision?.action === "UPDATE") && decision.content?.trim()) {
+            content = decision.content;
+        }
+    }
+    else if (plan.existing) {
+        content = [
+            plan.content,
+            "",
+            "---",
+            "<!-- D-1 / #369: Existing knowledge content is shown below for reviewer reference. -->",
+            "<!-- Review: decide whether to ADD (merge), UPDATE (replace), or NOOP (keep existing). -->",
+            "",
+            "## Existing content (for reviewer reference)",
+            "",
+            plan.existing,
+        ].join("\n");
+    }
+    return judgeAndQueue(run, {
+        ref: plan.knowledgeRef,
+        kind: "knowledge",
+        content,
+        source: run.asset.content,
+        promotion: true,
+    });
+}
+// ── Inputs ───────────────────────────────────────────────────────────────────
+/** Read the input asset (best-effort: an unindexed asset distils from feedback alone). */
+async function loadInput(lookup, inputRef) {
+    try {
+        const filePath = await lookup(inputRef);
+        if (filePath && fs.existsSync(filePath))
+            return { path: filePath, content: fs.readFileSync(filePath, "utf8") };
+    }
+    catch {
+        // An index miss is not fatal.
+    }
+    return { path: null, content: null };
+}
+/** The index's ref bigram vocabulary, for the novelty term of encoding salience. */
+function loadRefVocabulary() {
+    try {
+        const db = openReadonlyExistingDatabase(getDbPath(), { isolatedSnapshot: true });
+        if (!db)
+            return new Set();
+        try {
+            return buildRefVocabulary(getAllEntries(db).map((e) => e.itemRef));
+        }
+        finally {
+            closeDatabase(db);
+        }
+    }
+    catch {
+        return new Set();
     }
-    // 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 failure, so those return pass:false and never fall through to
-    // this line). A defensive score>0 guard keeps confidence undefined for any
-    // non-positive score the auto-accept gate should treat as unscored.
-    return { confidence: judgeResult.score > 0 ? judgeResult.score / 5 : undefined };
 }
 /**
- * Read the target ref's `feedback` events and apply the #267 exclusion filter.
- * Returns the filtered events plus the exclusion tallies the outcome branches
- * carry. Extracted verbatim from `akmDistill`.
+ * Score the input's encoding salience and mirror it to the asset frontmatter
+ * and `asset_salience` (keyed by the ledger ref). Best-effort throughout.
  */
-function readDistillFeedback(args) {
-    const { readEventsImpl, options, durableInputRef } = args;
-    const { events: unfilteredEvents } = readEventsImpl({
-        ref: options.itemRef ?? durableInputRef,
-        type: "feedback",
-        excludeTags: options.excludeTags,
-        includeTags: options.includeTags,
-    });
-    const events = unfilteredEvents;
-    // #267 — feedback exclusion. Filter events whose `ref` matches the
-    // exclusion list BEFORE the prompt is built. The original event stream
-    // is never mutated; only the `feedback` slice that reaches the LLM is
-    // affected. Exclusion refs are compared with event refs exactly.
-    const exclusionList = options.excludeFeedbackFromRefs ?? [];
-    const exclusionSet = new Set(exclusionList.map((ref) => ref.trim()).filter((ref) => ref.length > 0));
-    const originalEventCount = events.length;
-    const filteredEvents = exclusionSet.size > 0 ? events.filter((e) => !(e.ref !== undefined && exclusionSet.has(e.ref))) : events;
-    const filteredFeedbackCount = originalEventCount - filteredEvents.length;
-    const feedbackFullyFiltered = exclusionSet.size > 0 && originalEventCount > 0 && filteredEvents.length === 0;
-    return { filteredEvents, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered };
+function stampInputSalience(run) {
+    const { content, path: filePath } = run.asset;
+    if (!content || !filePath)
+        return;
+    try {
+        const type = parseRefInput(run.inputRef).type;
+        let revisionCount = 0;
+        try {
+            // Revisions so far: every proposal raised against this ref.
+            revisionCount = listProposals(run.stash, { ref: run.inputRef, includeArchive: true }).length;
+        }
+        catch {
+            // Unknown history scores as a first encounter.
+        }
+        const scored = scoreEncodingSalience({ body: content, type, existingRefVocabulary: run.vocabulary, revisionCount });
+        const updated = writeSalienceToFrontmatter(content, scored.score, scored);
+        if (updated !== content) {
+            fs.writeFileSync(filePath, updated, "utf8");
+            recordWrittenPath(filePath);
+            run.asset.content = updated;
+        }
+        try {
+            withStateDb((stateDb) => upsertAssetSalience(stateDb, run.ledgerRef, computeSalience({
+                ref: run.inputRef,
+                type,
+                retrievalFreq: 0,
+                encodingSalience: scored.score,
+                outcomeWeightEnabled: run.outcomeWeightEnabled,
+            })));
+        }
+        catch {
+            // The frontmatter mirror is the only persistence then.
+        }
+    }
+    catch {
+        // Scoring never blocks distillation.
+    }
 }
 /**
- * Build the distill chat messages: inject the last 1–3 rejected proposals
- * (Reflexion verbal-RL), the optional WS-3b CLS adjacent-context, and the stash
- * authoring standards, then assemble the system+user prompt. Extracted verbatim
- * from `akmDistill`.
+ * Content-score a distilled output so it carries a real encoding salience from
+ * creation — lessons are refused as inputs, so this is their only chance.
  */
-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.
-    const rejectedForRef = listProposalsReadOnly(stash, { ref: inputRef, status: "rejected", includeArchive: true }, options.ctx)
-        .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),
-    }));
-    // WS-3b CLS interleaving (step 9).
-    // When cls.enabled, inject embedding-retrieved adjacent lessons/knowledge
-    // into the distill prompt so the LLM avoids overwriting prior generalizations
-    // (catastrophic interference). DEFAULT OFF.
-    const clsConfig = getImproveProcessConfig("distill", options.improveProfile)?.cls ?? {};
+function persistOutputEncodingSalience(run, ref, body) {
+    try {
+        const type = parseRefInput(ref).type;
+        const scored = scoreEncodingSalience({ body, type, existingRefVocabulary: run.vocabulary, revisionCount: 0 });
+        withStateDb((stateDb) => upsertAssetSalience(stateDb, ref, computeSalience({
+            ref,
+            type,
+            retrievalFreq: 0,
+            encodingSalience: scored.score,
+            outcomeWeightEnabled: run.outcomeWeightEnabled,
+        })));
+    }
+    catch {
+        // Scoring never blocks proposal creation.
+    }
+}
+/** The ref's feedback events, minus any `excludeFeedbackFromRefs` matches. */
+function readDistillFeedback(run) {
+    const read = run.options.readEventsFn ??
+        ((readOptions) => readEvents(readOptions, { readOnly: true }));
+    const { events } = read({
+        ref: run.ledgerRef,
+        type: "feedback",
+        excludeTags: run.options.excludeTags,
+        includeTags: run.options.includeTags,
+    });
+    const excluded = new Set((run.options.excludeFeedbackFromRefs ?? []).map((ref) => ref.trim()).filter((ref) => ref.length > 0));
+    if (excluded.size === 0)
+        return events;
+    const kept = events.filter((e) => !(e.ref !== undefined && excluded.has(e.ref)));
+    run.exclusion = {
+        filteredFeedbackCount: events.length - kept.length,
+        feedbackFullyFiltered: events.length > 0 && kept.length === 0,
+    };
+    return kept;
+}
+/** System + user prompt: rejected-proposal context, optional CLS neighbours, stash standards. */
+async function buildDistillMessages(run, feedback, kind, outputRef) {
+    const rejectedProposals = rejectedProposalContext(run.stash, run.inputRef, run.options.ctx);
+    // CLS interleaving (default off): show related lessons so the model does not overwrite them.
+    const cls = getImproveProcessConfig("distill", run.profile)?.cls ?? {};
     let clsContext = "";
-    if (clsConfig.enabled) {
+    if (cls.enabled) {
         try {
-            const adjacentCount = clsConfig.adjacentCount ?? DEFAULT_CLS_ADJACENT_COUNT;
-            // Use the asset content or input ref as the query for adjacent retrieval.
-            const clsQuery = assetContent ? assetContent.slice(0, 500) : inputRef;
-            const adjacentItems = await fetchSimilarLessonsFn(clsQuery, adjacentCount);
-            clsContext = buildClsContext(adjacentItems, clsConfig);
+            const query = run.asset.content ? run.asset.content.slice(0, 500) : run.inputRef;
+            clsContext = buildClsContext(await run.similar(query, cls.adjacentCount ?? DEFAULT_CLS_ADJACENT_COUNT), cls);
         }
         catch {
-            // Fail open — CLS is supplemental, never required.
+            // CLS context is supplemental.
         }
     }
-    // Distill output is a lesson/knowledge (non-wiki) → stash authoring
-    // standards. Resolved once for this single call.
-    const standardsContext = resolveStandardsContext(effectiveLessonRef, stash);
-    const baseUserPrompt = buildDistillPrompt({
-        inputRef,
-        assetContent,
+    const standardsContext = resolveStandardsContext(outputRef, run.stash);
+    const prompt = buildDistillPrompt({
+        inputRef: run.inputRef,
+        assetContent: run.asset.content,
         feedback,
-        proposalKind: effectiveProposalKind,
-        ...(rejectedForRef.length > 0 ? { rejectedProposals: rejectedForRef } : {}),
+        proposalKind: kind,
+        ...(rejectedProposals.length > 0 ? { rejectedProposals } : {}),
         ...(standardsContext.trim() ? { standardsContext } : {}),
     });
-    const userPrompt = clsContext ? `${baseUserPrompt}${clsContext}` : baseUserPrompt;
-    return [
-        { role: "system", content: effectiveProposalKind === "knowledge" ? KNOWLEDGE_SYSTEM_PROMPT : LESSON_SYSTEM_PROMPT },
-        { role: "user", content: userPrompt },
-    ];
+    return {
+        system: kind === "knowledge" ? distillKnowledgeSystemPrompt : distillLessonSystemPrompt,
+        prompt: `${prompt}${clsContext}`,
+    };
 }
 async function defaultLookup(ref, stashDir) {
     return resolveAssetPath(ref, {
@@ -1291,3 +835,26 @@ async function defaultLookup(ref, stashDir) {
         honorOrigin: false,
     });
 }
+/** Top-N existing lessons similar to `query` (empty when search is unavailable). */
+async function fetchTopSimilarLessons(query, n) {
+    try {
+        const result = await akmSearch({ query, type: "lesson", limit: n, skipLogging: true, eventSource: "improve" });
+        return (result?.hits ?? [])
+            .filter((h) => "path" in h && typeof h.path === "string")
+            .slice(0, n)
+            .map((h) => {
+            let content = "";
+            try {
+                if (h.path && fs.existsSync(h.path))
+                    content = fs.readFileSync(h.path, "utf8");
+            }
+            catch {
+                // best-effort
+            }
+            return { ref: h.ref, content };
+        });
+    }
+    catch {
+        return [];
+    }
+}