akm-cli 0.9.0-beta.9 → 0.9.0-rc.0

package/dist/llm/embedders/cache.js

@@ -25,7 +25,9 @@ export function getCachedEmbedding(key) {
     return cached;
 }
 export function setCachedEmbedding(key, value) {
-    // Evict oldest entry if at capacity
+    // Delete first so an overwrite refreshes LRU recency AND is not counted as a
+    // new insert: only a genuinely new key at capacity should evict the oldest.
+    embedCache.delete(key);
     if (embedCache.size >= EMBED_CACHE_MAX) {
         const oldest = embedCache.keys().next().value;
         if (oldest !== undefined) {

package/dist/llm/embedders/deterministic.js

@@ -0,0 +1,66 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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/.
+/** Env var that switches the whole embedding facade into deterministic mode. */
+export const DETERMINISTIC_EMBED_ENV = "AKM_EMBED_DETERMINISTIC";
+/**
+ * Vector width. Matches the default local model (`bge-small`, 384 dims) so the
+ * index DB's embedding column and sqlite-vec table dimensions line up without
+ * any extra config.
+ */
+export const DETERMINISTIC_EMBED_DIM = 384;
+/**
+ * Stable model id reported for deterministic mode. Used as the embedding
+ * `model_id` and folded into the provider fingerprint so a deterministic index
+ * is never confused with a real-model index (and vice versa).
+ */
+export const DETERMINISTIC_EMBED_MODEL_ID = "akm-deterministic-hash-v1";
+/** True when deterministic embedding is enabled via env. */
+export function isDeterministicEmbedEnabled() {
+    return process.env[DETERMINISTIC_EMBED_ENV] === "1";
+}
+/** FNV-1a 32-bit hash. Platform- and version-stable. */
+function fnv1a(str) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        // 32-bit FNV prime multiply via shifts to stay in uint32.
+        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+    }
+    return h >>> 0;
+}
+/** Lowercase, split on non-alphanumeric, drop empties. */
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 0);
+}
+/**
+ * Deterministically embed `text` into a unit-length vector of width `dim`
+ * using feature hashing. Empty / token-less input returns a fixed unit
+ * vector so cosine similarity never sees a zero vector (NaN guard).
+ */
+export function deterministicEmbed(text, dim = DETERMINISTIC_EMBED_DIM) {
+    const vec = new Array(dim).fill(0);
+    const tokens = tokenize(text);
+    for (const tok of tokens) {
+        const h = fnv1a(tok);
+        const idx = h % dim;
+        // Use a higher bit for the sign so it is independent of the bucket index.
+        const sign = (h >>> 16) & 1 ? 1 : -1;
+        vec[idx] += sign;
+    }
+    let norm = 0;
+    for (const v of vec)
+        norm += v * v;
+    norm = Math.sqrt(norm);
+    if (norm === 0) {
+        // No usable tokens — return a fixed, stable unit vector.
+        vec[0] = 1;
+        return vec;
+    }
+    for (let i = 0; i < dim; i++)
+        vec[i] /= norm;
+    return vec;
+}

package/dist/llm/embedders/local.js

@@ -19,8 +19,30 @@ import { getDirname, resolveModule } from "../../runtime.js";
  * `all-MiniLM-L6-v2` at the same 384-dimension footprint.
  */
 export const DEFAULT_LOCAL_MODEL = "Xenova/bge-small-en-v1.5";
+/** Type-guard: true when the value looks like a batch Tensor (has .dims). */
+function isBatchTensor(v) {
+    return (v !== null &&
+        typeof v === "object" &&
+        "data" in v &&
+        "dims" in v &&
+        Array.isArray(v.dims) &&
+        v.dims.length >= 2);
+}
+const realTransformersLoader = () => import("@huggingface/transformers");
+let transformersLoader = realTransformersLoader;
+/** TEST-ONLY. Swap the transformers module loader; pass undefined to restore. */
+export function _setTransformersLoaderForTests(fake) {
+    transformersLoader = fake ?? realTransformersLoader;
+}
 const LOCAL_EMBEDDER_DTYPE = "fp32";
 const LOCAL_EMBEDDER_FALLBACK_DTYPE = "auto";
