@remnic/core 9.3.612 → 9.3.614

package/src/cross-namespace-budget.test.ts

@@ -40,18 +40,47 @@ test("enabled budget warns past soft and denies past hard", () => {
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 2,
-    hardLimit: 3,
+    hardLimit: 4,
     windowMs: 10_000,
   });
   assert.equal(limiter.record("p1", 1).reason, "allowed-under-soft");
   assert.equal(limiter.record("p1", 2).reason, "allowed-under-soft");
   assert.equal(limiter.record("p1", 3).reason, "warn-over-soft");
-  // 4th call crosses hardLimit (count would be 4 > 3) => deny.
+  // 4th call reaches hardLimit and is denied.
   const deny = limiter.record("p1", 4);
   assert.equal(deny.allowed, false);
   assert.equal(deny.reason, "deny-over-hard");
 });
 
+test("enabled budget denies the threshold-crossing hard-limit request", () => {
+  const limiter = new CrossNamespaceBudget({
+    enabled: true,
+    softLimit: 0,
+    hardLimit: 2,
+    windowMs: 10_000,
+  });
+
+  const first = limiter.record("p1", 1);
+  assert.equal(first.allowed, true);
+  assert.equal(first.reason, "warn-over-soft");
+  assert.equal(first.count, 1);
+
+  const beforeSecond = limiter.peek({
+    principal: "p1",
+    principalNamespace: "alice",
+    queryNamespace: "bob",
+    now: 2,
+  });
+  assert.equal(beforeSecond.allowed, false);
+  assert.equal(beforeSecond.reason, "deny-over-hard");
+  assert.equal(beforeSecond.count, 1);
+
+  const second = limiter.record("p1", 2);
+  assert.equal(second.allowed, false);
+  assert.equal(second.reason, "deny-over-hard");
+  assert.equal(second.count, 1);
+});
+
 test("sliding window drops old timestamps", () => {
   const limiter = new CrossNamespaceBudget({
     enabled: true,
@@ -61,10 +90,9 @@ test("sliding window drops old timestamps", () => {
   });
   // Fill to hard.
   limiter.record("p1", 0);
-  limiter.record("p1", 50);
-  assert.equal(limiter.record("p1", 80).reason, "deny-over-hard");
+  assert.equal(limiter.record("p1", 50).reason, "deny-over-hard");
 
-  // Walk past the window so the first two slide out.
+  // Walk past the window so the first allowed timestamp slides out.
   const d = limiter.record("p1", 201);
   assert.equal(d.allowed, true);
   assert.equal(d.reason, "allowed-under-soft");
@@ -75,7 +103,7 @@ test("per-principal isolation: one principal's denial does not affect another",
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 1,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 10_000,
   });
   limiter.record("alice", 10);
@@ -107,7 +135,7 @@ test("check() engages on cross-namespace", () => {
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 1,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 10_000,
   });
   const d1 = limiter.check({
@@ -131,7 +159,7 @@ test("denied calls do not push bucket forward", () => {
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 1,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 100,
   });
   limiter.record("p1", 0);
@@ -150,7 +178,7 @@ test("missing principal is bucketed under __anonymous__ rather than failing open
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 0,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 10_000,
   });
   // An empty-string principal shares the anonymous bucket.
@@ -168,8 +196,7 @@ test("reset clears all state", () => {
     windowMs: 10_000,
   });
   limiter.record("p1", 1);
-  limiter.record("p1", 2);
-  assert.equal(limiter.record("p1", 3).reason, "deny-over-hard");
+  assert.equal(limiter.record("p1", 2).reason, "deny-over-hard");
   limiter.reset();
   const after = limiter.record("p1", 4);
   assert.equal(after.allowed, true);
@@ -231,7 +258,7 @@ test("record() normalizes non-finite clocks before mutating limiter state", () =
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 1,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 100,
   });
 
@@ -254,7 +281,7 @@ test("peek() with a non-finite clock is read-only and does not poison state", ()
   const limiter = new CrossNamespaceBudget({
     enabled: true,
     softLimit: 0,
-    hardLimit: 1,
+    hardLimit: 2,
     windowMs: 100,
   });
 
@@ -293,14 +320,10 @@ test("bucket is evicted after a denial rolls the only timestamp back", () => {
     hardLimit: 1,
     windowMs: 100,
   });
-  limiter.record("p1", 0);
-  // Denial at t=150 after the earlier timestamp has slid out. The
-  // timestamp just added gets rolled back; bucket becomes empty; must
-  // be evicted.
-  limiter.record("p1", 150);
-  // (wait — the above is allowed because the earlier timestamp slid out.)
-  // Force a deny path differently:
-  assert.equal(limiter.bucketCount(), 1);
+  const denied = limiter.record("p1", 0);
+  assert.equal(denied.allowed, false);
+  assert.equal(denied.reason, "deny-over-hard");
+  assert.equal(limiter.bucketCount(), 0);
 });
 
 test("check() does NOT fail-open when both namespaces are empty or undefined", () => {

package/src/cross-namespace-budget.ts

@@ -207,7 +207,7 @@ export class CrossNamespaceBudget {
     this.buckets.set(principal, bucket);
     const count = bucket.timestamps.length;
 
-    if (count > hardLimit) {
+    if (count >= hardLimit) {
       // Denied: roll back the timestamp we just added so a repeated denied
       // call does not push the bucket further into the future. This keeps
       // the limiter stateless with respect to denied attempts.
@@ -290,7 +290,7 @@ export class CrossNamespaceBudget {
       if (ts >= cutoff) liveCount++;
     }
     const projected = liveCount + 1; // +1 for the current call
-    if (projected > hardLimit) {
+    if (projected >= hardLimit) {
       return { allowed: false, reason: "deny-over-hard", count: liveCount, limit };
     }
     if (projected > softLimit) {

package/src/enrichment/pipeline.ts

@@ -32,12 +32,12 @@ interface RateLimitBucket {
 
 const rateBuckets = new Map<string, RateLimitBucket>();
 
-function isRateLimited(
+function reserveRateLimitSlot(
   provider: EnrichmentProvider,
   config: EnrichmentPipelineConfig,
 ): boolean {
   const providerCfg = config.providers.find((p) => p.id === provider.id);
-  if (!providerCfg?.rateLimit) return false;
+  if (!providerCfg?.rateLimit) return true;
 
   const now = Date.now();
   let bucket = rateBuckets.get(provider.id);
@@ -62,17 +62,13 @@ function isRateLimited(
   }
 
   const { maxPerMinute, maxPerDay } = providerCfg.rateLimit;
-  return bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay;
-}
-
-function recordCall(
-  providerId: string,
-): void {
-  const bucket = rateBuckets.get(providerId);
-  if (bucket) {
-    bucket.minuteCount += 1;
-    bucket.dayCount += 1;
+  if (bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay) {
+    return false;
   }
+
+  bucket.minuteCount += 1;
+  bucket.dayCount += 1;
+  return true;
 }
 
 // ---------------------------------------------------------------------------
@@ -129,8 +125,9 @@ export async function runEnrichmentPipeline(
         continue;
       }
 
-      // Check rate limit
-      if (isRateLimited(provider, config)) {
+      // Reserve quota before the awaited provider call so concurrent pipelines
+      // cannot all pass the same pre-await rate-limit check.
+      if (!reserveRateLimitSlot(provider, config)) {
         log.debug?.(
           `enrichment: skipping provider ${provider.id} for ${entity.name} — rate limited`,
         );
@@ -154,7 +151,6 @@ export async function runEnrichmentPipeline(
       try {
         candidates = await provider.enrich(entity);
       } catch (err) {
-        recordCall(provider.id);
         log.error?.(
           `enrichment: provider ${provider.id} failed for ${entity.name}: ${err instanceof Error ? err.message : String(err)}`,
         );
@@ -169,7 +165,6 @@ export async function runEnrichmentPipeline(
         });
         continue;
       }
-      recordCall(provider.id);
 
       // Tag each candidate with provider id
       for (const candidate of candidates) {

package/src/evals.ts

@@ -359,7 +359,7 @@ export function validateEvalBenchmarkManifest(
 
   return {
     schemaVersion: 1,
-    benchmarkId: assertString(raw.benchmarkId, "benchmarkId"),
+    benchmarkId: assertSafeBenchmarkId(assertString(raw.benchmarkId, "benchmarkId")),
     benchmarkType,
     title: assertString(raw.title, "title"),
     description:

package/src/extraction-judge-chain.test.ts

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { judgeFactDurability } from "./extraction-judge.js";
+import type { FallbackLlmClient } from "./fallback-llm.js";
+
+// Regression for cursor review on #1425: the extraction judge must route gateway
+// fallback calls through the SAME precedence as ExtractionEngine.withGatewayAgent
+// — taskModelChain wins over gatewayAgentId — so judge-gated extractions use the
+// configured task chain instead of silently using the persona/default chain.
+
+function captureLlm(captured: Array<Record<string, unknown>>): FallbackLlmClient {
+  return {
+    isAvailable: () => true,
+    chatCompletion: async (_messages: unknown, options: Record<string, unknown>) => {
+      captured.push(options);
+      // A parseable batch verdict so the judge doesn't error after the call.
+      return { content: JSON.stringify([{ index: 0, durable: true, reason: "ok" }]) };
+    },
+  } as unknown as FallbackLlmClient;
+}
+
+// "preference" is not auto-approved (only "correction"/"principle" are), so a
+// non-critical preference candidate reaches the LLM path.
+const candidate = { text: "user prefers dark mode", category: "preference", confidence: 0.5 };
+
+test("judge forwards taskModelChain to the fallback LLM in gateway mode", async () => {
+  const config = parseConfig({
+    modelSource: "gateway",
+    gatewayAgentId: "persona-agent",
+    taskModelChain: { primary: "zai/glm-4.7-flash", fallbacks: ["fireworks/x/glm-5p1"] },
+  });
+  const captured: Array<Record<string, unknown>> = [];
+
+  await judgeFactDurability([candidate], config, null, captureLlm(captured), new Map(), new Map());
+
+  assert.equal(captured.length, 1, "judge should call the fallback LLM once");
+  assert.deepEqual(captured[0]?.modelChain, {
+    primary: "zai/glm-4.7-flash",
+    fallbacks: ["fireworks/x/glm-5p1"],
+  });
+  assert.equal(captured[0]?.agentId, undefined, "taskModelChain takes precedence over gatewayAgentId");
+});
+
+test("judge falls back to gatewayAgentId when no taskModelChain is set", async () => {
+  const config = parseConfig({ modelSource: "gateway", gatewayAgentId: "persona-agent" });
+  const captured: Array<Record<string, unknown>> = [];
+
+  await judgeFactDurability([candidate], config, null, captureLlm(captured), new Map(), new Map());
+
+  assert.equal(captured.length, 1);
+  assert.equal(captured[0]?.agentId, "persona-agent");
+  assert.equal(captured[0]?.modelChain, undefined);
+});

package/src/extraction-judge.ts

@@ -17,7 +17,7 @@ import { createHash } from "node:crypto";
 import { log } from "./logger.js";
 import type { PluginConfig, ImportanceLevel } from "./types.js";
 import type { LocalLlmClient } from "./local-llm.js";
-import type { FallbackLlmClient } from "./fallback-llm.js";
+import { type FallbackLlmClient, gatewayTaskChainOptions } from "./fallback-llm.js";
 import { extractJsonCandidates } from "./json-extract.js";
 import { normalizeProcedureSteps } from "./procedural/procedure-types.js";
 
@@ -656,13 +656,11 @@ async function callJudgeLlm(
   // routing preference.
   const skipLocal = config.modelSource === "gateway";
 
-  // Resolve the gateway agent ID so the fallback LLM routes through the
-  // correct agent persona's model chain — identical to the pattern used
-  // by ExtractionEngine.withGatewayAgent().
-  const agentId =
-    config.modelSource === "gateway"
-      ? (config.gatewayAgentId || undefined)
-      : undefined;
+  // Route judge-gated extractions through the SAME shared resolution as every
+  // other background task (taskModelChain > gatewayAgentId in gateway mode), so
+  // the judge never silently falls back to the persona/default chain when a
+  // task chain is configured (gotcha #22, #39). Issue #1365 / PR #1425.
+  const gatewayChain = gatewayTaskChainOptions(config);
 
   // Try local LLM first (unless modelSource says gateway)
   if (localLlm && !skipLocal) {
@@ -695,7 +693,7 @@ async function callJudgeLlm(
           maxTokens: 2048,
           timeoutMs: 1500,
           ...(modelOverride ? { model: modelOverride } : {}),
-          ...(agentId ? { agentId } : {}),
+          ...gatewayChain,
         },
       );
       if (result?.content) {

package/src/extraction.ts

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import { log } from "./logger.js";
 import { delinearize } from "./delinearize.js";
 import { LocalLlmClient } from "./local-llm.js";
-import { FallbackLlmClient, fallbackLlmRuntimeContextFromConfig } from "./fallback-llm.js";
+import { FallbackLlmClient, fallbackLlmRuntimeContextFromConfig, gatewayTaskChainOptions } from "./fallback-llm.js";
 import {
   ExtractionResultSchema,
   ConsolidationResultSchema,
@@ -123,7 +123,16 @@ export class ExtractionEngine {
     if (config.modelSource === "gateway") {
       log.debug(
         `extraction engine: gateway model source active; extraction uses the gateway chain as its primary path` +
-          (config.gatewayAgentId ? ` (agent: ${config.gatewayAgentId})` : " (defaults)"),
+          (config.taskModelChain ? " (taskModelChain)" :
+            config.gatewayAgentId ? ` (agent: ${config.gatewayAgentId})` : " (defaults)"),
+      );
+    } else if (config.taskModelChain) {
+      // taskModelChain resolves through gateway providers, so it only applies
+      // under modelSource: "gateway". Warn rather than silently ignore it so a
+      // misconfigured plugin-mode setup is visible. Issue #1365 / PR #1370.
+      log.warn(
+        `taskModelChain is set but modelSource is "${config.modelSource}"; the chain is ignored. ` +
+          `Set modelSource: "gateway" to use it for extraction/consolidation/summarization.`,
       );
     }
   }
@@ -157,8 +166,9 @@ export class ExtractionEngine {
    */
   private withGatewayAgent(options: import("./fallback-llm.js").FallbackLlmOptions): import("./fallback-llm.js").FallbackLlmOptions {
     if (!this.useGatewayModelSource) return options;
-    const agentId = this.config.gatewayAgentId || undefined;
-    return agentId ? { ...options, agentId } : options;
+    // Shared resolution (taskModelChain > gatewayAgentId) so every background
+    // task routes identically (gotcha #22). Issue #1365.
+    return { ...options, ...gatewayTaskChainOptions(this.config) };
   }
 
   private emit(event: LlmTraceEvent): void {
@@ -1098,7 +1108,8 @@ export class ExtractionEngine {
     if (this.useGatewayModelSource) {
       log.debug(
         `extraction: using gateway model chain as primary path` +
-          (this.config.gatewayAgentId ? ` (agent: ${this.config.gatewayAgentId})` : " (defaults)"),
+          (this.config.taskModelChain ? " (taskModelChain)" :
+            this.config.gatewayAgentId ? ` (agent: ${this.config.gatewayAgentId})` : " (defaults)"),
       );
     } else {
       log.info("extraction: falling back to gateway default AI");