@remnic/core 9.3.726 → 9.3.728

package/src/extraction-faithfulness.ts

@@ -220,6 +220,27 @@ export function parseFaithfulnessResponse(
   return null;
 }
 
+/**
+ * True when `map` contains an entry for every integer index in
+ * [0, expectedCount). The local parse-fallback gate uses this to accept a
+ * local model-lab response only when it is COMPLETE: size alone is
+ * insufficient because a malformed response with duplicate/fractional indexes
+ * can yield expectedCount distinct map keys without covering index 0..N-1
+ * (codex P2 PRRT_kwDORJXyws6O7PfY). parseEntries now rejects non-integer
+ * indexes so the two checks agree, but the explicit coverage loop documents
+ * the invariant and stays robust to any future parser relaxation.
+ */
+function coversAllIndexes(
+  map: Map<number, ParsedFaithfulnessEntry>,
+  expectedCount: number,
+): boolean {
+  if (map.size < expectedCount) return false;
+  for (let i = 0; i < expectedCount; i++) {
+    if (!map.has(i)) return false;
+  }
+  return true;
+}
+
 function parseEntries(
   data: unknown,
   expectedCount: number,
@@ -243,7 +264,7 @@ function parseEntries(
     if (!entry || typeof entry !== "object") continue;
     const obj = entry as Record<string, unknown>;
     const idx = typeof obj.index === "number" ? obj.index : undefined;
-    if (idx === undefined || idx < 0 || idx >= expectedCount) continue;
+    if (idx === undefined || !Number.isInteger(idx) || idx < 0 || idx >= expectedCount) continue;
     const verdictRaw = typeof obj.verdict === "string" ? obj.verdict : undefined;
     if (!verdictRaw || !VALID_VERDICTS.has(verdictRaw)) continue;
     const rationale =
@@ -279,6 +300,7 @@ interface LlmCallResult {
 async function callFaithfulnessLlm(
   systemPrompt: string,
   userPrompt: string,
+  expectedCount: number,
   config: PluginConfig,
   localLlm: LocalLlmClient | null,
   fallbackLlm: FallbackLlmClient | null,
@@ -311,15 +333,44 @@ async function callFaithfulnessLlm(
     const result = await callOpenAiCompatibleChat(
       localEndpoint,
       messages,
-      { temperature: 0.1, maxTokens: 2048, responseFormatJson: true, timeoutMs: probeBudgetMs },
+      {
+        temperature: 0.1,
+        maxTokens: 2048,
+        responseFormatJson: true,
+        timeoutMs: probeBudgetMs,
+        // Forward the batch signal so the probe aborts the instant the batch
+        // budget elapses, not after probeBudgetMs (issue #1700 nit #5).
+        ...(signal ? { signal } : {}),
+      },
       fetchImpl,
     );
     if (result?.content) {
-      return { content: result.content, modelUsed: result.modelUsed };
+      // Issue #1700 nit #6: pre-validate the local endpoint response shape.
+      // Default (extractionFaithfulnessLocalParseFallback=false) returns the
+      // content as-is -- a 200-with-garbage local response surfaces
+      // malformed_output, alerting the operator to a misconfigured endpoint.
+      // When the operator opts into resilient fallback, an unparseable OR
+      // PARTIAL local response falls through to the configured chain instead
+      // of surfacing. parseFaithfulnessResponse is truthy as soon as ONE entry
+      // is valid, so accept the local response only when the parsed verdict
+      // map covers every expected index -- otherwise the missing indexes would
+      // surface as malformed_output downstream, defeating the resilient
+      // fallback (codex P2 PRRT_kwDORJXyws6O6zwZ).
+      if (!config.extractionFaithfulnessLocalParseFallback) {
+        return { content: result.content, modelUsed: result.modelUsed };
+      }
+      const parsedLocal = parseFaithfulnessResponse(result.content, expectedCount);
+      if (parsedLocal && coversAllIndexes(parsedLocal, expectedCount)) {
+        return { content: result.content, modelUsed: result.modelUsed };
+      }
+      log.debug(
+        "extraction-faithfulness: local endpoint returned incomplete/unparseable output; falling back to configured chain",
+      );
+    } else {
+      log.debug(
+        "extraction-faithfulness: local model-lab endpoint unavailable, trying configured chain",
+      );
     }
-    log.debug(
-      "extraction-faithfulness: local model-lab endpoint unavailable, trying configured chain",
-    );
   }
 
   // extractionFaithfulnessModel is the LOCAL served model's name (e.g.
@@ -532,6 +583,7 @@ export async function checkFaithfulnessBatch(
     const callPromise = callFaithfulnessLlm(
       FAITHFULNESS_SYSTEM_PROMPT,
       userPrompt,
+      checkableInputs.length,
       config,
       localLlm,
       fallbackLlm,

package/src/extraction.ts

@@ -38,6 +38,7 @@ import { normalizeProcedureSteps } from "./procedural/procedure-types.js";
 import { normalizeReasoningTrace } from "./reasoning-trace-types.js";
 import { looksLikeMechanicalTelemetryTranscript } from "./telemetry-transcript.js";
 import { buildFactProvenance, type ProvenanceTurnInput } from "./provenance.js";
+import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
 
 type ExtractionQuestion = ExtractionResult["questions"][number];
 type ExtractedFactResult = ExtractionResult["facts"][number];
@@ -1055,6 +1056,7 @@ export class ExtractionEngine {
   }
 
   async extract(turns: BufferTurn[], existingEntities?: string[]): Promise<ExtractionResult> {
+    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
 
     // Guard: skip if buffer is empty or all turns are whitespace-only
     const substantiveTurns = turns.filter((t) => t.content.trim().length > 0);
@@ -1083,7 +1085,7 @@ export class ExtractionEngine {
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
     }
     if (
-      this.config.extractionTelemetryPrefilterEnabled &&
+      lifecycleCaps.extractionTelemetryPrefilter &&
       looksLikeMechanicalTelemetryTranscript(conversation)
     ) {
       log.debug("extraction skipped — mechanical action/state telemetry without durable-memory cues");
@@ -1331,6 +1333,7 @@ export class ExtractionEngine {
    * Uses a minimal prompt to fit within local model context limits (typically 4k-8k).
    */
   private async extractWithLocalLlm(conversation: string, existingEntities?: string[]): Promise<ExtractionResult | null> {
+    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
     log.debug(
       `extractWithLocalLlm: starting extraction, localLlmEnabled=${this.shouldUseLocalLlm}, model=${this.config.localLlmModel}`,
     );
@@ -1406,7 +1409,7 @@ These are durable insights - capture them:
 - CRITICAL: Use canonical hyphenated entity names (e.g., "jane-doe" not "janedoe")
 - CRITICAL: NEVER extract the same fact twice - check for duplicates before adding to facts array
 - CRITICAL: NEVER extract cron job schedules, automation configurations, or system monitoring details (these are operational noise)
-- If uncertain about relevance, prefer NOT extracting${this.config.extractionScopeClassificationEnabled ? `
+- If uncertain about relevance, prefer NOT extracting${lifecycleCaps.extractionScopeClassification ? `
 - For each fact, set "scope" to "global" (cross-project knowledge: framework bugs, library behavior, user preferences, tool configs, general patterns) or "project" (codebase-specific: file paths, env configs, deployment details, project workarounds). When in doubt, prefer "project".` : ""}
 
 === Structured Attributes ===
@@ -1645,6 +1648,7 @@ Omit "eventTime" when the fact has no explicit temporal anchor — do NOT guess
    * Build extraction instructions shared between local and cloud LLM.
    */
   private buildExtractionInstructions(existingEntities?: string[]): string {
+    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
     return `You are a memory extraction system. Analyze the following conversation and extract durable, reusable memories.
 
 Memory categories:
@@ -1681,7 +1685,7 @@ Rules:
   * Inferred (0.40-0.69): Pattern recognition — reasonable guess from limited evidence
   * Speculative (0.00-0.39): Tentative hypothesis — weak signal, needs future confirmation. Speculative memories auto-expire after 30 days if not confirmed.${this.config.provenance?.enabled ? `
 - Source quotes: For each fact, include a "quote" field containing the EXACT verbatim words from the conversation that support the fact. Copy a contiguous span from a single speaker turn (not a paraphrase, not a summary). Cap at ~300 characters. This grounds every memory in the literal utterance that created it.` : ""}
-- For commitments: include any deadline or timeframe mentioned${this.config.extractionScopeClassificationEnabled ? `
+- For commitments: include any deadline or timeframe mentioned${lifecycleCaps.extractionScopeClassification ? `
 
 Scope classification:
 For each fact, set "scope" to one of:

package/src/faithfulness-config.ts

@@ -17,7 +17,7 @@
  * `config.ts` spread the result in one line.
  */
 
-import { coerceNumber } from "./connectors/coerce.js";
+import { coerceBool, coerceNumber } from "./connectors/coerce.js";
 
 /**
  * Parse a value as a strict integer >= `min`, throwing on anything else.
@@ -67,6 +67,7 @@ export function parseFaithfulnessGateConfig(cfg: Record<string, unknown>): {
   extractionFaithfulnessBaseUrl: string;
   extractionFaithfulnessContextChars: number;
   extractionFaithfulnessTimeoutMs: number;
+  extractionFaithfulnessLocalParseFallback: boolean;
 } {
   const gateValue = cfg.extractionFaithfulnessGate;
   let extractionFaithfulnessGate: "off" | "shadow" | "enforce";
@@ -105,12 +106,26 @@ export function parseFaithfulnessGateConfig(cfg: Record<string, unknown>): {
     60_000,
   );
 
+  // Issue #1700 nit #6: resilient-fallback toggle for the local model-lab
+  // endpoint. Default false preserves the loud-signal behavior (a 200-with-
+  // garbage local response surfaces malformed_output so a misconfigured
+  // endpoint is visible); true falls back to the configured chain on local
+  // parse failure. Byte-identical pre-feature when unset (rule 39).
+  // coerceBool for CLI-string parity: a CLI override like
+  // --config extractionFaithfulnessLocalParseFallback=true reaches here as the
+  // string "true"; === true would silently leave the flag disabled. Matches
+  // every other CLI-settable boolean in config.ts (gotcha 36, codex P2
+  // PRRT_kwDORJXyws6O6gDQ / cursor BUGBOT e273b22c).
+  const extractionFaithfulnessLocalParseFallback =
+    coerceBool(cfg.extractionFaithfulnessLocalParseFallback) === true;
+
   return {
     extractionFaithfulnessGate,
     extractionFaithfulnessModel,
     extractionFaithfulnessBaseUrl,
     extractionFaithfulnessContextChars,
     extractionFaithfulnessTimeoutMs,
+    extractionFaithfulnessLocalParseFallback,
   };
 }
 

package/src/local-model-endpoint.ts

@@ -42,10 +42,15 @@ export interface EndpointChatMessage {
 
 /** Options for a single local-endpoint chat call. */
 export interface EndpointChatOptions {
-  /** Per-call timeout in ms. The caller's batch AbortSignal is NOT forwarded
-   *  (matches the local-LLM precedent: each attempt is bounded by its own
-   *  timer so one slow server can't starve the batch). */
+  /** Per-call timeout in ms. Bounds each attempt so one slow server can't
+   *  starve the batch (matches the local-LLM precedent). */
   timeoutMs: number;
+  /** Optional batch AbortSignal forwarded into the probe (issue #1700 nit #5).
+   *  When the batch budget elapses (or the caller aborts), the in-flight probe
+   *  aborts immediately instead of waiting for its own `timeoutMs` — a
+   *  micro-optimization, not a correctness fix (the outer race already bounds
+   *  the total). Undefined preserves the prior per-attempt-only behavior. */
+  signal?: AbortSignal;
   /** Sampling temperature — classification wants low entropy (0.0–0.2). */
   temperature?: number;
   /** Max output tokens. */
@@ -119,6 +124,21 @@ export async function callOpenAiCompatibleChat(
   const url = joinBaseUrl(endpoint.baseUrl, "/chat/completions");
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), options.timeoutMs);
+  // Forward the batch AbortSignal into the probe (issue #1700 nit #5): if the
+  // batch budget already elapsed, abort the in-flight probe immediately rather
+  // than waiting for the probe's own timeoutMs. AbortSignal.any is ES2024
+  // (forbidden here); wire the listener manually + guard the already-aborted
+  // case. The fetch still uses the probe's controller, so clearing the timer
+  // below is the only cleanup needed.
+  const batchSignal = options.signal;
+  const onBatchAbort = () => controller.abort();
+  if (batchSignal) {
+    if (batchSignal.aborted) {
+      controller.abort();
+    } else {
+      batchSignal.addEventListener("abort", onBatchAbort, { once: true });
+    }
+  }
   try {
     const body: Record<string, unknown> = {
       model: endpoint.model,
@@ -150,6 +170,7 @@ export async function callOpenAiCompatibleChat(
     return { content, modelUsed: extractModel(parsed) ?? endpoint.model };
   } finally {
     clearTimeout(timer);
+    if (batchSignal) batchSignal.removeEventListener("abort", onBatchAbort);
   }
 }
 

package/src/maintenance/first-start-migration.ts

@@ -18,6 +18,7 @@
 
 import path from "node:path";
 import { access, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { resolveMemoryLifecycleCapabilities } from "../capabilities.js";
 import type { StorageManager } from "../storage.js";
 import type { PluginConfig } from "../types.js";
 import {
@@ -179,6 +180,7 @@ export async function runFirstStartMigration(
     signal,
   } = options;
   const now = (options.now ?? (() => new Date()))();
+  const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
   const abortedResult = (candidateCount = 0, demotedCount = 0, failureCount = 0): FirstStartMigrationResult => ({
     skipped: candidateCount === 0 && demotedCount === 0 && failureCount === 0,
     skipReason: candidateCount === 0 && demotedCount === 0 && failureCount === 0 ? "aborted" : undefined,
@@ -193,7 +195,7 @@ export async function runFirstStartMigration(
     return abortedResult();
   }
 
-  if (!config.lifecyclePolicyEnabled) {
+  if (!lifecycleCaps.lifecyclePolicy) {
     return {
       skipped: true,
       skipReason: "lifecyclePolicyEnabled is false",