akm-cli 0.9.1 → 0.9.2-alpha.2

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

@@ -18,13 +18,48 @@
  */
 import fs from "node:fs";
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
+import { ConfigError } from "../../../core/errors.js";
 import { appendEvent } from "../../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
+import { callStructured } from "../../../llm/structured-call.js";
 import { isProposalSkipped } from "../../proposal/repository.js";
 import { assessMemoryKnowledgePromotionCandidate } from "../distill-promotion-policy.js";
 import { emitProposal } from "../proposal-envelope.js";
 import { durableImproveRef } from "../source-identity.js";
 import { persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection } from "./quality-gate.js";
+/** Read-only classification of the deterministic promotion path and destination conflict. */
+export async function planMemoryKnowledgePromotion(ctx) {
+    const durableInputRef = ctx.durableInputRef ?? ctx.inputRef;
+    const promotion = ctx.targetKind === "lesson"
+        ? null
+        : assessMemoryKnowledgePromotionCandidate({
+            inputRef: durableInputRef,
+            assetContent: ctx.assetContent,
+            feedbackEvents: ctx.filteredEvents.map((event) => ({
+                ...(event.metadata !== undefined ? { metadata: event.metadata } : {}),
+            })),
+        });
+    if (!(promotion?.promote && promotion.content && (ctx.targetKind === "knowledge" || ctx.targetKind === "auto"))) {
+        return null;
+    }
+    const existingKnowledgePath = await ctx.lookup(durableImproveRef(promotion.knowledgeRef));
+    let existingKnowledgeContent = null;
+    if (existingKnowledgePath && fs.existsSync(existingKnowledgePath)) {
+        try {
+            existingKnowledgeContent = fs.readFileSync(existingKnowledgePath, "utf8");
+        }
+        catch {
+            existingKnowledgeContent = null;
+        }
+    }
+    return { promotion: promotion, existingKnowledgeContent };
+}
+/** Whether a classified promotion will actually call merge generation and/or the judge. */
+export function memoryKnowledgePromotionRequiresDispatch(ctx, plan) {
+    const hasRunner = Boolean(ctx.llmRunner);
+    return ((Boolean(plan.existingKnowledgeContent) && hasRunner) ||
+        (ctx.strategy?.processes?.distill?.qualityGate?.enabled ?? true));
+}
 /**
  * Resolve the knowledge content to propose when a memory promotes to knowledge,
  * reconciling it with any existing knowledge file at the destination (D-1 / #369).
@@ -35,21 +70,14 @@ import { persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejec
  * an LLM the existing content is appended as reviewer-reference context so the
  * merge can be done by hand. Logic is byte-identical to the prior inline block.
  */
