@remnic/core 9.3.726 → 9.3.728

package/dist/{chunk-ZA2S2VLL.js → chunk-C2PG7IEH.js}

@@ -2,6 +2,9 @@ import {
   getHostEmbeddingProvider,
   normalizeHostEmbeddingVector
 } from "./chunk-3ONXXHQO.js";
+import {
+  resolveMemoryLifecycleCapabilities
+} from "./chunk-3RCBIOOJ.js";
 import {
   readEnvVar
 } from "./chunk-JUC24CTX.js";
@@ -225,7 +228,7 @@ var EmbeddingFallback = class {
     return run;
   }
   async resolveProvider(options = {}) {
-    if (!this.config.embeddingFallbackEnabled) return null;
+    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) return null;
     if (options.includeHost !== false && this.config.hostEmbeddingProviderEnabled !== false) {
       const hostProvider = getHostEmbeddingProvider(this.config.memoryDir);
       if (hostProvider) {
@@ -510,4 +513,4 @@ export {
   EmbeddingProviderUnavailableError,
   EmbeddingFallback
 };
-//# sourceMappingURL=chunk-ZA2S2VLL.js.map
+//# sourceMappingURL=chunk-C2PG7IEH.js.map

package/dist/chunk-C2PG7IEH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/embedding-fallback.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, readFile, rename, rm, writeFile } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport { resolveMemoryLifecycleCapabilities } from \"./capabilities.js\";\nimport { readEnvVar } from \"./runtime/env.js\";\nimport type { PluginConfig } from \"./types.js\";\nimport {\n  getHostEmbeddingProvider,\n  type HostEmbeddingProvider,\n  normalizeHostEmbeddingVector,\n} from \"./host-embedding-provider.js\";\n\ntype EmbeddingProviderType = \"openai\" | \"local\" | \"host\";\n\ntype ProviderConfig = {\n  type: EmbeddingProviderType;\n  model: string;\n  endpoint?: string;\n  headers?: Record<string, string>;\n  hostProvider?: HostEmbeddingProvider;\n};\n\ntype EmbeddingIndexEntry = {\n  vector: number[];\n  path: string;\n};\n\ntype EmbeddingResult = {\n  provider: ProviderConfig;\n  vector: number[];\n};\n\ntype EmbeddingIndexFile = {\n  version: 1;\n  provider: EmbeddingProviderType;\n  model: string;\n  entries: Record<string, EmbeddingIndexEntry>;\n};\n\ntype EmbeddingIndexIdentity = Pick<EmbeddingIndexFile, \"provider\" | \"model\">;\ntype EmbeddingIndexComparable =\n  | EmbeddingIndexIdentity\n  | Pick<ProviderConfig, \"type\" | \"model\">;\n\nconst DEFAULT_OPENAI_MODEL = \"text-embedding-3-small\";\n\n/**\n * Thrown by `EmbeddingFallback.search()` (via `embed()`) when the embedding\n * backend is effectively unavailable on the lookup path — either because the\n * HTTP fetch exceeded its deadline OR because the endpoint returned a non-2xx\n * status code. Callers that need to distinguish a backend outage from \"no\n * candidates\" can `instanceof`-check against this class.\n *\n * Round 9 fix (Finding UZqB): previously a timeout returned null from embed(),\n * which caused search() to return [] silently. decideSemanticDedup then\n * classified the result as no_candidates instead of backend_unavailable, so\n * the per-batch batchBackendUnavailable short-circuit never activated and\n * batches of N facts each paid a full timeout roundtrip.\n *\n * Round 10 fix (Findings Ui1J + Ui1L): search() now only re-throws this error\n * when the caller explicitly passes `{ throwOnTimeout: true }`. Without that\n * flag search() catches it and returns [] instead, preserving fail-open\n * semantics for recall-path callers (searchEmbeddingFallback) that have no\n * try/catch. Only the semantic-dedup path (semanticDedupLookup) passes the\n * flag so it can still reach decideSemanticDedup's backend_unavailable branch.\n *\n * Round 11 fix (Finding Ur_J): `embed()` now also throws this error from the\n * lookup path when the HTTP response is non-2xx (e.g. 429, 500, 503). Without\n * this, repeated 5xx outages would each return null → [] → no_candidates and\n * subsequent facts in the same batch would all pay full roundtrips instead of\n * tripping the per-batch backend_unavailable short-circuit.\n *\n * The class name is kept for backward compatibility — `EmbeddingTimeoutError`\n * now signals \"lookup backend unavailable\" rather than strictly \"timed out\".\n */\nexport class EmbeddingTimeoutError extends Error {\n  override readonly name = \"EmbeddingTimeoutError\" as const;\n  constructor(message: string) {\n    super(message);\n  }\n}\n\nexport class EmbeddingProviderUnavailableError extends Error {\n  override readonly name = \"EmbeddingProviderUnavailableError\" as const;\n  constructor(message: string) {\n    super(message);\n  }\n}\n\nfunction isLookupBackendUnavailableError(err: unknown): boolean {\n  return (\n    err instanceof EmbeddingTimeoutError ||\n    err instanceof EmbeddingProviderUnavailableError\n  );\n}\n\n/**\n * Maximum time to wait for an embedding HTTP request on the LOOKUP/query\n * path before giving up.\n *\n * The write-time semantic dedup guard in orchestrator.persistExtraction()\n * blocks each candidate fact on an embedding lookup. If the embedding\n * endpoint hangs (degraded OpenAI, stalled local gateway, DNS timeout),\n * extraction would otherwise stall indefinitely — a single bad backend\n * could freeze the entire persist loop. Bounding the fetch here ensures\n * the decision path fails open (returns null) within a predictable window\n * and writes proceed as non-duplicates.\n *\n * Tests can override via REMNIC_EMBEDDING_FETCH_TIMEOUT_MS so they don't\n * have to wait the full default on hung-fetch assertions.\n *\n * Related: joshuaswarren/remnic#373, PR #399 P1/P2 review.\n */\nconst DEFAULT_EMBEDDING_LOOKUP_TIMEOUT_MS = 5000;\n\n/**\n * Maximum time to wait for an embedding HTTP request on the INDEX path.\n *\n * Indexing runs asynchronously after a memory has already been persisted\n * to disk. It does not block extraction or writes — it only updates the\n * embedding index used by later semantic dedup lookups. A slow local\n * CPU-backed embedding model can legitimately take tens of seconds per\n * call, so applying the short lookup timeout here silently dropped index\n * updates and caused later dedup lookups to miss recently persisted\n * memories. Use a much larger budget on this path.\n *\n * Tests can override via REMNIC_EMBEDDING_INDEX_TIMEOUT_MS.\n */\nconst DEFAULT_EMBEDDING_INDEX_TIMEOUT_MS = 120_000;\n\nfunction resolveEmbeddingLookupTimeoutMs(): number {\n  const raw = readEnvVar(\"REMNIC_EMBEDDING_FETCH_TIMEOUT_MS\");\n  if (raw) {\n    const parsed = Number(raw);\n    if (Number.isFinite(parsed) && parsed > 0) {\n      return Math.floor(parsed);\n    }\n  }\n  return DEFAULT_EMBEDDING_LOOKUP_TIMEOUT_MS;\n}\n\nfunction resolveEmbeddingIndexTimeoutMs(): number {\n  const raw = readEnvVar(\"REMNIC_EMBEDDING_INDEX_TIMEOUT_MS\");\n  if (raw) {\n    const parsed = Number(raw);\n    if (Number.isFinite(parsed) && parsed > 0) {\n      return Math.floor(parsed);\n    }\n  }\n  return DEFAULT_EMBEDDING_INDEX_TIMEOUT_MS;\n}\n\n/**\n * Options for the low-level embed() call.\n *\n * `mode` selects the timeout profile:\n *   - \"lookup\" (default): bounded by the short lookup budget; fails open fast.\n *   - \"index\": bounded by a much longer budget so slow backends can still\n *     index newly persisted memories.\n */\nexport type EmbedMode = \"lookup\" | \"index\";\n\nexport class EmbeddingFallback {\n  private readonly indexPath: string;\n  private loaded: EmbeddingIndexFile | null = null;\n  private mutationQueue: Promise<void> = Promise.resolve();\n\n  constructor(private readonly config: PluginConfig) {\n    this.indexPath = path.join(config.memoryDir, \"state\", \"embeddings.json\");\n  }\n\n  async isAvailable(): Promise<boolean> {\n    return (await this.resolveProvider()) !== null;\n  }\n\n  /**\n   * Embed an array of texts and return their embedding vectors.\n   *\n   * This is the public batch-embed interface used by semantic chunking\n   * (Finding 1, PR #420 post-merge). Texts are grouped into batches of\n   * `embeddingBatchSize` (from `semanticChunkingConfig`, default 32) and\n   * each batch is dispatched concurrently via `Promise.all()`. This\n   * preserves the semantic intent of `embeddingBatchSize` — without batching,\n   * every text incurred a sequential HTTP round-trip, making the batch size\n   * config ineffective. (PR #439 post-merge Finding 2.)\n   *\n   * If the provider is unavailable or any single embedding fails, the method\n   * throws so the caller can fall back to recursive chunking.\n   */\n  async embedTexts(texts: string[]): Promise<number[][]> {\n    const provider = await this.resolveProvider();\n    if (!provider) {\n      throw new Error(\"Embedding provider is not available\");\n    }\n\n    const batchSize = Math.max(\n      1,\n      this.config.semanticChunkingConfig?.embeddingBatchSize ?? 32,\n    );\n\n    const vectors: number[][] = [];\n    for (let i = 0; i < texts.length; i += batchSize) {\n      const batch = texts.slice(i, i + batchSize);\n      const batchResults = await Promise.all(\n        batch.map((text) => this.embed(text, provider, { mode: \"lookup\" })),\n      );\n      for (const vec of batchResults) {\n        if (!vec) {\n          throw new Error(\"Embedding returned null for input text\");\n        }\n        vectors.push(vec);\n      }\n    }\n    return vectors;\n  }\n\n  /**\n   * Nearest-neighbor search against the embedding index.\n   *\n   * @param query         The query string to embed and search for.\n   * @param limit         Max number of hits to return.\n   * @param options       Optional filters.\n   *   - `pathPrefix`   Restrict candidates to entries whose indexed `path`\n   *                    starts with this prefix (relative to `memoryDir`).\n   *                    Used by the semantic dedup guard to scope lookups\n   *                    to the target namespace so a high-similarity hit\n   *                    from a different namespace can't suppress a write\n   *                    in the target namespace. Default: no filter.\n   *   - `pathExcludePrefixes`\n   *                    Exclude any entry whose indexed `path` starts with\n   *                    any of these prefixes. Used for the default\n   *                    namespace case: when the default namespace lives at\n   *                    `memoryDir` root (legacy layout) we still want to\n   *                    exclude `namespaces/<other>/…` entries.\n   */\n  async search(\n    query: string,\n    limit: number,\n    options: {\n      pathPrefix?: string;\n      pathExcludePrefixes?: readonly string[];\n      /**\n       * When true, an `EmbeddingTimeoutError` from the embedding backend is\n       * re-thrown to the caller. Use this on the semantic-dedup path so\n       * `decideSemanticDedup`'s catch block can classify the result as\n       * `reason=\"backend_unavailable\"` and activate the per-batch\n       * short-circuit.\n       *\n       * When false (the default), a timeout is caught here and search()\n       * returns [] instead — preserving fail-open semantics for the recall\n       * path (`searchEmbeddingFallback`) which has no surrounding try/catch.\n       * Without this gate a timed-out embedding request on the recall path\n       * would propagate as an unhandled rejection and abort recall entirely.\n       * (Round 10 fix, Findings Ui1J + Ui1L.)\n       */\n      throwOnTimeout?: boolean;\n    } = {},\n  ): Promise<Array<{ id: string; score: number; path: string }>> {\n    const provider = await this.resolveProvider();\n    if (!provider) return [];\n\n    let queryResult = await this.embedForSearch(query, provider, options);\n    if (!queryResult) return [];\n\n    const diskIdentity = await this.readIndexIdentityFromDisk();\n    if (diskIdentity && !sameIndexIdentity(diskIdentity, queryResult.provider)) {\n      const diskProvider = await this.resolveFallbackProviderForIndexIdentity(diskIdentity);\n      if (diskProvider) {\n        const diskQueryResult = await this.embedForSearch(query, diskProvider, options);\n        if (diskQueryResult && sameIndexIdentity(diskIdentity, diskQueryResult.provider)) {\n          queryResult = diskQueryResult;\n        } else {\n          log.debug(\n            `embedding fallback search skipped: preserved ${diskIdentity.provider}/${diskIdentity.model} index is unavailable for lookup`,\n          );\n          return [];\n        }\n      } else {\n        log.debug(\n          `embedding fallback search skipped: query provider ${queryResult.provider.type}/${queryResult.provider.model} does not match existing ${diskIdentity.provider}/${diskIdentity.model} index`,\n        );\n        return [];\n      }\n    }\n\n    const index = await this.loadIndex(queryResult.provider);\n    const ids = Object.keys(index.entries);\n    if (ids.length === 0) return [];\n\n    const includePrefix = normalizePathPrefix(options.pathPrefix);\n    const excludePrefixes = (options.pathExcludePrefixes ?? [])\n      .map((p) => normalizePathPrefix(p))\n      .filter((p): p is string => typeof p === \"string\");\n\n    const scored = ids\n      .map((id) => {\n        const entry = index.entries[id];\n        return {\n          id,\n          path: entry.path,\n          score: cosineSimilarity(queryResult.vector, entry.vector),\n        };\n      })\n      .filter((r) => {\n        if (!Number.isFinite(r.score)) return false;\n        const normalized = normalizeEntryPath(r.path);\n        if (includePrefix !== undefined && !normalized.startsWith(includePrefix)) {\n          return false;\n        }\n        for (const excl of excludePrefixes) {\n          if (normalized.startsWith(excl)) return false;\n        }\n        return true;\n      })\n      .sort((a, b) => b.score - a.score)\n      .slice(0, Math.max(1, limit));\n\n    return scored;\n  }\n\n  async indexFile(memoryId: string, content: string, filePath: string): Promise<void> {\n    const provider = await this.resolveProvider();\n    if (!provider) return;\n    // Indexing is not on the write-critical path: a newly persisted memory\n    // has already been written to disk by the time we reach this call. Use\n    // the long \"index\" timeout so slow local embedding backends can still\n    // add the entry to the index. Previously this used the short lookup\n    // budget and silently dropped updates, leaving later dedup lookups\n    // blind to the memory. Related: PR #399 P2.\n    const result = await this.embedWithEffectiveProvider(content, provider, {\n      mode: \"index\",\n    });\n    if (!result) return;\n\n    await this.enqueueIndexMutation(async () => {\n      const existing = await this.readIndexIdentityFromDisk();\n      if (\n        existing &&\n        !sameIndexIdentity(existing, result.provider) &&\n        !canReplaceIndexIdentity(existing, result.provider)\n      ) {\n        log.debug(\n          `embedding fallback index update skipped: ${result.provider.type}/${result.provider.model} would replace existing ${existing.provider}/${existing.model} index`,\n        );\n        return;\n      }\n      const index = await this.loadIndex(result.provider);\n      const relPath = toMemoryRelativePath(this.config.memoryDir, filePath);\n      index.entries[memoryId] = {\n        vector: result.vector,\n        path: relPath,\n      };\n      await this.saveIndex(index);\n    });\n  }\n\n  async removeFromIndex(memoryId: string): Promise<void> {\n    const provider = await this.resolveProvider();\n    if (!provider) return;\n\n    await this.enqueueIndexMutation(async () => {\n      const providers = [provider];\n      const diskIdentity = await this.readIndexIdentityFromDisk();\n      if (\n        diskIdentity &&\n        !providers.some((entry) => sameIndexIdentity(entry, diskIdentity))\n      ) {\n        providers.push(providerFromIndexIdentity(diskIdentity));\n      }\n      if (provider.type === \"host\") {\n        const fallbackProvider = await this.resolveProvider({ includeHost: false });\n        if (\n          fallbackProvider &&\n          !providers.some((entry) => sameIndexIdentity(entry, fallbackProvider))\n        ) {\n          providers.push(fallbackProvider);\n        }\n      }\n\n      for (const indexProvider of providers) {\n        const index = await this.loadIndex(indexProvider);\n        if (!index.entries[memoryId]) continue;\n        delete index.entries[memoryId];\n        await this.saveIndex(index);\n      }\n    });\n  }\n\n  private enqueueIndexMutation<T>(mutation: () => Promise<T>): Promise<T> {\n    const run = this.mutationQueue.catch(() => undefined).then(mutation);\n    this.mutationQueue = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    return run;\n  }\n\n  private async resolveProvider(\n    options: { includeHost?: boolean } = {},\n  ): Promise<ProviderConfig | null> {\n    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) return null;\n\n    if (\n      options.includeHost !== false &&\n      this.config.hostEmbeddingProviderEnabled !== false\n    ) {\n      const hostProvider = getHostEmbeddingProvider(this.config.memoryDir);\n      if (hostProvider) {\n        return {\n          type: \"host\",\n          model: hostProvider.model || hostProvider.id,\n          hostProvider,\n        };\n      }\n    }\n\n    const preferred = this.config.embeddingFallbackProvider;\n    const providers = preferred === \"auto\" ? [\"openai\", \"local\"] : [preferred];\n\n    for (const p of providers) {\n      if (p === \"openai\") {\n        const provider = this.createOpenAiProvider();\n        if (provider) return provider;\n      }\n\n      if (p === \"local\") {\n        const provider = this.createLocalProvider();\n        if (provider) return provider;\n      }\n    }\n\n    return null;\n  }\n\n  private async resolveFallbackProviderForIndexIdentity(\n    identity: EmbeddingIndexIdentity,\n  ): Promise<ProviderConfig | null> {\n    if (identity.provider === \"openai\") {\n      const provider = this.createOpenAiProvider();\n      return provider && sameIndexIdentity(provider, identity) ? provider : null;\n    }\n    if (identity.provider === \"local\") {\n      const provider = this.createLocalProvider();\n      return provider && sameIndexIdentity(provider, identity) ? provider : null;\n    }\n    return null;\n  }\n\n  private createOpenAiProvider(): ProviderConfig | null {\n    if (!this.config.openaiApiKey) return null;\n    const baseUrl = this.config.openaiBaseUrl ?? \"https://api.openai.com/v1\";\n    return {\n      type: \"openai\",\n      model: DEFAULT_OPENAI_MODEL,\n      endpoint: `${baseUrl.replace(/\\/$/, \"\")}/embeddings`,\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${this.config.openaiApiKey}`,\n      },\n    };\n  }\n\n  private createLocalProvider(): ProviderConfig | null {\n    if (!this.config.localLlmEnabled || !this.config.localLlmUrl) return null;\n    const base = this.config.localLlmUrl.replace(/\\/$/, \"\");\n    const endpoint = /\\/v1$/i.test(base) ? `${base}/embeddings` : `${base}/v1/embeddings`;\n    const headers: Record<string, string> = {\n      \"Content-Type\": \"application/json\",\n      ...(this.config.localLlmHeaders ?? {}),\n    };\n    if (this.config.localLlmApiKey && this.config.localLlmAuthHeader !== false) {\n      headers.Authorization = `Bearer ${this.config.localLlmApiKey}`;\n    }\n    return {\n      type: \"local\",\n      model:\n        this.config.embeddingFallbackModel ||\n        this.config.localLlmModel ||\n        DEFAULT_OPENAI_MODEL,\n      endpoint,\n      headers,\n    };\n  }\n\n  private async embedForSearch(\n    query: string,\n    provider: ProviderConfig,\n    options: { throwOnTimeout?: boolean } = {},\n  ): Promise<EmbeddingResult | null> {\n    try {\n      return await this.embedWithEffectiveProvider(query, provider, {\n        mode: \"lookup\",\n      });\n    } catch (err) {\n      if (isLookupBackendUnavailableError(err)) {\n        if (options.throwOnTimeout) {\n          throw err;\n        }\n        // Fail-open: recall-path callers get an empty result rather than an\n        // unhandled rejection that would abort recall entirely.\n        log.debug(\"embedding fallback search: backend unavailable on lookup, returning [] (throwOnTimeout=false)\");\n        return null;\n      }\n      throw err;\n    }\n  }\n\n  private async embed(\n    input: string,\n    provider: ProviderConfig,\n    options: { mode?: EmbedMode } = {},\n  ): Promise<number[] | null> {\n    const result = await this.embedWithEffectiveProvider(input, provider, options);\n    return result?.vector ?? null;\n  }\n\n  private async embedWithEffectiveProvider(\n    input: string,\n    provider: ProviderConfig,\n    options: { mode?: EmbedMode } = {},\n  ): Promise<EmbeddingResult | null> {\n    // Bound the fetch so a hung embedding endpoint cannot stall callers.\n    // The lookup path uses a short budget (see DEFAULT_EMBEDDING_LOOKUP_TIMEOUT_MS\n    // docblock) so semantic dedup fails open fast. The index path uses a\n    // much longer budget because slow local backends (CPU embedding models)\n    // otherwise drop index updates and blind later dedup lookups. See\n    // DEFAULT_EMBEDDING_INDEX_TIMEOUT_MS docblock and PR #399 P2 review.\n    const mode: EmbedMode = options.mode ?? \"lookup\";\n    const timeoutMs =\n      mode === \"index\"\n        ? resolveEmbeddingIndexTimeoutMs()\n        : resolveEmbeddingLookupTimeoutMs();\n    if (provider.type === \"host\") {\n      const vector = await this.embedWithHostProvider(input, provider, mode, timeoutMs);\n      if (vector) return { provider, vector };\n      const fallbackProvider = await this.resolveProvider({ includeHost: false });\n      if (!fallbackProvider) {\n        if (mode === \"lookup\") {\n          throw new EmbeddingProviderUnavailableError(\n            `host embedding provider unavailable (${provider.hostProvider?.id ?? provider.model})`,\n          );\n        }\n        return null;\n      }\n      return this.embedWithEffectiveProvider(input, fallbackProvider, options);\n    }\n    if (!provider.endpoint || !provider.headers) return null;\n    try {\n      const res = await fetch(provider.endpoint, {\n        method: \"POST\",\n        headers: provider.headers,\n        body: JSON.stringify({\n          model: provider.model,\n          input: input.slice(0, 8000),\n          encoding_format: \"float\",\n        }),\n        signal: AbortSignal.timeout(timeoutMs),\n      });\n      if (!res.ok) {\n        log.debug(`embedding fallback request failed: ${provider.type} ${res.status}`);\n        // Round 11 fix (Finding Ur_J): on the LOOKUP path, a non-2xx response\n        // means the embedding backend is effectively unavailable. Throw the\n        // tagged error so search() (when called with throwOnTimeout) propagates\n        // to decideSemanticDedup's backend_unavailable branch, activating the\n        // per-batch short-circuit. Without this, repeated 429/5xx responses\n        // would silently return [] for every fact in the batch.\n        //\n        // On the INDEX path a non-2xx is non-fatal (the memory is already\n        // persisted; index update can be skipped) — return null there.\n        if (mode === \"lookup\") {\n          throw new EmbeddingTimeoutError(\n            `embedding backend returned ${res.status} (${provider.type})`,\n          );\n        }\n        return null;\n      }\n      const payload = (await res.json()) as any;\n      const vector = payload?.data?.[0]?.embedding;\n      if (!Array.isArray(vector)) return null;\n      const normalized = vector\n        .map((n: unknown) => Number(n))\n        .filter((n: number) => Number.isFinite(n));\n      return normalized.length > 0 ? { provider, vector: normalized } : null;\n    } catch (err) {\n      // Round 11 (Finding Ur_J): the !res.ok branch above throws\n      // EmbeddingTimeoutError directly. Re-throw it here so the catch does\n      // not swallow our own intentional signal back into a null return.\n      if (isLookupBackendUnavailableError(err)) {\n        throw err;\n      }\n      // AbortSignal.timeout throws a DOMException with name \"TimeoutError\";\n      // surface at warn level so operators can distinguish slow backends from\n      // generic errors.\n      const isTimeout =\n        err instanceof Error &&\n        (err.name === \"TimeoutError\" || err.name === \"AbortError\");\n      if (isTimeout) {\n        log.warn(\n          `embedding fallback fetch timed out after ${timeoutMs}ms (${provider.type}, mode=${mode})`,\n        );\n        // Round 9 fix (Finding UZqB): on the LOOKUP path a timeout means the\n        // embedding backend is effectively unavailable — re-throw so that\n        // search() propagates the error to semanticDedupLookup, which lets it\n        // reach decideSemanticDedup's catch block and return\n        // reason=\"backend_unavailable\". Without this, search() would silently\n        // return [] and the per-batch batchBackendUnavailable flag would never\n        // flip, causing subsequent facts in the same batch to each pay a full\n        // timeout roundtrip (N × timeout instead of 1 × timeout).\n        //\n        // On the INDEX path a timeout is not fatal (the memory is already\n        // persisted; index update can be skipped) — return null there so\n        // indexFile() stays non-blocking.\n        if (mode === \"lookup\") {\n          throw new EmbeddingTimeoutError(\n            `embedding backend timed out after ${timeoutMs}ms (${provider.type})`,\n          );\n        }\n      } else {\n        // Round 12 fix (PR #399 thread PRRT_kwDORJXyws56U6Gi): non-timeout\n        // transport failures (ECONNREFUSED, DNS errors, TLS failures) are just\n        // as fatal as timeouts on the LOOKUP path — the embedding backend is\n        // effectively unreachable. Throw EmbeddingTimeoutError so that\n        // search() (when called with throwOnTimeout:true) propagates the error\n        // to decideSemanticDedup's backend_unavailable branch, activating the\n        // per-batch short-circuit. Without this, each fact in the batch would\n        // pay a full ECONNREFUSED roundtrip and return null → [] → no_candidates,\n        // preventing batchBackendUnavailable from ever being set.\n        //\n        // On the INDEX path a transport failure is non-fatal — the memory is\n        // already persisted; index update can be safely skipped.\n        if (mode === \"lookup\") {\n          log.warn(\n            `embedding fallback transport error on lookup path (${provider.type}): ${err}`,\n          );\n          throw new EmbeddingTimeoutError(\n            `embedding backend transport failure (${provider.type}): ${err instanceof Error ? err.message : String(err)}`,\n          );\n        }\n        log.debug(`embedding fallback error: ${err}`);\n      }\n      return null;\n    }\n  }\n\n  private async embedWithHostProvider(\n    input: string,\n    provider: ProviderConfig,\n    mode: EmbedMode,\n    timeoutMs: number,\n  ): Promise<number[] | null> {\n    const hostProvider = provider.hostProvider;\n    if (!hostProvider) return null;\n    try {\n      const vector = await hostProvider.embed(input.slice(0, 8000), {\n        signal: AbortSignal.timeout(timeoutMs),\n        inputType: mode === \"lookup\" ? \"query\" : \"document\",\n      });\n      return normalizeHostEmbeddingVector(vector);\n    } catch (err) {\n      log.debug(`host embedding provider error: ${hostProvider.id}: ${err}`);\n      return null;\n    }\n  }\n\n  private async loadIndex(provider: ProviderConfig): Promise<EmbeddingIndexFile> {\n    if (this.loaded && this.loaded.provider === provider.type && this.loaded.model === provider.model) {\n      return this.loaded;\n    }\n\n    try {\n      const raw = await readFile(this.indexPath, \"utf-8\");\n      const parsed = JSON.parse(raw) as EmbeddingIndexFile;\n      if (\n        parsed &&\n        parsed.version === 1 &&\n        parsed.provider === provider.type &&\n        parsed.model === provider.model &&\n        parsed.entries &&\n        typeof parsed.entries === \"object\"\n      ) {\n        this.loaded = {\n          version: 1,\n          provider: provider.type,\n          model: provider.model,\n          entries: parsed.entries,\n        };\n        return this.loaded;\n      }\n    } catch {\n      // ignore and create a new index\n    }\n\n    this.loaded = {\n      version: 1,\n      provider: provider.type,\n      model: provider.model,\n      entries: {},\n    };\n    return this.loaded;\n  }\n\n  private async readIndexIdentityFromDisk(): Promise<EmbeddingIndexIdentity | null> {\n    try {\n      const raw = await readFile(this.indexPath, \"utf-8\");\n      const parsed = JSON.parse(raw) as Partial<EmbeddingIndexFile> | null;\n      if (\n        parsed &&\n        parsed.version === 1 &&\n        (parsed.provider === \"openai\" ||\n          parsed.provider === \"local\" ||\n          parsed.provider === \"host\") &&\n        typeof parsed.model === \"string\" &&\n        parsed.model.length > 0\n      ) {\n        return {\n          provider: parsed.provider,\n          model: parsed.model,\n        };\n      }\n    } catch {\n      // Missing or invalid indexes are treated as absent; loadIndex() owns\n      // creating a fresh file when it is safe to write.\n    }\n    return null;\n  }\n\n  private async saveIndex(index: EmbeddingIndexFile): Promise<void> {\n    const dir = path.dirname(this.indexPath);\n    await mkdir(dir, { recursive: true });\n    const tempPath = path.join(\n      dir,\n      `.embeddings.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`,\n    );\n    try {\n      await writeFile(tempPath, JSON.stringify(index), \"utf-8\");\n      await rename(tempPath, this.indexPath);\n    } catch (err) {\n      await rm(tempPath, { force: true }).catch(() => undefined);\n      throw err;\n    }\n    this.loaded = index;\n  }\n}\n\nfunction toMemoryRelativePath(memoryDir: string, filePath: string): string {\n  if (!path.isAbsolute(filePath)) return filePath;\n  const rel = path.relative(memoryDir, filePath);\n  return rel.startsWith(\"..\") ? filePath : rel;\n}\n\n/**\n * Normalize an index entry path to forward-slashes for stable prefix\n * comparison. Entries are stored as `path.relative(memoryDir, …)` output,\n * which on Windows uses back-slashes. Normalize both sides so prefix\n * matching is OS-independent.\n *\n * Also strip a leading `./` so this helper's output is symmetric with\n * `normalizePathPrefix` below. `toMemoryRelativePath` is a pass-through for\n * non-absolute filePath inputs, so an index entry could legitimately carry a\n * stored path like `\"./namespaces/alpha/facts/f.md\"`. Without this strip, a\n * caller-supplied prefix `\"./namespaces/alpha\"` (which `normalizePathPrefix`\n * rewrites to `\"namespaces/alpha/\"`) would silently miss that entry and\n * namespace-scoped dedup would either let a near-duplicate through or fail\n * to exclude a cross-namespace hit.\n */\nfunction normalizeEntryPath(p: string): string {\n  let out = p.replace(/\\\\/g, \"/\");\n  if (out.startsWith(\"./\")) out = out.slice(2);\n  return out;\n}\n\n/**\n * Normalize a caller-supplied path prefix:\n *   - Return `undefined` for nullish/empty input (no filter).\n *   - Replace back-slashes with forward-slashes.\n *   - Strip a leading `./`.\n *   - Ensure a trailing `/` so `\"namespaces/a\"` doesn't accidentally match\n *     `\"namespaces/another/…\"`.\n */\nfunction normalizePathPrefix(prefix: string | undefined): string | undefined {\n  if (prefix === undefined || prefix === null) return undefined;\n  let p = String(prefix).replace(/\\\\/g, \"/\");\n  if (p.startsWith(\"./\")) p = p.slice(2);\n  if (p.length === 0) return undefined;\n  if (!p.endsWith(\"/\")) p = `${p}/`;\n  return p;\n}\n\nfunction sameIndexIdentity(\n  left: EmbeddingIndexComparable,\n  right: EmbeddingIndexComparable,\n): boolean {\n  return indexIdentityProvider(left) === indexIdentityProvider(right) && left.model === right.model;\n}\n\nfunction indexIdentityProvider(identity: EmbeddingIndexComparable): EmbeddingProviderType {\n  return \"provider\" in identity ? identity.provider : identity.type;\n}\n\nfunction canReplaceIndexIdentity(\n  existing: EmbeddingIndexIdentity,\n  replacement: Pick<ProviderConfig, \"type\" | \"model\">,\n): boolean {\n  return existing.provider === \"host\" && !sameIndexIdentity(existing, replacement);\n}\n\nfunction providerFromIndexIdentity(identity: EmbeddingIndexIdentity): ProviderConfig {\n  return {\n    type: identity.provider,\n    model: identity.model,\n  };\n}\n\nfunction cosineSimilarity(a: number[], b: number[]): number {\n  const n = Math.min(a.length, b.length);\n  if (n === 0) return 0;\n  let dot = 0;\n  let normA = 0;\n  let normB = 0;\n  for (let i = 0; i < n; i++) {\n    const av = a[i] ?? 0;\n    const bv = b[i] ?? 0;\n    dot += av * bv;\n    normA += av * av;\n    normB += bv * bv;\n  }\n  const denom = Math.sqrt(normA) * Math.sqrt(normB);\n  if (denom === 0) return 0;\n  return dot / denom;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-K4ZNARDO.js → chunk-CBWI22JN.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-YTZ3VGC7.js";
+} from "./chunk-M4V2JVSZ.js";
 
 // src/maintenance/namespace-maintenance-fanout.ts
 var NAMESPACE_MAINTENANCE_JOBS = [
@@ -146,4 +146,4 @@ export {
   summarizeNamespaceMaintenanceHealth,
   formatNamespaceMaintenanceHealthText
 };
-//# sourceMappingURL=chunk-K4ZNARDO.js.map
+//# sourceMappingURL=chunk-CBWI22JN.js.map

package/dist/{chunk-ZOHMPFOB.js → chunk-CKFLLAIS.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-6SQQOJ4U.js";
+} from "./chunk-GKRLPHPU.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-7AG54AF3.js";
+} from "./chunk-PUR2CKX2.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-ZOHMPFOB.js.map
+//# sourceMappingURL=chunk-CKFLLAIS.js.map

