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

package/dist/integrations/session-logs/index.js

@@ -2,24 +2,37 @@
 // 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/.
 import { getHarness, SESSION_LOG_HARNESSES } from "../harnesses/index.js";
-import { ClaudeCodeProvider } from "../harnesses/claude/session-log.js";
-import { OpenCodeProvider } from "../harnesses/opencode/session-log.js";
 export { extractInlineRefMentions } from "./inline-refs.js";
-const HARNESSES = [new ClaudeCodeProvider(), new OpenCodeProvider()];
-// #562: the unified HARNESS_REGISTRY is the single source of truth for which
-// harnesses expose session logs. Validate (behaviour-preserving) that every
-// session-log provider instantiated above resolves to a registry harness whose
-// `sessionLogs` capability is set — and via the id-normalization bridge, so a
-// provider named "claude-code" still maps to the canonical "claude" harness.
-// This turns a silently-drifting third registry into a startup invariant.
+// #562/P2 (plan §"Kill registry drift"): the provider array is DERIVED from
+// the unified HARNESS_REGISTRY — every harness with `capabilities.sessionLogs`
+// must supply a `sessionLogProvider` factory on its descriptor, and this is
+// the only place providers are instantiated. Adding a session-log harness is
+// therefore one registry entry, never an edit here.
+//
+// Ordered by canonical id so the pre-derivation provider order
+// ([claude-code, opencode] — visible in e.g. `extract --auto` result order)
+// is preserved deterministically, independent of HARNESS_REGISTRY declaration
+// order (which is pinned for JSON-schema enum stability).
+const HARNESSES = [...SESSION_LOG_HARNESSES]
+    .sort((a, b) => a.id.localeCompare(b.id))
+    .map((h) => {
+    const provider = h.sessionLogProvider?.();
+    if (!provider) {
+        throw new Error(`[akm] harness "${h.id}" declares capabilities.sessionLogs but no sessionLogProvider factory (src/integrations/harnesses). Add one to its descriptor.`);
+    }
+    return provider;
+});
+// Reverse invariant (kept from #562): every derived provider's runtime name
+// must resolve back — via the id-normalization bridge, so a provider named
+// "claude-code" still maps to the canonical "claude" harness — to a registry
+// harness whose `sessionLogs` capability is set. Catches a descriptor whose
+// factory returns a provider named for a different/unregistered harness.
 for (const provider of HARNESSES) {
     const harness = getHarness(provider.name);
     if (!harness?.capabilities.sessionLogs) {
         throw new Error(`[akm] session-log provider "${provider.name}" is not registered as a sessionLogs harness in HARNESS_REGISTRY (src/integrations/harnesses). Add it there.`);
     }
 }