-async function resolveKnowledgePromotionContent(ctx, baseContent, knowledgeRef) {
+async function resolveKnowledgePromotionContent(ctx, plan) {
     const durableInputRef = ctx.durableInputRef ?? ctx.inputRef;
+    const baseContent = plan.promotion.content;
+    const knowledgeRef = plan.promotion.knowledgeRef;
     let resolvedPromotionContent = baseContent;
-    const existingKnowledgePath = await ctx.lookup(durableImproveRef(knowledgeRef));
-    const existingKnowledgeContent = existingKnowledgePath && fs.existsSync(existingKnowledgePath)
-        ? (() => {
-            try {
-                return fs.readFileSync(existingKnowledgePath, "utf8");
-            }
-            catch {
-                return null;
-            }
-        })()
-        : null;
-    if (existingKnowledgeContent && ctx.llmConfig) {
+    const existingKnowledgeContent = plan.existingKnowledgeContent;
+    const runner = ctx.llmRunner;
+    if (existingKnowledgeContent && runner) {
         // Existing content found: call LLM for contradiction-resolution merge.
         const mergePrompt = [
             "You are merging two versions of a knowledge document.",
@@ -68,10 +96,23 @@ async function resolveKnowledgePromotionContent(ctx, baseContent, knowledgeRef)
             "```",
         ].join("\n");
         try {
-            const mergeResponse = await ctx.chat(ctx.llmConfig, [
-                { role: "system", content: "Return only valid JSON. No prose." },
-                { role: "user", content: mergePrompt },
-            ], ctx.signal ? { signal: ctx.signal } : undefined);
+            const mergeResponse = await callStructured({
+                feature: "distill",
+                runner,
+                ...(ctx.lease ? { lease: ctx.lease } : {}),
+                messages: [
+                    { role: "system", content: "Return only valid JSON. No prose." },
+                    { role: "user", content: mergePrompt },
+                ],
+                request: {
+                    ...(ctx.signal ? { signal: ctx.signal } : {}),
+                    ...(ctx.chat ? { chat: ctx.chat } : {}),
+                },
+                parse: (raw) => raw ?? "",
+                onError: () => "",
+                fallback: "",
+                ...(ctx.onNotices ? { onNotices: ctx.onNotices } : {}),
+            });
             const mergeResult = parseEmbeddedJsonResponse(mergeResponse);
             if (mergeResult?.action === "NOOP") {
                 // Existing content is authoritative — no update needed.
@@ -104,7 +145,9 @@ async function resolveKnowledgePromotionContent(ctx, baseContent, knowledgeRef)
                 }
             }
         }
-        catch {
+        catch (error) {
+            if (error instanceof ConfigError)
+                throw error;
             // LLM merge failed — fall through with the original promotion content.
             // The reviewer will see both versions in the proposal diff.
         }
@@ -132,26 +175,18 @@ async function resolveKnowledgePromotionContent(ctx, baseContent, knowledgeRef)
  * not a promotion candidate and the caller should continue to the ordinary
  * lesson/knowledge distillation path.
  */
-export async function promoteMemoryToKnowledge(ctx) {
-    const { targetKind, inputRef, assetContent, config, chat, stash, fetchSimilarLessonsFn, existingRefVocabulary, outcomeWeightEnabled, eligMeta, exclusionSetSize, filteredFeedbackCount, feedbackFullyFiltered, } = ctx;
+export async function promoteMemoryToKnowledge(ctx, planned) {
+    const { inputRef, assetContent, config, chat, stash, fetchSimilarLessonsFn, existingRefVocabulary, outcomeWeightEnabled, eligMeta, exclusionSetSize, filteredFeedbackCount, feedbackFullyFiltered, } = ctx;
     const durableInputRef = ctx.durableInputRef ?? inputRef;
-    const promotion = targetKind === "lesson"
-        ? null
-        : assessMemoryKnowledgePromotionCandidate({
-            inputRef: durableInputRef,
-            assetContent,
-            feedbackEvents: ctx.filteredEvents.map((event) => ({
-                ...(event.metadata !== undefined ? { metadata: event.metadata } : {}),
-            })),
-        });
-    if (!(promotion?.promote && promotion.content && (targetKind === "knowledge" || targetKind === "auto"))) {
+    const promotionPlan = planned === undefined ? await planMemoryKnowledgePromotion(ctx) : planned;
+    if (!promotionPlan)
         return null;
-    }
+    const promotion = promotionPlan.promotion;
     // D-1 / #369: When the destination knowledge file already exists, route
     // through the LLM for contradiction resolution instead of silently
     // overwriting. Follows mem0 ADD/UPDATE/DELETE/NOOP pattern (arXiv:2504.19413 §3.2)
     // and A-MEM dynamic linking (arXiv:2502.12110).
-    const merged = await resolveKnowledgePromotionContent(ctx, promotion.content, promotion.knowledgeRef);
+    const merged = await resolveKnowledgePromotionContent(ctx, promotionPlan);
     if ("earlyResult" in merged)
         return merged.earlyResult;
     const resolvedPromotionContent = merged.resolvedContent;
@@ -164,8 +199,10 @@ export async function promoteMemoryToKnowledge(ctx) {
         const similarLessons = await fetchSimilarLessonsFn(resolvedPromotionContent.slice(0, 500), 3);
         const judgeResult = await runLessonQualityJudge(config, resolvedPromotionContent, assetContent ?? "", chat, {
             ...(similarLessons.length > 0 ? { similarLessons } : {}),
-            ...(ctx.llmConfig ? { llmConfig: ctx.llmConfig } : {}),
+            ...(ctx.llmRunner ? { llmRunner: ctx.llmRunner } : {}),
+            ...(ctx.lease ? { lease: ctx.lease } : {}),
             ...(ctx.signal ? { signal: ctx.signal } : {}),
+            ...(ctx.onNotices ? { onNotices: ctx.onNotices } : {}),
         });
         if (!judgeResult.pass) {
             if (judgeResult.reviewNeeded) {
@@ -186,7 +223,7 @@ export async function promoteMemoryToKnowledge(ctx) {
         ref: promotion.knowledgeRef,
         source: "distill",
         // §23.6 fingerprint model-id term (WI-6.4).
-        ...(ctx.llmConfig?.model ? { modelId: ctx.llmConfig.model } : {}),
+        ...(ctx.llmRunner?.connection.model ? { modelId: ctx.llmRunner.connection.model } : {}),
         ...(ctx.sourceRun !== undefined ? { sourceRun: ctx.sourceRun } : {}),
         payload: {
             content: resolvedPromotionContent,

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

@@ -12,14 +12,15 @@ import fs from "node:fs";
 import path from "node:path";
 import { parseRefInput } from "../../../core/asset/resolve-ref.js";
 import { timestampForFilename } from "../../../core/common.js";
+import { ConfigError } from "../../../core/errors.js";
 import { appendEvent } from "../../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
 import { withStateDb } from "../../../core/state-db.js";
 import { recordWrittenPath } from "../../../core/write-provenance.js";
-import { getDefaultLlmConfig } from "../../../integrations/agent/engine-resolution.js";
 import { callStructured } from "../../../llm/structured-call.js";
 import { akmSearch } from "../../read/search.js";
 import { scoreEncodingSalience } from "../encoding-salience.js";
+import { resolveImproveLlmExecution } from "../execution.js";
 import { computeSalience, upsertAssetSalience } from "../salience.js";
 // ── D-4 / #390: Top-3 similar lessons retrieval ──────────────────────────────
 /**
@@ -158,8 +159,13 @@ export function buildReflectJudgePrompt(candidateContent, sourceContent, feedbac
     ].join("\n");
 }
 async function runQualityJudge(feature, config, prompt, chat, options = {}) {
-    const llmConfig = options.llmConfig ?? getDefaultLlmConfig(config);
-    if (!llmConfig) {
+    const resolvedDefault = !options.runnerSelectionFrozen && !options.llmRunner
+        ? resolveImproveLlmExecution({ config, processName: `${feature}-judge` })
+        : null;
+    if (resolvedDefault)
+        options.onNotices?.(resolvedDefault.notices);
+    const runner = options.llmRunner ?? resolvedDefault?.runner;
+    if (!runner) {
         return { pass: false, score: -1, reason: "no LLM configured — cannot judge, failing closed" };
     }
     try {
@@ -168,7 +174,8 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
         // propagates into the fail-closed catch below. `feature` labels the call.
         const raw = await callStructured({
             feature,
-            config: llmConfig,
+            runner,
+            ...(options.lease ? { lease: options.lease } : {}),
             messages: [
                 { role: "system", content: "Return only valid JSON. No prose." },
                 { role: "user", content: prompt },
@@ -183,6 +190,7 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
             // Unreachable on the ungated path (errors propagate); fail closed anyway.
             onError: () => "",
             fallback: "",
+            ...(options.onNotices ? { onNotices: options.onNotices } : {}),
         });
         const parsed = parseEmbeddedJsonResponse(raw);
         if (!parsed ||
@@ -205,7 +213,11 @@ async function runQualityJudge(feature, config, prompt, chat, options = {}) {
             return { pass: false, score, reason, reviewNeeded: true };
         return { pass: false, score, reason };
     }
-    catch {
+    catch (error) {
+        // Invalid symbolic credentials are configuration failures, not a negative
+        // content verdict. Provider/runtime failures retain the fail-closed result.
+        if (error instanceof ConfigError)
+            throw error;
         return { pass: false, score: -1, reason: "judge timeout/error — cannot judge, failing closed" };
     }
 }