package/dist/{chunk-JPUT5NGH.js → chunk-DMQWV6SQ.js}

@@ -1,6 +1,6 @@
 import {
   runPostConsolidationMaterialize
-} from "./chunk-UQSVUEN2.js";
+} from "./chunk-37436GML.js";
 import {
   discoverMemoryExtensions,
   renderExtensionsBlock,
@@ -217,4 +217,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-JPUT5NGH.js.map
+//# sourceMappingURL=chunk-DMQWV6SQ.js.map

package/dist/{chunk-F3XZN24Z.js → chunk-DRUDC2UX.js}

@@ -1,6 +1,6 @@
 import {
   isRecallDisclosure
-} from "./chunk-7AG54AF3.js";
+} from "./chunk-PUR2CKX2.js";
 import {
   normalizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -292,4 +292,4 @@ export {
   RecallXrayBuilder,
   summarizeDisclosureTokens
 };
-//# sourceMappingURL=chunk-F3XZN24Z.js.map
+//# sourceMappingURL=chunk-DRUDC2UX.js.map

package/dist/{chunk-KJR66XOM.js → chunk-EY6MDMHK.js}

@@ -1,7 +1,7 @@
 import {
   StorageManager,
   normalizeEntityName
-} from "./chunk-MQVKHFIU.js";
+} from "./chunk-7RLCCNHU.js";
 import {
   serializeMutations
 } from "./chunk-LTJAMRGI.js";
