akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/improve/distill.js

@@ -13,7 +13,7 @@
  *
  * # Architectural seams
  *
- *   - **Single bounded in-tree LLM call.** Wrapped in {@link tryLlmFeature}
+ *   - **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
@@ -34,14 +34,10 @@
  *
  * # Lesson-name derivation rule
  *
- * The proposed lesson ref is `lesson:<original-ref-slug>-lesson`, where
- * `<original-ref-slug>` is `<type>-<name>` from the parsed input ref (so
- * `skill:deploy` → `lesson:skill-deploy-lesson`, and `team//memory:auth-tips`
- * → `lesson:memory-auth-tips-lesson`). Origin prefixes are dropped from the
- * derived name so two sources with the same asset-type/name collapse onto
- * the same lesson queue entry rather than each generating its own — the
- * proposal queue tolerates duplicate refs (id is a UUID), so the human
- * reviewer can decide which one to accept.
+ * 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`
  *
@@ -53,42 +49,47 @@
 import fs from "node:fs";
 import distillKnowledgeSystemPrompt from "../../assets/prompts/distill-knowledge-system.md" with { type: "text" };
 import distillLessonSystemPrompt from "../../assets/prompts/distill-lesson-system.md" with { type: "text" };
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
-import { assembleAssetFromString } from "../../core/asset/asset-serialize.js";
+import { assembleAsset, assembleAssetFromString, serializeFrontmatterQuoted } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter, writeSalienceToFrontmatter } from "../../core/asset/frontmatter.js";
 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 { getDefaultLlmConfig, getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
-import { ConfigError, UsageError } from "../../core/errors.js";
+import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
+import { UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { lintLessonContent } from "../../core/lesson-lint.js";
+import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { getDbPath } from "../../core/paths.js";
-import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
+import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { withStateDb } from "../../core/state-db.js";
 import { warnVerbose } from "../../core/warn.js";
-import { closeDatabase, getAllEntries, openIndexDatabase } from "../../indexer/db/db.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
-import { chatCompletion, parseEmbeddedJsonResponse } from "../../llm/client.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
-import { createProposal, isProposalSkipped, listProposals, } from "../proposal/repository.js";
-import { stripFrontmatterBody as stripBodyForFidelity } from "./dedup.js";
+import { getDefaultLlmConfig } from "../../integrations/agent/engine-resolution.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../integrations/agent/runner.js";
+import { chatCompletion } from "../../llm/client.js";
+import { callStructured } from "../../llm/structured-call.js";
+import { closeDatabase, openIndexDatabase } from "../../storage/repositories/index-connection.js";
+import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
+import { isProposalSkipped, listProposals, proposalContent, } from "../proposal/repository.js";
+import { stripFrontmatterBody as stripBodyForFidelity } from "./content-hash.js";
 import { autoRepairLessonFrontmatter, autoSwapDescriptionWhenToUse, collectLessonQualityFindings, repairLessonDescriptionTruncation, } from "./distill/content-repair.js";
 import { promoteMemoryToKnowledge } from "./distill/promote-memory.js";
 import { fetchTopSimilarLessons, persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection, } from "./distill/quality-gate.js";
 import { buildClsContext, checkDistillFidelity } from "./distill-guards.js";
 import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { buildRefVocabulary, scoreEncodingSalience } from "./encoding-salience.js";
+import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
+import { emitProposal } from "./proposal-envelope.js";
+import { createRunContext, resolveRunStashDir } from "./run-context.js";
 import { computeSalience, upsertAssetSalience } from "./salience.js";
-// Re-exported for `reflect.ts`, which applies the same LLM-as-judge gate to
-// reflect proposals (R-5 / #374).
-export { runLessonQualityJudge };
+import { MAX_REJECTED_PROPOSALS } from "./shared.js";
+import { durableImproveRef } from "./source-identity.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 `lesson:*` ref would derive
- * `lesson:lesson-<name>-lesson-lesson` (double `-lesson` suffix) — the
+ * 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
@@ -118,38 +119,42 @@ export function isDistillRefusedInputType(type) {
 // ── Lesson-ref derivation ───────────────────────────────────────────────────
 /** Derive the proposed lesson ref from the input ref. See module docblock. */
 export function deriveLessonRef(inputRef) {
-    const parsed = parseAssetRef(inputRef);
-    // Strip origin: a feedback signal recorded against `team//skill:deploy`
-    // distils into the same lesson namespace as `skill:deploy`. The proposal
+    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 slug = `${parsed.type}-${parsed.name}`.toLowerCase();
+    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
         .replace(/[^a-z0-9-]+/g, "-")
         .replace(/-+/g, "-")
         .replace(/^-|-$/g, "");