+/**
+ * Maximum texts per batch for the local transformers pipeline. The pipeline
+ * can run genuine batched inference over a string array; 32 is a safe default
+ * that fits well inside most model context budgets while providing 10–50×
+ * throughput improvement over one-at-a-time calls on the cold minority.
+ */
+const LOCAL_BATCH_SIZE = 32;
 /**
  * Return the local model name that will be used for embedding.
  * When `overrideModel` is provided it takes precedence; otherwise
@@ -77,15 +99,63 @@ export class LocalEmbedder {
         }
         return this.embedWithModel(text, this.defaultModel);
     }
+    /**
+     * Embed a batch of texts. Processes in chunks of `LOCAL_BATCH_SIZE` (32) so
+     * the transformers pipeline can run genuine batched inference rather than one
+     * call per text. Falls back to one-at-a-time if the pipeline does not support
+     * array input (older versions of @huggingface/transformers). Each chunk is
+     * checked against the AbortSignal between calls.
+     */
     async embedBatch(texts, signal) {
         if (texts.length === 0)
             return [];
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+        }
+        const pipeline = await this.getPipeline(this.defaultModel);
         const results = [];
-        for (const text of texts) {
+        for (let i = 0; i < texts.length; i += LOCAL_BATCH_SIZE) {
             if (signal?.aborted) {
                 throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
             }
-            results.push(await this.embedWithModel(text, this.defaultModel));
+            const chunk = texts.slice(i, i + LOCAL_BATCH_SIZE);
+            try {
+                // @huggingface/transformers feature-extraction pipeline accepts a
+                // string[] and returns a batch Tensor (NOT an Array<{data}>).
+                // The Tensor has .data (flat Float32Array, length = batch * dim) and
+                // .dims = [batch, dim]. Slice .data into per-row vectors using .dims.
+                const batchResult = await pipeline(chunk, {
+                    pooling: "mean",
+                    normalize: true,
+                });
+                if (isBatchTensor(batchResult)) {
+                    const dim = batchResult.dims[1];
+                    for (let row = 0; row < chunk.length; row++) {
+                        results.push(Array.from(batchResult.data.subarray(row * dim, (row + 1) * dim)));
+                    }
+                }
+                else if (Array.isArray(batchResult)) {
+                    // Older versions of @huggingface/transformers returned Array<{data}>.
+                    for (const r of batchResult) {
+                        results.push(Array.from(r.data));
+                    }
+                }
+                else {
+                    // Single-text result returned for a chunk — should not happen for
+                    // string[] input, but handle defensively.
+                    throw new Error("unexpected pipeline return shape for batch input");
+                }
+            }
+            catch {
+                // Fallback: process one-at-a-time (older pipeline versions or mismatched
+                // return type). Fail-open per text: a single failure aborts the chunk.
+                for (const text of chunk) {
+                    if (signal?.aborted) {
+                        throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+                    }
+                    results.push(await this.embedWithModel(text, this.defaultModel));
+                }
+            }
         }
         return results;
     }