@@ -956,4 +956,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-KJR66XOM.js.map
+//# sourceMappingURL=chunk-EY6MDMHK.js.map

package/dist/{chunk-3TUT4PWB.js → chunk-FVZ2ISIX.js}

@@ -1,6 +1,6 @@
 import {
   isValidCapsuleSince
-} from "./chunk-5W7CTZ2E.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -441,4 +441,4 @@ export {
   actionConfidenceRequestSchema,
   validateRequest
 };
-//# sourceMappingURL=chunk-3TUT4PWB.js.map
+//# sourceMappingURL=chunk-FVZ2ISIX.js.map

package/dist/{chunk-C4X4QGIO.js → chunk-G6NKALRN.js}

@@ -1,4 +1,5 @@
 import {
+  coerceBool,
   coerceNumber
 } from "./chunk-PHK3HARR.js";
 
@@ -38,12 +39,14 @@ function parseFaithfulnessGateConfig(cfg) {
     parseIntegerAtLeast(cfg.extractionFaithfulnessTimeoutMs, 8e3, 1, "extractionFaithfulnessTimeoutMs"),
     6e4
   );
+  const extractionFaithfulnessLocalParseFallback = coerceBool(cfg.extractionFaithfulnessLocalParseFallback) === true;
   return {
     extractionFaithfulnessGate,
     extractionFaithfulnessModel,
     extractionFaithfulnessBaseUrl,
     extractionFaithfulnessContextChars,
-    extractionFaithfulnessTimeoutMs
+    extractionFaithfulnessTimeoutMs,
+    extractionFaithfulnessLocalParseFallback
   };
 }
 function parseCorrectionIntentConfig(cfg) {
@@ -57,4 +60,4 @@ export {
   parseFaithfulnessGateConfig,
   parseCorrectionIntentConfig
 };
-//# sourceMappingURL=chunk-C4X4QGIO.js.map
+//# sourceMappingURL=chunk-G6NKALRN.js.map

package/dist/chunk-G6NKALRN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/faithfulness-config.ts"],"sourcesContent":["/**\n * Faithfulness-gate + correction-intent config parsing (issue #1576 / #1585).\n *\n * Extracted verbatim from `config.ts` (a watchlisted god file) so the gate\n * config block can grow — the model-lab pointer keys\n * `extractionFaithfulnessBaseUrl` (#1585) and the correction-intent pointers\n * (`correctionIntentModel` / `correctionIntentBaseUrl`) — without growing the\n * god file. This is a behavior-preserving extraction (#1526-style): the\n * validation, defaults, and error messages are byte-identical to the inline\n * block it replaces, which the existing extraction-faithfulness + config\n * tests pin.\n *\n * Why a dedicated module (and not inline): the ratchet\n * (`scripts/check-ratchets.mjs`) forbids `config.ts` from growing, and the\n * model-lab integration needs three new optional keys. Centralizing the whole\n * gate+intent parsing here keeps it unit-testable in isolation and lets\n * `config.ts` spread the result in one line.\n */\n\nimport { coerceBool, coerceNumber } from \"./connectors/coerce.js\";\n\n/**\n * Parse a value as a strict integer >= `min`, throwing on anything else.\n *\n * Mirrors `parseIntegerAtLeast` in `config.ts` byte-for-byte (issue #1634:\n * reject non-numeric, <=0, non-integer, NaN, Infinity, booleans, objects —\n * gotcha #51). Reimplemented locally rather than exported from `config.ts`\n * so this module has no dependency on the god file (and vice versa).\n */\nfunction parseIntegerAtLeast(\n  value: unknown,\n  fallback: number,\n  min: number,\n  keyName: string,\n): number {\n  if (value === undefined || value === null) return fallback;\n  const coerced = coerceNumber(value);\n  if (\n    coerced === undefined ||\n    !Number.isFinite(coerced) ||\n    !Number.isInteger(coerced) ||\n    coerced < min\n  ) {\n    throw new Error(\n      `${keyName} must be an integer greater than or equal to ${min}; got ${JSON.stringify(value)}`,\n    );\n  }\n  return coerced;\n}\n\n/**\n * Parse the extraction faithfulness gate config block.\n *\n * Returns exactly the `PluginConfig` fields this block owns. Defaults preserve\n * the byte-identical pre-feature pipeline (rule 39): gate \"off\", empty model\n * + base URL, context 400 chars, timeout 8000 ms. Invalid `gate` values reject\n * listing valid options (rule 51); invalid integers throw (issue #1634).\n *\n * `extractionFaithfulnessBaseUrl` (issue #1585) is the model-lab pointer: when\n * set together with `extractionFaithfulnessModel`, the gate routes to that\n * local openai-compatible endpoint before the configured chain; empty string\n * (default) preserves the existing routing exactly.\n */\nexport function parseFaithfulnessGateConfig(cfg: Record<string, unknown>): {\n  extractionFaithfulnessGate: \"off\" | \"shadow\" | \"enforce\";\n  extractionFaithfulnessModel: string;\n  extractionFaithfulnessBaseUrl: string;\n  extractionFaithfulnessContextChars: number;\n  extractionFaithfulnessTimeoutMs: number;\n  extractionFaithfulnessLocalParseFallback: boolean;\n} {\n  const gateValue = cfg.extractionFaithfulnessGate;\n  let extractionFaithfulnessGate: \"off\" | \"shadow\" | \"enforce\";\n  if (gateValue === undefined || gateValue === null) {\n    extractionFaithfulnessGate = \"off\";\n  } else {\n    // Present-but-invalid (true/1/{}) must reject, not silently disable the gate (Ob4RQ).\n    const raw = typeof gateValue === \"string\" ? gateValue.trim().toLowerCase() : gateValue;\n    if (raw === \"off\" || raw === \"shadow\" || raw === \"enforce\") {\n      extractionFaithfulnessGate = raw;\n    } else {\n      throw new Error(\n        `extractionFaithfulnessGate must be one of \"off\" | \"shadow\" | \"enforce\" (got ${JSON.stringify(gateValue)})`,\n      );\n    }\n  }\n\n  const extractionFaithfulnessModel =\n    typeof cfg.extractionFaithfulnessModel === \"string\" ? cfg.extractionFaithfulnessModel : \"\";\n\n  // Issue #1585: model-lab pointer. Empty default → gate uses its existing\n  // routing chain (byte-identical). Non-empty + a model name → gate prefers\n  // the local served endpoint, falling back to the chain on failure.\n  const extractionFaithfulnessBaseUrl =\n    typeof cfg.extractionFaithfulnessBaseUrl === \"string\"\n      ? cfg.extractionFaithfulnessBaseUrl\n      : \"\";\n\n  const extractionFaithfulnessContextChars = Math.min(\n    parseIntegerAtLeast(cfg.extractionFaithfulnessContextChars, 400, 1, \"extractionFaithfulnessContextChars\"),\n    4000,\n  );\n\n  const extractionFaithfulnessTimeoutMs = Math.min(\n    parseIntegerAtLeast(cfg.extractionFaithfulnessTimeoutMs, 8000, 1, \"extractionFaithfulnessTimeoutMs\"),\n    60_000,\n  );\n\n  // Issue #1700 nit #6: resilient-fallback toggle for the local model-lab\n  // endpoint. Default false preserves the loud-signal behavior (a 200-with-\n  // garbage local response surfaces malformed_output so a misconfigured\n  // endpoint is visible); true falls back to the configured chain on local\n  // parse failure. Byte-identical pre-feature when unset (rule 39).\n  // coerceBool for CLI-string parity: a CLI override like\n  // --config extractionFaithfulnessLocalParseFallback=true reaches here as the\n  // string \"true\"; === true would silently leave the flag disabled. Matches\n  // every other CLI-settable boolean in config.ts (gotcha 36, codex P2\n  // PRRT_kwDORJXyws6O6gDQ / cursor BUGBOT e273b22c).\n  const extractionFaithfulnessLocalParseFallback =\n    coerceBool(cfg.extractionFaithfulnessLocalParseFallback) === true;\n\n  return {\n    extractionFaithfulnessGate,\n    extractionFaithfulnessModel,\n    extractionFaithfulnessBaseUrl,\n    extractionFaithfulnessContextChars,\n    extractionFaithfulnessTimeoutMs,\n    extractionFaithfulnessLocalParseFallback,\n  };\n}\n\n/**\n * Parse the correction-intent config block (issue #1581 / #1585).\n *\n * The model-lab pointer for passive-correction detection: when both\n * `correctionIntentModel` and `correctionIntentBaseUrl` are set, the detection\n * path can route to that local fine-tuned classifier; empty defaults (the\n * common case) keep the rule-based `detectPassiveCorrections` heuristic as the\n * sole detector — byte-identical to the pre-feature path. Consumption by the\n * detector is the consuming child's job (#1581's detector is a pure function;\n * wiring a model call into it is out of scope for this config-pointer PR).\n */\nexport function parseCorrectionIntentConfig(cfg: Record<string, unknown>): {\n  correctionIntentModel: string;\n  correctionIntentBaseUrl: string;\n} {\n  return {\n    correctionIntentModel:\n      typeof cfg.correctionIntentModel === \"string\" ? cfg.correctionIntentModel : \"\",\n    correctionIntentBaseUrl:\n      typeof cfg.correctionIntentBaseUrl === \"string\" ? cfg.correctionIntentBaseUrl : \"\",\n  };\n}\n"],"mappings":";;;;;;AA6BA,SAAS,oBACP,OACA,UACA,KACA,SACQ;AACR,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,QAAM,UAAU,aAAa,KAAK;AAClC,MACE,YAAY,UACZ,CAAC,OAAO,SAAS,OAAO,KACxB,CAAC,OAAO,UAAU,OAAO,KACzB,UAAU,KACV;AACA,UAAM,IAAI;AAAA,MACR,GAAG,OAAO,gDAAgD,GAAG,SAAS,KAAK,UAAU,KAAK,CAAC;AAAA,IAC7F;AAAA,EACF;AACA,SAAO;AACT;AAeO,SAAS,4BAA4B,KAO1C;AACA,QAAM,YAAY,IAAI;AACtB,MAAI;AACJ,MAAI,cAAc,UAAa,cAAc,MAAM;AACjD,iCAA6B;AAAA,EAC/B,OAAO;AAEL,UAAM,MAAM,OAAO,cAAc,WAAW,UAAU,KAAK,EAAE,YAAY,IAAI;AAC7E,QAAI,QAAQ,SAAS,QAAQ,YAAY,QAAQ,WAAW;AAC1D,mCAA6B;AAAA,IAC/B,OAAO;AACL,YAAM,IAAI;AAAA,QACR,+EAA+E,KAAK,UAAU,SAAS,CAAC;AAAA,MAC1G;AAAA,IACF;AAAA,EACF;AAEA,QAAM,8BACJ,OAAO,IAAI,gCAAgC,WAAW,IAAI,8BAA8B;AAK1F,QAAM,gCACJ,OAAO,IAAI,kCAAkC,WACzC,IAAI,gCACJ;AAEN,QAAM,qCAAqC,KAAK;AAAA,IAC9C,oBAAoB,IAAI,oCAAoC,KAAK,GAAG,oCAAoC;AAAA,IACxG;AAAA,EACF;AAEA,QAAM,kCAAkC,KAAK;AAAA,IAC3C,oBAAoB,IAAI,iCAAiC,KAAM,GAAG,iCAAiC;AAAA,IACnG;AAAA,EACF;AAYA,QAAM,2CACJ,WAAW,IAAI,wCAAwC,MAAM;AAE/D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAaO,SAAS,4BAA4B,KAG1C;AACA,SAAO;AAAA,IACL,uBACE,OAAO,IAAI,0BAA0B,WAAW,IAAI,wBAAwB;AAAA,IAC9E,yBACE,OAAO,IAAI,4BAA4B,WAAW,IAAI,0BAA0B;AAAA,EACpF;AACF;","names":[]}