-    return `lesson:${safe}-lesson`;
+    const safeScope = scope
+        ?.toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    return `lessons/${safeScope ? `${safeScope}/` : ""}${safe}-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`.
-// We re-export the public-facing helpers here so existing imports
-// (`from "../../src/commands/distill"`) continue to resolve.
-import { detectDoubleFrontmatter, isValidDescription, isValidWhenToUse, } from "../proposal/validators/proposal-quality-validators.js";
-export { detectDoubleFrontmatter, isValidDescription, isValidWhenToUse };
+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/
+// 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 previous "emit raw markdown with
-// embedded frontmatter" path remains as a fallback for providers that ignore
+// 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
@@ -252,16 +257,9 @@ export function assembleStructuredDistillMarkdown(payload, kind) {
     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.sources = sources;
-    }
-    const fmLines = Object.entries(fm)
-        .map(([k, v]) => {
-        if (Array.isArray(v))
-            return `${k}: [${v.map((s) => JSON.stringify(s)).join(", ")}]`;
-        return `${k}: ${JSON.stringify(v)}`;
-    })
-        .join("\n");
-    return assembleAssetFromString(fmLines, body);
+            fm.xrefs = sources;
+    }
+    return assembleAssetFromString(serializeFrontmatterQuoted(fm), body);
 }
 function validateKnowledgeContent(content, inputRef) {
     const findings = [];
@@ -331,7 +329,11 @@ export function buildDistillPrompt(input) {
     }
     lines.push("Asset content:");
     if (input.assetContent) {
-        const body = input.assetContent.trim().slice(0, 3000);
+        // 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("```");
@@ -420,78 +422,26 @@ export function buildDistillPrompt(input) {
  * `distill_invoked` event (with `outcome` in the metadata) regardless of the
  * branch taken — so observers can count invocations cheaply.
  */
-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 = parseAssetRef(inputRef);
-    const targetKind = options.proposalKind ?? "lesson";
-    // 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. Distill produces *lessons* from non-lesson
-    // sources (memory, skill, knowledge, etc.). Calling distill on an existing
-    // lesson would derive `lesson:lesson-<name>-lesson-lesson` (double `-lesson`
-    // suffix) and route a "lesson of a lesson" through the proposal queue —
-    // observed in 323 reviewed archived proposals as the recursive-ref defect.
-    // Refuse the input here so the improve loop (or other callers) get a clean
-    // skipped outcome instead of producing nonsense refs.
-    //
-    // 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.
-    if (isDistillRefusedInputType(parsedInputRef.type)) {
-        // 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 : `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",
-            ref: inputRef,
-            metadata: {
-                outcome: "skipped",
-                lessonRef: skippedRef,
-                message,
-                skipReason: isSecretInput ? "refused_secret_input" : "recursive_lesson_input",
-                ...eligMeta,
-            },
-        });
-        return {
-            schemaVersion: 1,
-            ok: true,
-            outcome: "skipped",
-            inputRef,
-            lessonRef: skippedRef,
-            message,
-        };
-    }
-    const config = options.config ?? loadConfig();
-    const stash = options.stashDir ?? resolveStashDir();
-    const chat = options.chat ?? chatCompletion;
-    const lookup = options.lookupFn ?? defaultLookup;
-    const readEventsImpl = options.readEventsFn ?? readEvents;
-    // R1 opt-out must flow into every computeSalience call this command makes so
-    // distill-written rank_score rows use the same weights as preparation's.
-    const outcomeWeightEnabled = config.improve?.salience?.outcomeWeightEnabled !== false;
-    // D-4 / #390: similar-lessons retrieval seam (test-injectable).
-    const fetchSimilarLessonsFn = options.fetchSimilarLessonsFn ?? ((query, n) => fetchTopSimilarLessons(query, n, options.stashDir));
+/**
+ * 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, config, 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(inputRef);
+        const filePath = await lookup(durableInputRef);
         if (filePath && fs.existsSync(filePath)) {
             assetFilePath = filePath;
-            assetContent = fs.readFileSync(filePath, "utf8");
+            assetContent = ctx.readAsset(filePath);
         }
     }
     catch {
@@ -523,7 +473,7 @@ export async function akmDistill(options) {
     }
     if (assetContent && assetFilePath) {
         try {
-            const parsedRef = parseAssetRef(inputRef);
+            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.
@@ -543,7 +493,7 @@ export async function akmDistill(options) {
             // 1. Write salience to the source asset frontmatter (idempotent).
             const updatedContent = writeSalienceToFrontmatter(assetContent, salienceResult.score, salienceResult);
             if (updatedContent !== assetContent) {
-                fs.writeFileSync(assetFilePath, updatedContent, "utf8");
+                ctx.writeAsset(assetFilePath, updatedContent);
                 assetContent = updatedContent;
             }
             // 2. Persist encoding_salience to state.db.
@@ -556,7 +506,7 @@ export async function akmDistill(options) {
                         encodingSalience: salienceResult.score,
                         outcomeWeightEnabled,
                     });
-                    upsertAssetSalience(stateDb, inputRef, vector);
+                    upsertAssetSalience(stateDb, salienceWriteKey, vector);
                 });
             }
             catch {
@@ -567,24 +517,131 @@ export async function akmDistill(options) {
             // Scoring errors never block distillation.
         }
     }
-    const { events } = readEventsImpl({
-        ref: inputRef,
-        type: "feedback",
-        excludeTags: options.excludeTags,
-        includeTags: options.includeTags,
+    return { assetContent, existingRefVocabulary };
+}
+/**
+ * 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,
+    };
+}
+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";
+        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.",
+        };
+    }
+    // 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 stash = resolveRunStashDir(options.stashDir);
+    const chat = options.chat ?? chatCompletion;
+    const distillLlm = Object.hasOwn(options, "llmConfig")
+        ? (options.llmConfig ?? undefined)
+        : (() => {
+            const runner = resolveImproveProcessRunner(options.improveProfile, "distill", config);
+            return runner ? materializeLlmRunnerConnection(runner) : getDefaultLlmConfig(config);
+        })();
+    const lookup = options.lookupFn ?? ((ref) => defaultLookup(ref, stash));
+    const readEventsImpl = options.readEventsFn ?? readEvents;
+    // R1 opt-out must flow into every computeSalience call this command makes so
+    // distill-written rank_score rows use the same weights as preparation's.
+    const outcomeWeightEnabled = config.improve?.salience?.outcomeWeightEnabled !== false;
+    // D-4 / #390: similar-lessons retrieval seam (test-injectable).
+    const fetchSimilarLessonsFn = options.fetchSimilarLessonsFn ?? ((query, n) => fetchTopSimilarLessons(query, n, options.stashDir));
+    const assetCtx = createRunContext({
+        stashDir: stash,
+        config,
+        eventsCtx: options.eventsCtx ?? {},
+        proposalsCtx: options.ctx ?? {},
+        chat,
+        getLlmConfig: () => distillLlm ?? null,
+        sourceRun: options.sourceRun ?? `distill-${Date.now()}`,
+        dryRun: false,
+        signal: options.signal,
+    }).withFreshAssetMemo();
+    const { assetContent, existingRefVocabulary } = await loadAndScoreInputSalience({
+        inputRef,
+        durableInputRef,
+        salienceWriteKey,
+        stash,
+        config,
+        outcomeWeightEnabled,
+        lookup,
+        ctx: assetCtx,
+    });
+    const { filteredEvents, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered } = readDistillFeedback({
+        readEventsImpl,
+        options,
+        durableInputRef,
     });
-    // #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. The exclusion set is normalised through `parseAssetRef` →
-    // re-serialised so callers can pass canonical or origin-prefixed refs
-    // and the comparison still works against the event payload's `ref`.
-    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;
     const feedback = filteredEvents.slice(-20).map((e) => ({
         ts: e.ts,
         eventType: e.eventType,
@@ -599,9 +656,14 @@ export async function akmDistill(options) {
     const promotionResult = await promoteMemoryToKnowledge({
         targetKind,
         inputRef,
+        durableInputRef,
+        ...(options.itemRef ? { itemRef: options.itemRef } : {}),
         assetContent,
         filteredEvents,
         config,
+        strategy: options.improveProfile,
+        llmConfig: distillLlm,
+        signal: options.signal,
         chat,
         stash,
         lookup,
@@ -612,6 +674,7 @@ export async function akmDistill(options) {
         eligibilitySource: options.eligibilitySource,
         sourceRun: options.sourceRun,
         proposalsCtx: options.ctx,
+        eventsCtx: options.eventsCtx,
         exclusionSetSize: exclusionSet.size,
         filteredFeedbackCount,
         feedbackFullyFiltered,
@@ -620,143 +683,226 @@ export async function akmDistill(options) {
         return promotionResult;
     const effectiveProposalKind = targetKind === "knowledge" ? "knowledge" : "lesson";
     const effectiveLessonRef = effectiveProposalKind === "knowledge" ? deriveKnowledgeRef(inputRef) : deriveLessonRef(inputRef);
-    // Inject last 1–3 rejected proposals for this ref as Reflexion-style
-    // verbal-RL context so the LLM avoids regenerating refused proposals.
-    const MAX_REJECTED_PROPOSALS = 3;
-    const rejectedForRef = listProposals(stash, { ref: inputRef, status: "rejected", includeArchive: true })
-        .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: p.payload.content.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(config, "distill", options.improveProfile)?.cls ?? {};
-    let clsContext = "";
-    if (clsConfig.enabled) {
-        try {
-            const adjacentCount = clsConfig.adjacentCount ?? 3;
-            // 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);
-        }
-        catch {
-            // Fail open — CLS is supplemental, never required.
-        }
-    }
-    // Distill output is a lesson/knowledge (non-wiki) → stash authoring
-    // standards. Resolved once for this single call.
-    const standardsContext = resolveStashStandards(stash);
-    const baseUserPrompt = buildDistillPrompt({
+    const messages = await buildDistillMessages({
+        options,
+        stash,
         inputRef,
         assetContent,
         feedback,
-        proposalKind: effectiveProposalKind,
-        ...(rejectedForRef.length > 0 ? { rejectedProposals: rejectedForRef } : {}),
-        ...(standardsContext.trim() ? { standardsContext } : {}),
+        effectiveProposalKind,
+        effectiveLessonRef,
+        fetchSimilarLessonsFn,
     });
-    const userPrompt = clsContext ? `${baseUserPrompt}${clsContext}` : baseUserPrompt;
-    const messages = [
-        { role: "system", content: effectiveProposalKind === "knowledge" ? KNOWLEDGE_SYSTEM_PROMPT : LESSON_SYSTEM_PROMPT },
-        { role: "user", content: userPrompt },
-    ];
-    // Single bounded LLM call. The wrapper handles the gate-check, 600s
-    // (10 min) default timeout, and error fallback (returning `null`).
-    //
-    // Capture the fallback reason so we can distinguish "config gate is off"
-    // (no LLM was called — operator action required) from "LLM call was made
-    // but returned no usable output" (transport/timeout/empty — observability).
-    // The previous conflated message ("disabled or the LLM call failed") gave
-    // operators no signal to act on; a 108-run audit found 100% of skipped
-    // outcomes were actually the config-gate-off branch.
-    //
-    // responseSchema lift (PR 1, asset-writers-investigation §5): on the
-    // production path (no test `chat` seam) we pass the lesson/knowledge JSON
-    // schema to `chatCompletion`. Providers with `supportsJsonSchema: true`
-    // return a typed JSON object the post-call code re-assembles into markdown,
-    // bypassing the four shape-level rejection codes the validator log catches.
-    // The test seam keeps its two-arg signature, so injected fakes still pin
-    // markdown responses verbatim and the existing assertion suite is unchanged.
-    const distillSchema = effectiveProposalKind === "knowledge" ? DISTILL_KNOWLEDGE_JSON_SCHEMA : DISTILL_LESSON_JSON_SCHEMA;
-    let fallbackReason;
-    const raw = await tryLlmFeature("distill", config, async () => {
-        const distillLlm = getDefaultLlmConfig(config);
-        if (!distillLlm) {
-            // No LLM connection configured — treat as gate-disabled. Throwing
-            // here lets `tryLlmFeature` route us through the "error" fallback,
-            // which is the same graceful skipped path.
-            throw new ConfigError("No LLM connection configured. Set `defaults.llm` and a profile under `profiles.llm`.", "LLM_NOT_CONFIGURED");
+    const { raw, fallbackReason } = await runDistillLlmCall({
+        config,
+        options,
+        distillLlm,
+        messages,
+        effectiveProposalKind,
+    });
+    if (raw === null || raw.trim() === "") {
+        return distillEmptyResponseResult({
+            fallbackReason,
+            inputRef,
+            durableInputRef,
+            ...(options.itemRef ? { itemRef: options.itemRef } : {}),
+            effectiveLessonRef,
+            effectiveProposalKind,
+            exclusionSet,
+            filteredFeedbackCount,
+            feedbackFullyFiltered,
+            eligMeta,
+            eventsCtx: options.eventsCtx,
+        });
+    }
+    const { content, descriptionSwapped } = assembleAndValidateDistillContent({
+        raw,
+        effectiveProposalKind,
+        inputRef,
+        durableInputRef,
+        ...(options.itemRef ? { itemRef: options.itemRef } : {}),
+        effectiveLessonRef,
+        exclusionSet,
+        filteredFeedbackCount,
+        eligMeta,
+        eventsCtx: options.eventsCtx,
+    });
+    const gate = await applyDistillQualityGate({
+        config,
+        options,
+        content,
+        assetContent,
+        chat,
+        distillLlm,
+        fetchSimilarLessonsFn,
+        stash,
+        inputRef,
+        effectiveLessonRef,
+        exclusionSet,
+        filteredFeedbackCount,
+        feedbackFullyFiltered,
+    });
+    if ("rejection" in gate)
+        return gate.rejection;
+    const lessonJudgeConfidence = gate.confidence;
+    return emitDistillLessonProposal({
+        content,
+        options,
+        distillLlm,
+        assetContent,
+        inputRef,
+        durableInputRef,
+        effectiveLessonRef,
+        effectiveProposalKind,
+        stash,
+        exclusionSet,
+        filteredFeedbackCount,
+        feedbackFullyFiltered,
+        lessonJudgeConfidence,
+        existingRefVocabulary,
+        outcomeWeightEnabled,
+        descriptionSwapped,
+        eligMeta,
+    });
+}
+// ── 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, distillLlm, 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);
+            }
         }
-        // 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.
-        if (options.chat === undefined) {
-            return chatCompletion(distillLlm, messages, { responseSchema: distillSchema });
+        catch {
+            // Fail open — fidelity check is supplemental.
         }
-        // Test seam: preserve the two-arg signature so existing fake `chat`
-        // functions (which return markdown strings) continue to work.
-        return chat(distillLlm, messages);
-    }, null, {
-        onFallback: (evt) => {
-            fallbackReason = evt.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 ${evt.feature}: ${evt.reason}`);
+    }
+    // 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.
+        ...(distillLlm?.model ? { modelId: distillLlm.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 (raw === null || raw.trim() === "") {
-        // 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,
-                lessonRef: effectiveLessonRef,
-                proposalRef: effectiveLessonRef,
-                proposalKind: effectiveProposalKind,
-                message: "distill is disabled in config; enable processes.distill.enabled to activate.",
-                ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-            };
-        }
-        // LLM was actually invoked but produced nothing usable (transport error,
-        // timeout, or empty/whitespace response). Emit the event so the failure
-        // is observable.
+    if (isProposalSkipped(proposalResult2)) {
         appendEvent({
             eventType: "distill_invoked",
-            ref: inputRef,
+            // Use item_ref when resolved, otherwise the input conceptId.
+            ref: options.itemRef ?? durableInputRef,
             metadata: {
-                outcome: "llm_failed",
-                lessonRef: effectiveLessonRef,
-                proposalKind: effectiveProposalKind,
-                ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
+                outcome: "skipped",
+                proposalRef: effectiveLessonRef,
+                message: proposalResult2.message,
+                skipReason: proposalResult2.reason,
                 ...eligMeta,
             },
-        });
+        }, options.eventsCtx);
         return {
             schemaVersion: 1,
             ok: true,
-            outcome: "llm_failed",
+            outcome: "skipped",
             inputRef,
-            lessonRef: effectiveLessonRef,
             proposalRef: effectiveLessonRef,
-            proposalKind: effectiveProposalKind,
-            message: "LLM call returned no usable output (timeout, empty, or error).",
-            ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
+            skipReason: proposalResult2.reason,
+            message: proposalResult2.message,
         };
     }
+    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 } : {}),
+    };
+}
+/**
+ * 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, } = 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 falling through to the
-    // legacy markdown pipeline. Failure here (non-JSON response, missing
+    // 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;
@@ -801,156 +947,254 @@ export async function akmDistill(options) {
     if (findings.length > 0) {
         appendEvent({
             eventType: "distill_invoked",
-            ref: inputRef,
+            // Use item_ref when resolved, otherwise the input conceptId.
+            ref: itemRef ?? durableInputRef,
             metadata: {
                 outcome: "validation_failed",
-                lessonRef: effectiveLessonRef,
+                proposalRef: effectiveLessonRef,
                 proposalKind: effectiveProposalKind,
                 findingKinds: findings.map((f) => f.kind),
                 ...(exclusionSet.size > 0 ? { filteredFeedbackCount } : {}),
                 ...eligMeta,
             },
-        });
+        }, eventsCtx);
         const message = findings.map((f) => f.message).join("\n");
         throw new UsageError(`Distilled ${effectiveProposalKind} failed validation:\n${message}`, "MISSING_REQUIRED_ARGUMENT", effectiveProposalKind === "knowledge"
             ? "Knowledge proposals require a non-empty markdown body."
             : "Lessons require non-empty `description` and `when_to_use` frontmatter fields. See v1 spec §13.");
     }
-    // LLM-as-judge quality gate (P2-B). Only active when the feature flag is
-    // explicitly enabled. Fail-CLOSED (07 P0-2): an unjudgeable proposal (no LLM
-    // / timeout / parse failure) is rejected, not passed through.
-    // D-5 / #388: Three-band system — review_needed band queues a proposal
-    // with review_needed outcome rather than auto-rejecting.
-    let lessonJudgeConfidence;
-    if (isLlmFeatureEnabled(config, "lesson_quality_gate")) {
-        // 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 : undefined);
-        if (!judgeResult.pass) {
-            if (judgeResult.reviewNeeded) {
-                return writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {
-                    reviewNeeded: true,
-                    ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-                }, options.eligibilitySource);
-            }
-            return writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}, options.eligibilitySource);
-        }
-        // 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.
-        if (judgeResult.score > 0)
-            lessonJudgeConfidence = judgeResult.score / 5;
-    }
-    // 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(config, "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);
-            }
-        }
-        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).
-    //
-    // D-7 / #398: Inject `sources: [inputRef]` into the LLM-path proposal
-    // frontmatter when the field is absent, providing reviewers with provenance
-    // without requiring them to open event history. A-MEM arXiv:2502.12110 —
-    // all notes carry explicit provenance links.
-    const parsed = parseFrontmatter(content);
-    const frontmatterWithSources = { ...parsed.data };
-    if (!Array.isArray(frontmatterWithSources.sources) || frontmatterWithSources.sources.length === 0) {
-        frontmatterWithSources.sources = [inputRef];
+    return { content, descriptionSwapped };
+}
+/**
+ * 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.
+ */
+async function runDistillLlmCall(args) {
+    const { config, options, distillLlm, messages, effectiveProposalKind } = 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 && !distillLlm) {
+        // 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 };
     }
-    const proposalResult2 = createProposal(stash, {
-        ref: effectiveLessonRef,
-        source: "distill",
-        ...(options.sourceRun !== undefined ? { sourceRun: options.sourceRun } : {}),
-        payload: {
-            content,
-            frontmatter: frontmatterWithSources,
+    const raw = await callStructured({
+        feature: "distill",
+        akmConfig: config,
+        enabled,
+        // Safe: when the gate is open, distillLlm is defined (guard above); when
+        // it is closed, the transport never runs and config is never read.
+        config: distillLlm,
+        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 }
+            : // 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;
         },
-        ...(lessonJudgeConfidence !== undefined ? { confidence: lessonJudgeConfidence } : {}),
-        // Attribution tagging: persist the eligibility lane on the proposal.
-        ...(options.eligibilitySource ? { eligibilitySource: options.eligibilitySource } : {}),
-    }, options.ctx);
-    if (isProposalSkipped(proposalResult2)) {
-        appendEvent({
-            eventType: "distill_invoked",
-            ref: inputRef,
-            metadata: {
-                outcome: "skipped",
-                lessonRef: effectiveLessonRef,
-                message: proposalResult2.message,
-                skipReason: proposalResult2.reason,
-                ...eligMeta,
-            },
-        });
+        fallback: null,
+        onFallback: (evt) => recordFallback(evt.feature, evt.reason),
+    });
+    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`.
+ */
+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: "skipped",
+            outcome: "config_disabled",
             inputRef,
-            lessonRef: effectiveLessonRef,
-            message: proposalResult2.message,
+            proposalRef: effectiveLessonRef,
+            proposalKind: effectiveProposalKind,
+            message: "distill is disabled in config; enable processes.distill.enabled to activate.",
+            ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
         };
     }
-    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(effectiveLessonRef, content, existingRefVocabulary, outcomeWeightEnabled);
+    // LLM was actually invoked but produced nothing usable (transport error,
+    // timeout, or empty/whitespace response). Emit the event so the failure
+    // is observable.
     appendEvent({
         eventType: "distill_invoked",
-        ref: inputRef,
+        // Use item_ref when resolved, otherwise the input conceptId.
+        ref: itemRef ?? durableInputRef,
         metadata: {
-            outcome: "queued",
-            lessonRef: effectiveLessonRef,
+            outcome: "llm_failed",
             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,
         },
-    });
+    }, eventsCtx);
     return {
         schemaVersion: 1,
         ok: true,
-        outcome: "queued",
+        outcome: "llm_failed",
         inputRef,
-        lessonRef: effectiveLessonRef,
         proposalRef: effectiveLessonRef,
         proposalKind: effectiveProposalKind,
-        proposalId: proposal2.id,
-        proposal: proposal2,
+        message: "LLM call returned no usable output (timeout, empty, or error).",
         ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
-        ...(descriptionSwapped > 0 ? { descriptionSwapped } : {}),
     };
 }
-// ── Helpers ─────────────────────────────────────────────────────────────────
-async function defaultLookup(ref) {
-    return resolveAssetPath(ref, { mode: "index-only" });
+/**
+ * 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`.
+ */
+async function applyDistillQualityGate(args) {
+    const { config, options, content, assetContent, chat, distillLlm, fetchSimilarLessonsFn, stash, inputRef, effectiveLessonRef, exclusionSet, filteredFeedbackCount, feedbackFullyFiltered, } = 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 } : {}),
+        ...(distillLlm ? { llmConfig: distillLlm } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
+    });
+    if (!judgeResult.pass) {
+        if (judgeResult.reviewNeeded) {
+            return {
+                rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, {
+                    reviewNeeded: true,
+                    ...(exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}),
+                }, options.eligibilitySource, options.eventsCtx),
+            };
+        }
+        return {
+            rejection: writeQualityRejection(stash, inputRef, effectiveLessonRef, content, judgeResult.score, judgeResult.reason, exclusionSet.size > 0 ? { filteredFeedbackCount, feedbackFullyFiltered } : {}, options.eligibilitySource, options.eventsCtx),
+        };
+    }
+    // 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`.
+ */
+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 };
+}
+/**
+ * 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`.
+ */
+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 = listProposals(stash, { ref: inputRef, status: "rejected", includeArchive: true })
+        .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 ?? {};
+    let clsContext = "";
+    if (clsConfig.enabled) {
+        try {
+            const adjacentCount = clsConfig.adjacentCount ?? 3;
+            // 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);
+        }
+        catch {
+            // Fail open — CLS is supplemental, never required.
+        }
+    }
+    // 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,
+        feedback,
+        proposalKind: effectiveProposalKind,
+        ...(rejectedForRef.length > 0 ? { rejectedProposals: rejectedForRef } : {}),
+        ...(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 },
+    ];
+}
+async function defaultLookup(ref, stashDir) {
+    return resolveAssetPath(ref, {
+        stashDir,
+        mode: "disk-only",
+        directoryIndexNames: ["SKILL.md"],
+        preserveDirectNameFallback: true,
+        honorOrigin: false,
+    });
 }