-// Touch the derived list so the dependency is explicit and tree-shake-safe.
-void SESSION_LOG_HARNESSES;
 const ERROR_PATTERNS = /error|failed|exception|cannot|undefined|null pointer|ENOENT|timeout/i;
 /**
  * Returns all available session log harnesses for the current machine.
@@ -28,6 +41,22 @@ const ERROR_PATTERNS = /error|failed|exception|cannot|undefined|null pointer|ENO
 export function getAvailableHarnesses() {
     return HARNESSES.filter((harness) => harness.isAvailable());
 }
+/**
+ * Map each available harness to its `{ harnessName, roots }` watch target,
+ * skipping harnesses that expose no roots (absent `watchRoots()` or an empty
+ * result). This is the one stable entry point the watcher uses so it never
+ * reaches into providers directly.
+ */
+export function getWatchTargets() {
+    const targets = [];
+    for (const harness of getAvailableHarnesses()) {
+        const roots = harness.watchRoots?.() ?? [];
+        if (roots.length === 0)
+            continue;
+        targets.push({ harnessName: harness.name, roots });
+    }
+    return targets;
+}
 export function normalizeSessionTopic(text) {
     const normalized = text.replace(/\s+/g, " ").trim().toLowerCase();
     if (normalized.length < 10)

package/dist/llm/call-ai.js

@@ -3,7 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { getDefaultLlmConfig } from "../core/config/config.js";
 import { warn } from "../core/warn.js";
-import { resolveAgentProfile, runAgent } from "../integrations/agent/index.js";
+import { resolveProfileFromConfig, runAgent } from "../integrations/agent/index.js";
 import { chatCompletion } from "./client.js";
 /**
  * Unified AI call: prefers the default agent profile, falls back to the
@@ -14,7 +14,7 @@ export async function callAi(config, prompt, opts = {}) {
     const defaultAgentName = config.defaults?.agent;
     if (defaultAgentName) {
         try {
-            const profile = resolveAgentProfile(defaultAgentName, config.profiles?.agent?.[defaultAgentName]);
+            const profile = resolveProfileFromConfig(defaultAgentName, config);
             if (!profile) {
                 return {
                     ok: false,

package/dist/llm/client.js

@@ -103,18 +103,29 @@ function retryBackoffMs() {
     return RETRY_BACKOFF_MIN_MS + Math.random() * (RETRY_BACKOFF_MAX_MS - RETRY_BACKOFF_MIN_MS);
 }
 /**
- * Detect whether an error message indicates a context-size-exceeded condition.
- * Mirrors the heuristic in `graph-extract.ts` — retrying a context overflow
- * cannot shrink the input, so it must not be retried.
+ * 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).
+ *
+ * Canonical home: `graph-extract.ts` re-exports this so the index-pass
+ * graph extractor and the retry classifier (`isRetryable`) share one
+ * definition — retrying a context overflow cannot shrink the input, so it
+ * must never be retried.
  */
-function looksLikeContextOverflow(message) {
+export function isContextSizeError(message) {
     const lower = message.toLowerCase();
-    return (lower.includes("context") &&
-        (lower.includes("context size") ||
-            lower.includes("context length") ||
-            lower.includes("context_window") ||
-            lower.includes("prompt too long") ||
-            lower.includes("exceeds")));
+    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;
 }
 /**
  * Decide whether a first-attempt {@link LlmCallError} is eligible for a single
@@ -138,7 +149,7 @@ function looksLikeContextOverflow(message) {
  * failure in the improve/reflect and capability-probe flows.
  */
 function isRetryable(err) {
-    if (looksLikeContextOverflow(err.message))
+    if (isContextSizeError(err.message))
         return false;
     if (err.code === "provider_error") {
         return typeof err.statusCode === "number" && err.statusCode >= 500;
@@ -154,7 +165,19 @@ function isRetryable(err) {
     }
     return false;
 }
+// ── Test seam ────────────────────────────────────────────────────────────────
+// Swap-and-restore override. Inert in production; only tests call the setter.
+let chatCompletionOverride;
+/** TEST-ONLY. Swap the implementation of `chatCompletion`; pass undefined to restore. */
+export function _setChatCompletionForTests(fake) {
+    chatCompletionOverride = fake;
+}
 export async function chatCompletion(config, messages, options) {
+    if (chatCompletionOverride)
+        return chatCompletionOverride(config, messages, options);
+    return chatCompletionReal(config, messages, options);
+}
+async function chatCompletionReal(config, messages, options) {
     const effectiveTimeoutMs = options?.timeoutMs ?? config.timeoutMs ?? 120_000;
     const started = Date.now();
     try {

package/dist/llm/embedder.js

@@ -2,11 +2,27 @@
 // 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/.
 import { embedCacheKey, getCachedEmbedding, setCachedEmbedding } from "./embedders/cache.js";
-import { isTransformersAvailable, LocalEmbedder } from "./embedders/local.js";
+import { DETERMINISTIC_EMBED_MODEL_ID, deterministicEmbed, isDeterministicEmbedEnabled, } from "./embedders/deterministic.js";
+import { DEFAULT_LOCAL_MODEL, isTransformersAvailable as isTransformersAvailableReal, LocalEmbedder, } from "./embedders/local.js";
 import { hasRemoteEndpoint, RemoteEmbedder } from "./embedders/remote.js";
 // ── Re-exports (public API) ─────────────────────────────────────────────────
 export { clearEmbeddingCache } from "./embedders/cache.js";
-export { DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "./embedders/local.js";
+export { _setTransformersLoaderForTests, DEFAULT_LOCAL_MODEL } from "./embedders/local.js";
+let embedderOverrides;
+/** TEST-ONLY. Swap embedder implementations; pass undefined to restore. */
+export function _setEmbedderForTests(fakes) {
+    embedderOverrides = fakes;
+}
+/**
+ * Check whether the @huggingface/transformers package is importable.
+ * Delegating wrapper around `./embedders/local`'s probe so tests can swap it
+ * via {@link _setEmbedderForTests}.
+ */
+export function isTransformersAvailable() {
+    if (embedderOverrides?.isTransformersAvailable)
+        return embedderOverrides.isTransformersAvailable();
+    return isTransformersAvailableReal();
+}
 // ── Singleton local embedder ────────────────────────────────────────────────
 // `_localEmbedder` is an intentional module-level singleton but constructed
 // lazily on first use. The underlying @huggingface/transformers pipeline is
@@ -39,6 +55,12 @@ export function resetLocalEmbedder() {
  * and embedding config. Repeated identical queries return the cached vector.
  */
 export async function embed(text, embeddingConfig, signal) {
+    if (embedderOverrides?.embed)
+        return embedderOverrides.embed(text, embeddingConfig, signal);
+    // Deterministic mode (env-gated, test/bench only): model-free, stable.
+    if (isDeterministicEmbedEnabled()) {
+        return deterministicEmbed(text);
+    }
     const key = embedCacheKey(text, embeddingConfig);
     const cached = getCachedEmbedding(key);
     if (cached)
@@ -52,16 +74,28 @@ export async function embed(text, embeddingConfig, signal) {
 /**
  * Generate embeddings for multiple texts in batch.
  * Uses the OpenAI-compatible batch API for remote endpoints (batches of 100).
- * Falls back to sequential embedding for the local transformer pipeline.
+ * Uses the LocalEmbedder.embedBatch path for the local transformer pipeline,
+ * which processes texts in chunks of 32 for genuine batched inference.
  */
 export async function embedBatch(texts, embeddingConfig, signal) {
+    if (embedderOverrides?.embedBatch)
+        return embedderOverrides.embedBatch(texts, embeddingConfig, signal);
     if (texts.length === 0)
         return [];
+    // Deterministic mode (env-gated, test/bench only): model-free, stable.
+    if (isDeterministicEmbedEnabled()) {
+        return texts.map((t) => deterministicEmbed(t));
+    }
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
         return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal);
     }
-    // Local transformer: process sequentially (pipeline handles one at a time)
+    // Local transformer: use the batched path (chunks of 32 via LocalEmbedder).
+    // When a localModel override is set we cannot share the singleton (which uses
+    // the default model), so fall back to per-text embedWithModel in that case.
     const localModel = embeddingConfig?.localModel;
+    if (!localModel) {
+        return getLocalEmbedder().embedBatch(texts, signal);
+    }
     const results = [];
     for (const text of texts) {
         if (signal?.aborted) {
@@ -77,11 +111,40 @@ export async function embedBatch(texts, embeddingConfig, signal) {
 // facade and its `@huggingface/transformers` import chain. Re-export
 // preserves the existing public API.
 export { cosineSimilarity } from "./embedders/types.js";
+// ── Model ID resolution ─────────────────────────────────────────────────────
+/**
+ * Derive a stable string identifier for the embedding model in use.
+ * This is the `model_id` stored in `body_embeddings` (and used for the
+ * drop-all-on-mismatch purge when the model changes).
+ *
+ * Rules:
+ *   - Remote endpoint: use `config.model` (the API-level model name).
+ *   - Local transformers: use `config.localModel ?? DEFAULT_LOCAL_MODEL`.
+ *   - No config: use `DEFAULT_LOCAL_MODEL` (the shared singleton model).
+ */
+export function resolveEmbeddingModelId(embeddingConfig) {
+    if (embedderOverrides?.resolveEmbeddingModelId)
+        return embedderOverrides.resolveEmbeddingModelId(embeddingConfig);
+    if (isDeterministicEmbedEnabled())
+        return DETERMINISTIC_EMBED_MODEL_ID;
+    if (!embeddingConfig)
+        return DEFAULT_LOCAL_MODEL;
+    if (hasRemoteEndpoint(embeddingConfig))
+        return embeddingConfig.model ?? "remote";
+    return embeddingConfig.localModel ?? DEFAULT_LOCAL_MODEL;
+}
 // ── Availability check ──────────────────────────────────────────────────────
 /**
  * Check whether embedding is available with a detailed reason on failure.
  */
 export async function checkEmbeddingAvailability(embeddingConfig) {
+    if (embedderOverrides?.checkEmbeddingAvailability) {
+        return embedderOverrides.checkEmbeddingAvailability(embeddingConfig);
+    }
+    // Deterministic mode (env-gated): always available — no model, no network.
+    if (isDeterministicEmbedEnabled()) {
+        return { available: true };
+    }
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
         try {
             await new RemoteEmbedder(embeddingConfig).embed("test");

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];