package/dist/{chunk-6SQQOJ4U.js → chunk-GKRLPHPU.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-F3XZN24Z.js";
+} from "./chunk-DRUDC2UX.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -587,4 +587,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-6SQQOJ4U.js.map
+//# sourceMappingURL=chunk-GKRLPHPU.js.map

package/dist/{chunk-PLG6JHQS.js → chunk-H5BWGCRZ.js}

@@ -7,35 +7,30 @@ import {
 import {
   openclawReplayNormalizer
 } from "./chunk-7F7Z6MOS.js";
+import {
+  exportSqlite
+} from "./chunk-7VFZTJ7K.js";
 import {
   importMarkdownBundle
 } from "./chunk-HDDRVXX4.js";
 import {
   importSqlite
 } from "./chunk-AGNBY3VG.js";
-import {
-  backupMemoryDir
-} from "./chunk-OWHERGF2.js";
-import {
-  exportJsonBundle
-} from "./chunk-UP6MOYCB.js";
-import {
-  exportSqlite
-} from "./chunk-7VFZTJ7K.js";
 import {
   detectImportFormat
 } from "./chunk-OZKVVUJB.js";
 import {
   importJsonBundle
 } from "./chunk-2DL3OFLD.js";
+import {
+  backupMemoryDir
+} from "./chunk-2NLLXCJG.js";
+import {
+  exportJsonBundle
+} from "./chunk-UP6MOYCB.js";
 import {
   exportMarkdownBundle
 } from "./chunk-765K3SAT.js";
-import {
-  buildReplayNormalizerRegistry,
-  clampBatchSize,
-  runReplay
-} from "./chunk-HOJZMQ4J.js";
 import {
   TailscaleHelper
 } from "./chunk-EEC4PCG5.js";
@@ -43,22 +38,27 @@ import {
   WebDavServer
 } from "./chunk-PYIFUBRK.js";
 import {
-  migrateObservations
-} from "./chunk-D6RIFG4O.js";
-import {
-  rebuildMemoryLifecycleLedger
-} from "./chunk-6WAJQKBS.js";
+  buildReplayNormalizerRegistry,
+  clampBatchSize,
+  runReplay
+} from "./chunk-HOJZMQ4J.js";
 import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-V7CMKMHM.js";