@@ -116,7 +186,7 @@ export class LocalEmbedder {
                 }
                 let pipeline;
                 try {
-                    const mod = await import("@huggingface/transformers");
+                    const mod = await transformersLoader();
                     pipeline = mod.pipeline;
                 }
                 catch (importError) {

package/dist/llm/feature-gate.js

@@ -22,18 +22,25 @@ const FEATURE_LOCATION = {
     graph_extraction: (cfg) => cfg.profiles?.improve?.default?.processes?.graphExtraction?.enabled ?? true,
     // Legacy default: false
     metadata_enhance: (cfg) => cfg.index?.metadataEnhance?.enabled ?? false,
-    // Legacy default: false
-    curate_rerank: (cfg) => cfg.search?.curateRerank?.enabled ?? false,
-    // Legacy default: false
-    lesson_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.distill?.qualityGate?.enabled ?? false,
+    // Default ON since R3 (docs/design/improve-self-learning-analysis.md G5):
+    // distill is a primary acquisition path, so the gate guards minted content by
+    // default. The judge fails CLOSED (07 P0-2): no LLM / timeout / parse failure
+    // reject the proposal rather than passing it through — an unjudgeable proposal
+    // must not slip into the stash. Opt out via
+    // profiles.improve.default.processes.distill.qualityGate.enabled: false.
+    lesson_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.distill?.qualityGate?.enabled ?? true,
     // Legacy default: false
     proposal_quality_gate: (cfg) => cfg.profiles?.improve?.default?.processes?.reflect?.qualityGate?.enabled ?? false,
     // Legacy default: false
     memory_contradiction_detection: (cfg) => cfg.profiles?.improve?.default?.processes?.consolidate?.contradictionDetection?.enabled ?? false,
-    // Default: true. Session extraction replaces the akm-plugin checkpoint hook
-    // and is the primary path for capturing durable signal from real sessions.
-    // Opt out via `profiles.improve.default.processes.extract.enabled: false`.
-    session_extraction: (cfg) => cfg.profiles?.improve?.default?.processes?.extract?.enabled ?? true,
+    // Always on at the LLM-wrapper level. Enablement is decided ONCE at the
+    // extract entry point (`akmExtract`): the `extract.enabled` process toggle
+    // gates extract as a STAGE of `akm improve` (the active improve profile, per
+    // #593/#594), while an explicit `akm extract` command always runs. Gating the
+    // inner LLM calls on `default.processes.extract.enabled` here was a footgun —
+    // dropping extract from the daily improve profile silently disabled the
+    // standalone `akm extract` command. (cfg unused — kept for resolver signature.)
+    session_extraction: (_cfg) => true,
 };
 /**
  * Pure predicate: is the named feature gate enabled in `config`?
@@ -89,14 +96,11 @@ export async function tryLlmFeature(feature, config, fn, fallback, opts) {
 export function isProcessEnabled(section, processName, config) {
     if (!config)
         return false;
-    // index.metadataEnhance / index.stalenessDetection are first-class new-shape entries.
+    // index.metadataEnhance is a first-class new-shape entry.
     if (section === "index") {
         if (processName === "metadata_enhance" || processName === "metadataEnhance") {
             return config.index?.metadataEnhance?.enabled ?? true;
         }
-        if (processName === "staleness_detection" || processName === "stalenessDetection") {
-            return config.index?.stalenessDetection?.enabled ?? false;
-        }
         if (processName === "memory_inference" || processName === "memoryInference") {
             return isLlmFeatureEnabled(config, "memory_inference");
         }
@@ -104,9 +108,6 @@ export function isProcessEnabled(section, processName, config) {
             return isLlmFeatureEnabled(config, "graph_extraction");
         }
     }
-    if (section === "search" && (processName === "curate_rerank" || processName === "curateRerank")) {
-        return config.search?.curateRerank?.enabled ?? false;
-    }
     if (section === "improve") {
         const processes = config.profiles?.improve?.default?.processes;
         const entry = processes?.[processName];

package/dist/llm/graph-extract.js

@@ -20,11 +20,13 @@
  * the connection via `resolveIndexPassLLM("graph", config)` and pass it
  * straight through.
  */
+import systemPromptTemplate from "../assets/prompts/graph-extract-system.md" with { type: "text" };
 import userPromptTemplate from "../assets/prompts/graph-extract-user-prompt.md" with { type: "text" };
 import { toErrorMessage } from "../core/common.js";
 import { warn, warnVerbose } from "../core/warn.js";
-import { chatCompletion, LlmCallError, parseEmbeddedJsonResponse } from "./client.js";
+import { chatCompletion, isContextSizeError, parseEmbeddedJsonResponse } from "./client.js";
 import { tryLlmFeature } from "./feature-gate.js";
+import { callStructured } from "./structured-call.js";
 /**
  * Separator token used between assets in a batch prompt.
  * Chosen to be visually clear and unlikely to appear verbatim in asset bodies.
@@ -41,30 +43,15 @@ const NON_ARRAY_BATCH_DISABLE_THRESHOLD = 2;
 const MAX_ENTITIES_PER_ASSET = 32;
 /** Hard cap on relations returned per asset. */
 const MAX_RELATIONS_PER_ASSET = 32;
-const SYSTEM_PROMPT = "You extract a knowledge graph from developer notes. Return ONLY valid JSON — no prose, no markdown fences, no preamble.";
+const SYSTEM_PROMPT = systemPromptTemplate;
 const USER_PROMPT_PREFIX = userPromptTemplate
     .replace("{{MAX_ENTITIES}}", String(MAX_ENTITIES_PER_ASSET))
     .replace("{{MAX_RELATIONS}}", String(MAX_RELATIONS_PER_ASSET));
-/**
- * Detect whether an error message indicates a context size exceeded condition.
- * Covers common patterns from OpenAI-compatible APIs (LM Studio, Ollama, etc).
- *
- * Requires BOTH a context keyword AND token-count/overflow evidence so that
- * model prose merely mentioning "context size" / "context length" (e.g. gemma
- * narrating about a document) does not get misclassified as a provider
- * context-limit error (#496).
- */
-export function isContextSizeError(message) {
-    const lower = message.toLowerCase();
-    const contextKw = /context (size|length|window)|prompt too long|exceeds.*context/.test(lower);
-    if (!contextKw) {
-        return false;
-    }
-    const evidence = /\b\d+\s*(token|tokens|tk)\b/.test(lower) ||
-        /max(imum)?\s+(context|token|input)/.test(lower) ||
-        /exceeded|over.*limit|too.*long/.test(lower);
-    return evidence;
-}
+// `isContextSizeError` is defined in `./client` and re-exported here so the
+// graph extractor and the retry classifier (`isRetryable`) share one
+// definition (#496). Re-exported (not just imported) to preserve existing
+// importers of this module — including its unit test.
+export { isContextSizeError } from "./client.js";
 const GENERIC_ENTITIES = new Set([
     "agent",
     "application",
@@ -327,7 +314,13 @@ function parseGraphExtraction(raw) {
             if (!normalized)
                 continue;
             const normalizedKey = normalized.toLowerCase();
-            if (!/[a-z0-9]/i.test(normalized) || GENERIC_ENTITIES.has(normalizedKey)) {
+            // Drop generic/empty entities AND raw file/dir paths (anything with a
+            // path separator) — the prompt no longer asks for them and isJunkEntity
+            // discards them downstream, so emitting them is pure waste/junk (#632).
+            if (!/[a-z0-9]/i.test(normalized) ||
+                GENERIC_ENTITIES.has(normalizedKey) ||
+                normalized.includes("/") ||
+                normalized.includes("\\")) {
                 filteredGenericEntities += 1;
                 continue;
             }
@@ -432,6 +425,18 @@ function buildBatchSystemPrompt() {
         "The array length MUST equal the number of assets provided. " +
         'Use {"entities":[],"relations":[]} for assets with no extractable graph content.');
 }
+/**
+ * Hardened system prompt for the single batch retry (#635). Used only after a
+ * first response failed array salvage — leans harder on "raw array only" so a
+ * model that wrapped the array in prose/fences corrects itself before we pay
+ * the per-asset fallback.
+ */
+function buildBatchRetrySystemPrompt() {
+    return (`${buildBatchSystemPrompt()} ` +
+        "Your previous response could NOT be parsed as a JSON array. " +
+        "Respond with ONLY the raw JSON array — start with '[' and end with ']'. " +
+        "No prose, no explanation, no markdown code fences, no preamble.");
+}
 function buildBatchUserPrompt(bodies) {
     const count = bodies.length;
     const assetBlocks = bodies.map((body, i) => `${BATCH_ASSET_SEPARATOR} ${i + 1} ===\n${body.trim()}`).join("\n\n");
@@ -541,7 +546,21 @@ export async function extractGraphFromBodies(llmConfig, bodies, signal, akmConfi
             });
             if (!raw)
                 return null;
-            const parsed = parseEmbeddedJsonResponse(raw);
+            // Array-preferring salvage (#635): the batch contract is a top-level
+            // JSON array. A leading/example `{…}` object in the response must not
+            // mask a valid `[…]` array as a false "non-array" failure.
+            let parsed = parseEmbeddedJsonResponse(raw, { expect: "array" });
+            if (!Array.isArray(parsed)) {
+                // One stricter-reprompt retry before paying the per-asset fallback
+                // (#635). Many genuine non-array responses recover when the model is
+                // told explicitly to emit only the raw array.
+                bumpTelemetry(options.telemetry, "retryAttempts");
+                const retryRaw = await chatCompletion(llmConfig, [
+                    { role: "system", content: buildBatchRetrySystemPrompt() },
+                    { role: "user", content: userPrompt },
+                ], { temperature: 0, timeoutMs: llmConfig.timeoutMs, signal });
+                parsed = retryRaw ? parseEmbeddedJsonResponse(retryRaw, { expect: "array" }) : undefined;
+            }
             if (!Array.isArray(parsed)) {
                 nonArrayResponse = true;
                 bumpTelemetry(options.telemetry, "nonArrayBatchFailures");
@@ -551,8 +570,9 @@ export async function extractGraphFromBodies(llmConfig, bodies, signal, akmConfi
                         batchState.batchingDisabled = true;
                     }
                 }
-                warn(`graph extraction (batch): LLM response was not a JSON array for ${nonEmptyBodies.length} asset(s); ` +
-                    `will fall back per-asset. promptChars=${userPrompt.length}${formatContextHint(llmConfig)}`);
+                warn(`graph extraction (batch): LLM response was not a JSON array for ${nonEmptyBodies.length} asset(s) ` +
+                    `even after a stricter retry; will fall back per-asset. ` +
+                    `promptChars=${userPrompt.length}${formatContextHint(llmConfig)}`);
                 return null;
             }
             return parsed;
@@ -675,17 +695,21 @@ export async function extractGraphFromBody(llmConfig, body, signal, akmConfig, o
         return merged;
     }
     const userPrompt = `${USER_PROMPT_PREFIX}${trimmedBody}`;
-    return tryLlmFeature("graph_extraction", akmConfig, async () => {
-        try {
-            const raw = await chatCompletion(llmConfig, [
-                { role: "system", content: SYSTEM_PROMPT },
-                { role: "user", content: userPrompt },
-            ], {
-                temperature: 0.1,
-                timeoutMs: llmConfig.timeoutMs,
-                signal,
-                onRetryAttempt: () => bumpTelemetry(options.telemetry, "retryAttempts"),
-            });
+    return callStructured({
+        feature: "graph_extraction",
+        akmConfig,
+        config: llmConfig,
+        messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: userPrompt },
+        ],
+        request: {
+            temperature: 0.1,
+            timeoutMs: llmConfig.timeoutMs,
+            signal,
+            onRetryAttempt: () => bumpTelemetry(options.telemetry, "retryAttempts"),
+        },
+        parse: (raw) => {
             if (!raw)
                 return empty();
             const parsed = parseEmbeddedJsonResponse(raw);
@@ -701,16 +725,16 @@ export async function extractGraphFromBody(llmConfig, body, signal, akmConfig, o
             if (extraction.status === "failed")
                 bumpTelemetry(options.telemetry, "failureCount");
             return extraction;
-        }
-        catch (err) {
+        },
+        onError: (cls, err) => {
             const errMsg = toErrorMessage(err);
-            if (isContextSizeError(errMsg)) {
+            if (cls === "context_limit") {
                 bumpTelemetry(options.telemetry, "failureCount");
                 warn(`graph extraction: context size exceeded for asset; promptChars=${userPrompt.length}${formatContextHint(llmConfig)}. ` +
                     `Consider increasing llm.contextLength in config.json.`);
                 return empty("context_limit", "failed");
             }
-            else if (err instanceof LlmCallError && err.code === "provider_html_error") {
+            else if (cls === "html") {
                 bumpTelemetry(options.telemetry, "htmlErrorCount");
                 warn(`graph extraction: provider returned HTML instead of JSON for asset; promptChars=${userPrompt.length}${formatContextHint(llmConfig)}: ${errMsg}`);
                 return empty("llm_error", "failed");
@@ -720,9 +744,8 @@ export async function extractGraphFromBody(llmConfig, body, signal, akmConfig, o
                 warn(`graph extraction failed for asset; promptChars=${userPrompt.length}${formatContextHint(llmConfig)}: ${errMsg}`);
                 return empty("llm_error", "failed");
             }
-        }
-    }, empty(), {
-        timeoutMs: llmConfig.timeoutMs,
+        },
+        fallback: empty(),
         onFallback,
     });
 }

package/dist/llm/memory-infer-impl.js

@@ -0,0 +1,138 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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/.
+/**
+ * LLM helper for the `akm index` memory-inference pass (#201).
+ *
+ * Compresses a single memory body into one higher-signal derived memory. The
+ * pass itself (in `src/indexer/memory-inference.ts`) is responsible for
+ * deciding which memories are pending, persisting the derived memory with the
+ * correct frontmatter (`inferred: true`, `source: <parent-ref>`), and marking
+ * the parent as processed for idempotency.
+ *
+ * This module is intentionally tiny and stateless so tests can stub it via
+ * `mock.module("../src/llm/memory-infer", ...)` without hitting a network.
+ *
+ * Locked v1 contract (#208): the LLM connection always comes from the
+ * shared `akm.llm` block — never from a per-pass override. Callers obtain
+ * the connection via `resolveIndexPassLLM("memory", config)` and pass it
+ * straight through.
+ */
+import memoryInferSystemPrompt from "../assets/prompts/memory-infer-system.md" with { type: "text" };
+import memoryInferUserPrompt from "../assets/prompts/memory-infer-user.md" with { type: "text" };
+import { toErrorMessage } from "../core/common.js";
+import { warn } from "../core/warn.js";
+import { parseEmbeddedJsonResponse } from "./client.js";
+import { callStructured } from "./structured-call.js";
+/** Hard cap on body chars sent to the model — pragmatic and matches `runLlmEnrich`. */
+const MAX_BODY_CHARS = 4000;
+const SYSTEM_PROMPT = memoryInferSystemPrompt;
+const USER_PROMPT_PREFIX = memoryInferUserPrompt;
+/**
+ * Strict JSON Schema for the derived-memory payload. Sent to providers that
+ * opt in via `LlmConnectionConfig.supportsJsonSchema = true`; the client
+ * silently drops the schema for providers that don't.
+ *
+ * Extends the responseSchema lift (PR 1, asset-writers-investigation §5) to
+ * the memory-inference path. Mirrors the validation gate below
+ * (title/description/content + non-empty tags/searchHints) so a
+ * schema-compliant response is guaranteed to pass the downstream check
+ * — no more "incomplete derived memory payload from LLM; skipping memory"
+ * for shape-only failures.
+ */
+const DERIVED_MEMORY_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        title: { type: "string", minLength: 1 },
+        description: { type: "string", minLength: 1 },
+        content: { type: "string", minLength: 1 },
+        tags: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 8 },
+        searchHints: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 6 },
+    },
+    required: ["title", "description", "content", "tags", "searchHints"],
+    additionalProperties: false,
+};
+/**
+ * Compress a single memory body into one derived memory via the configured LLM.
+ *
+ * Returns `undefined` on any failure (timeout, invalid JSON, empty response).
+ * Errors are logged via `warn()` but never thrown — a failed split for one memory
+ * must not abort the rest of the index pass.
+ *
+ * Routes through `callStructured({ feature: "memory_inference", ... })` so the
+ * feature gate, error classification, and onFallback hook are honoured uniformly
+ * (Fix C5).
+ */
+export async function compressMemoryToDerivedMemory(llmConfig, body, signal, akmConfig, onFallback, telemetry, onRetryAttempt) {
+    const trimmedBody = body.trim();
+    if (!trimmedBody)
+        return undefined;
+    const userPrompt = `${USER_PROMPT_PREFIX}${trimmedBody.slice(0, MAX_BODY_CHARS)}`;
+    // Memory-inference is ALWAYS gated: no `akmConfig` ⇒ gate closed (no chat,
+    // `disabled` fallback), never the seam's ungated/propagate path (which is for
+    // direct callers like `enhanceMetadata`). This is the gate-closed branch
+    // `tryLlmFeature(_, undefined, _)` took before the migration.
+    if (!akmConfig) {
+        onFallback?.({ feature: "memory_inference", reason: "disabled" });
+        return undefined;
+    }
+    return callStructured({
+        feature: "memory_inference",
+        akmConfig,
+        config: llmConfig,
+        messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: userPrompt },
+        ],
+        request: {
+            temperature: 0.1,
+            timeoutMs: llmConfig.timeoutMs,
+            signal,
+            responseSchema: DERIVED_MEMORY_JSON_SCHEMA,
+            onRetryAttempt,
+        },
+        parse: (raw) => {
+            if (!raw)
+                return undefined;
+            const parsed = parseEmbeddedJsonResponse(raw);
+            if (!parsed) {
+                warn("memory inference: invalid JSON response from LLM; skipping memory.");
+                return undefined;
+            }
+            const title = typeof parsed.title === "string" ? parsed.title.trim() : "";
+            const description = typeof parsed.description === "string" ? parsed.description.trim() : "";
+            const content = typeof parsed.content === "string" ? parsed.content.trim() : "";
+            const tags = Array.isArray(parsed.tags)
+                ? parsed.tags
+                    .filter((t) => typeof t === "string")
+                    .map((t) => t.trim())
+                    .filter(Boolean)
+                    .slice(0, 8)
+                : [];
+            const searchHints = Array.isArray(parsed.searchHints)
+                ? parsed.searchHints
+                    .filter((h) => typeof h === "string")
+                    .map((h) => h.trim())
+                    .filter(Boolean)
+                    .slice(0, 6)
+                : [];
+            if (!title || !description || !content || tags.length === 0 || searchHints.length === 0) {
+                warn("memory inference: incomplete derived memory payload from LLM; skipping memory.");
+                return undefined;
+            }
+            return { title, description, tags, searchHints, content };
+        },
+        onError: (cls, err) => {
+            if (cls === "html") {
+                if (telemetry)
+                    telemetry.htmlErrorCount = (telemetry.htmlErrorCount ?? 0) + 1;
+                warn(`memory inference: provider returned HTML instead of JSON; skipping memory: ${toErrorMessage(err)}`);
+                return undefined;
+            }
+            warn(`memory inference failed: ${toErrorMessage(err)}`);
+            return undefined;
+        },
+        fallback: undefined,
+        onFallback,
+    });
+}