+} from "./chunk-Y4YD5TYW.js";
 import {
   rebuildObservations
 } from "./chunk-LZZNTPLR.js";
 import {
   archiveObservations
 } from "./chunk-WMWVO45V.js";
+import {
+  migrateObservations
+} from "./chunk-D6RIFG4O.js";
+import {
+  rebuildMemoryLifecycleLedger
+} from "./chunk-JYLFZWUX.js";
 import {
   getBulkImportSource,
   listBulkImportSources,
@@ -70,18 +70,18 @@ import {
 } from "./chunk-GQL52GQ5.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-FO3HO52S.js";
+} from "./chunk-4H4F3BFL.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-5NWYQUQC.js";
+} from "./chunk-HOHVIVDR.js";
 import {
   resolveAgentAccessAuthToken
 } from "./chunk-TGQ2NTWH.js";
 import {
   parseXrayCliOptions
-} from "./chunk-ZOHMPFOB.js";
+} from "./chunk-CKFLLAIS.js";
 import {
   collectPatternMemories,
   explainPatternMemory,
@@ -98,12 +98,12 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-UKTDXTWX.js";
+} from "./chunk-M4AYVEWS.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-7NS7AWMZ.js";
+} from "./chunk-YGIQORJ3.js";
 import {
   GraphDashboardServer
 } from "./chunk-EZ25VE3G.js";
@@ -116,7 +116,7 @@ import {
 } from "./chunk-WIWPSQYU.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-NPL7VDM6.js";
+} from "./chunk-ASKXIAHD.js";
 import {
   getUtilityLearningStatus,
   learnUtilityPromotionWeights
@@ -130,7 +130,7 @@ import {
 } from "./chunk-QRDOSYOR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-BB57OZWC.js";
+} from "./chunk-UVPL565C.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -145,7 +145,7 @@ import {
 } from "./chunk-33JBK2XP.js";
 import {
   formatNamespaceMaintenanceHealthText
-} from "./chunk-K4ZNARDO.js";
+} from "./chunk-CBWI22JN.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -209,13 +209,13 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   parseConfig
-} from "./chunk-BIA7ELIB.js";
+} from "./chunk-36SEDFAU.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-2NBP25BG.js";
+} from "./chunk-HGNOCPZX.js";
 import {
   WearablesInputError
 } from "./chunk-7WV3F5DQ.js";
@@ -228,10 +228,10 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-TQQH2FTX.js";
+} from "./chunk-BQCHEV7O.js";
 import {
   EngramAccessService
-} from "./chunk-Q6D75LVH.js";
+} from "./chunk-UM5AWJNQ.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -243,13 +243,13 @@ import {
   parseRecallExplainFormat,
   renderRecallExplain,
   renderXray
-} from "./chunk-6SQQOJ4U.js";
+} from "./chunk-GKRLPHPU.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-BEUCACTV.js";
+} from "./chunk-4NOI577P.js";
 import {
   getTrustZoneStoreStatus,
   promoteTrustZoneRecord,
@@ -260,8 +260,9 @@ import {
 } from "./chunk-6HMYUWXR.js";
 import {
   resolveCapabilities,
-  resolveGraphConstructionCapabilities
-} from "./chunk-DVRHLN2O.js";
+  resolveGraphConstructionCapabilities,
+  resolveMemoryLifecycleCapabilities
+} from "./chunk-3RCBIOOJ.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-SQNED75R.js";
@@ -274,7 +275,7 @@ import {
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-7AG54AF3.js";
+} from "./chunk-PUR2CKX2.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -3464,7 +3465,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         console.log("=== Extraction Judge Verdict Stats ===\n");
         console.log(`Total verdicts: ${stats.total}`);
         if (stats.total === 0) {
-          if (!orchestrator.config.extractionJudgeTelemetryEnabled) {
+          if (!resolveMemoryLifecycleCapabilities(orchestrator.config).extractionJudgeTelemetry) {
             console.log(
               "\nNote: extractionJudgeTelemetryEnabled is OFF. Enable it in plugin config to collect verdict telemetry."
             );
@@ -4133,7 +4134,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
         }
         if (sourceArchive.endsWith(".enc")) {
-          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-GWVG7LGC.js");
+          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-7FJQINUR.js");
           const encDetected = await isEncryptedCapsuleFile(sourceArchive).catch(() => true);
           if (encDetected) {
             throw new Error(
@@ -4296,7 +4297,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           const { parseExportBundle } = await import("./transfer/types.js");
           let decryptedBuf;
           try {
-            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-GWVG7LGC.js");
+            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-7FJQINUR.js");
             decryptedBuf = await decryptCapsuleFileInMemory(archivePath, memoryDir);
           } catch (decErr) {
             const msg = decErr instanceof Error ? decErr.message : String(decErr);
@@ -6792,7 +6793,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           config: orchestrator.config,
           memoryDir: orchestrator.config.memoryDir,
           embeddingLookupFactory: (storage) => {
-            if (!orchestrator.config.embeddingFallbackEnabled) return void 0;
+            if (!resolveMemoryLifecycleCapabilities(orchestrator.config).embeddingFallback) return void 0;
             return async (content, limit) => {
               try {
                 return await orchestrator.semanticDedupLookup(content, limit, storage);
@@ -7505,4 +7506,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-PLG6JHQS.js.map
+//# sourceMappingURL=chunk-H5BWGCRZ.js.map