@remnic/core 9.3.720 → 9.3.721

package/src/faithfulness-config.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for the extracted faithfulness + correction-intent config parser
+ * (issue #1576 / #1585). Pins the behavior-preserving extraction: defaults
+ * are byte-identical to the pre-extraction inline block, validation rejects
+ * the same inputs with the same messages, and the new model-lab pointer keys
+ * default empty (byte-identical pre-feature path, rule 39).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { parseFaithfulnessGateConfig, parseCorrectionIntentConfig } from "./faithfulness-config.js";
+
+test("parseFaithfulnessGateConfig: empty input → byte-identical defaults (rule 39)", () => {
+  const out = parseFaithfulnessGateConfig({});
+  assert.equal(out.extractionFaithfulnessGate, "off");
+  assert.equal(out.extractionFaithfulnessModel, "");
+  assert.equal(out.extractionFaithfulnessBaseUrl, "");
+  assert.equal(out.extractionFaithfulnessContextChars, 400);
+  assert.equal(out.extractionFaithfulnessTimeoutMs, 8000);
+});
+
+test("parseFaithfulnessGateConfig: null/undefined gate → off (not rejected)", () => {
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessGate: undefined }).extractionFaithfulnessGate, "off");
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessGate: null }).extractionFaithfulnessGate, "off");
+});
+
+test("parseFaithfulnessGateConfig: valid gate modes accepted (case-insensitive, trimmed)", () => {
+  for (const v of ["off", "shadow", "enforce", "SHADOW", " Enforce "]) {
+    const mode = parseFaithfulnessGateConfig({ extractionFaithfulnessGate: v }).extractionFaithfulnessGate;
+    assert.ok(mode === "off" || mode === "shadow" || mode === "enforce", `${v} → ${mode}`);
+  }
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessGate: "SHADOW" }).extractionFaithfulnessGate, "shadow");
+});
+
+test("parseFaithfulnessGateConfig: present-but-invalid gate rejects (Ob4RQ — never silently off)", () => {
+  for (const bad of [true, 1, {}, "maybe", "on"]) {
+    assert.throws(
+      () => parseFaithfulnessGateConfig({ extractionFaithfulnessGate: bad }),
+      /extractionFaithfulnessGate must be one of "off" \| "shadow" \| "enforce"/,
+    );
+  }
+});
+
+test("parseFaithfulnessGateConfig: context chars clamp to [1, 4000]; invalid rejects (#1634)", () => {
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessContextChars: 100000 }).extractionFaithfulnessContextChars, 4000);
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessContextChars: "400" }).extractionFaithfulnessContextChars, 400);
+  for (const bad of [0, -1, 1.5, true, NaN, "abc"]) {
+    assert.throws(
+      () => parseFaithfulnessGateConfig({ extractionFaithfulnessContextChars: bad }),
+      /extractionFaithfulnessContextChars must be an integer/,
+    );
+  }
+});
+
+test("parseFaithfulnessGateConfig: timeout clamps to [1, 60000]; invalid rejects", () => {
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessTimeoutMs: 999999 }).extractionFaithfulnessTimeoutMs, 60_000);
+  for (const bad of [0, -5, 2.5, false, "no"]) {
+    assert.throws(
+      () => parseFaithfulnessGateConfig({ extractionFaithfulnessTimeoutMs: bad }),
+      /extractionFaithfulnessTimeoutMs must be an integer/,
+    );
+  }
+});
+
+test("parseFaithfulnessGateConfig: model-lab pointer keys default empty + accept strings (#1585)", () => {
+  // Defaults preserve the existing routing chain exactly.
+  assert.equal(parseFaithfulnessGateConfig({}).extractionFaithfulnessBaseUrl, "");
+  assert.equal(parseFaithfulnessGateConfig({}).extractionFaithfulnessModel, "");
+  // Non-string values are ignored → empty (not rejected; mirrors model key).
+  assert.equal(parseFaithfulnessGateConfig({ extractionFaithfulnessBaseUrl: 123 }).extractionFaithfulnessBaseUrl, "");
+  // Real pointer values round-trip.
+  const out = parseFaithfulnessGateConfig({
+    extractionFaithfulnessModel: "remnic-faithfulness-gate-v1",
+    extractionFaithfulnessBaseUrl: "http://localhost:11434/v1",
+  });
+  assert.equal(out.extractionFaithfulnessModel, "remnic-faithfulness-gate-v1");
+  assert.equal(out.extractionFaithfulnessBaseUrl, "http://localhost:11434/v1");
+});
+
+test("parseCorrectionIntentConfig: empty input → empty pointers (rule-based detector stays default)", () => {
+  const out = parseCorrectionIntentConfig({});
+  assert.equal(out.correctionIntentModel, "");
+  assert.equal(out.correctionIntentBaseUrl, "");
+});
+
+test("parseCorrectionIntentConfig: pointers round-trip; non-strings → empty", () => {
+  const out = parseCorrectionIntentConfig({
+    correctionIntentModel: "remnic-correction-intent-v1",
+    correctionIntentBaseUrl: "http://localhost:8000/v1",
+  });
+  assert.equal(out.correctionIntentModel, "remnic-correction-intent-v1");
+  assert.equal(out.correctionIntentBaseUrl, "http://localhost:8000/v1");
+  assert.equal(parseCorrectionIntentConfig({ correctionIntentModel: true }).correctionIntentModel, "");
+  assert.equal(parseCorrectionIntentConfig({ correctionIntentBaseUrl: 5 }).correctionIntentBaseUrl, "");
+});

package/src/faithfulness-config.ts

@@ -0,0 +1,138 @@
+/**
+ * Faithfulness-gate + correction-intent config parsing (issue #1576 / #1585).
+ *
+ * Extracted verbatim from `config.ts` (a watchlisted god file) so the gate
+ * config block can grow — the model-lab pointer keys
+ * `extractionFaithfulnessBaseUrl` (#1585) and the correction-intent pointers
+ * (`correctionIntentModel` / `correctionIntentBaseUrl`) — without growing the
+ * god file. This is a behavior-preserving extraction (#1526-style): the
+ * validation, defaults, and error messages are byte-identical to the inline
+ * block it replaces, which the existing extraction-faithfulness + config
+ * tests pin.
+ *
+ * Why a dedicated module (and not inline): the ratchet
+ * (`scripts/check-ratchets.mjs`) forbids `config.ts` from growing, and the
+ * model-lab integration needs three new optional keys. Centralizing the whole
+ * gate+intent parsing here keeps it unit-testable in isolation and lets
+ * `config.ts` spread the result in one line.
+ */
+
+import { coerceNumber } from "./connectors/coerce.js";
+
+/**
+ * Parse a value as a strict integer >= `min`, throwing on anything else.
+ *
+ * Mirrors `parseIntegerAtLeast` in `config.ts` byte-for-byte (issue #1634:
+ * reject non-numeric, <=0, non-integer, NaN, Infinity, booleans, objects —
+ * gotcha #51). Reimplemented locally rather than exported from `config.ts`
+ * so this module has no dependency on the god file (and vice versa).
+ */
+function parseIntegerAtLeast(
+  value: unknown,
+  fallback: number,
+  min: number,
+  keyName: string,
+): number {
+  if (value === undefined || value === null) return fallback;
+  const coerced = coerceNumber(value);
+  if (
+    coerced === undefined ||
+    !Number.isFinite(coerced) ||
+    !Number.isInteger(coerced) ||
+    coerced < min
+  ) {
+    throw new Error(
+      `${keyName} must be an integer greater than or equal to ${min}; got ${JSON.stringify(value)}`,
+    );
+  }
+  return coerced;
+}
+
+/**
+ * Parse the extraction faithfulness gate config block.
+ *
+ * Returns exactly the `PluginConfig` fields this block owns. Defaults preserve
+ * the byte-identical pre-feature pipeline (rule 39): gate "off", empty model
+ * + base URL, context 400 chars, timeout 8000 ms. Invalid `gate` values reject
+ * listing valid options (rule 51); invalid integers throw (issue #1634).
+ *
+ * `extractionFaithfulnessBaseUrl` (issue #1585) is the model-lab pointer: when
+ * set together with `extractionFaithfulnessModel`, the gate routes to that
+ * local openai-compatible endpoint before the configured chain; empty string
+ * (default) preserves the existing routing exactly.
+ */
+export function parseFaithfulnessGateConfig(cfg: Record<string, unknown>): {
+  extractionFaithfulnessGate: "off" | "shadow" | "enforce";
+  extractionFaithfulnessModel: string;
+  extractionFaithfulnessBaseUrl: string;
+  extractionFaithfulnessContextChars: number;
+  extractionFaithfulnessTimeoutMs: number;
+} {
+  const gateValue = cfg.extractionFaithfulnessGate;
+  let extractionFaithfulnessGate: "off" | "shadow" | "enforce";
+  if (gateValue === undefined || gateValue === null) {
+    extractionFaithfulnessGate = "off";
+  } else {
+    // Present-but-invalid (true/1/{}) must reject, not silently disable the gate (Ob4RQ).
+    const raw = typeof gateValue === "string" ? gateValue.trim().toLowerCase() : gateValue;
+    if (raw === "off" || raw === "shadow" || raw === "enforce") {
+      extractionFaithfulnessGate = raw;
+    } else {
+      throw new Error(
+        `extractionFaithfulnessGate must be one of "off" | "shadow" | "enforce" (got ${JSON.stringify(gateValue)})`,
+      );
+    }
+  }
+
+  const extractionFaithfulnessModel =
+    typeof cfg.extractionFaithfulnessModel === "string" ? cfg.extractionFaithfulnessModel : "";
+
+  // Issue #1585: model-lab pointer. Empty default → gate uses its existing
+  // routing chain (byte-identical). Non-empty + a model name → gate prefers
+  // the local served endpoint, falling back to the chain on failure.
+  const extractionFaithfulnessBaseUrl =
+    typeof cfg.extractionFaithfulnessBaseUrl === "string"
+      ? cfg.extractionFaithfulnessBaseUrl
+      : "";
+
+  const extractionFaithfulnessContextChars = Math.min(
+    parseIntegerAtLeast(cfg.extractionFaithfulnessContextChars, 400, 1, "extractionFaithfulnessContextChars"),
+    4000,
+  );
+
+  const extractionFaithfulnessTimeoutMs = Math.min(
+    parseIntegerAtLeast(cfg.extractionFaithfulnessTimeoutMs, 8000, 1, "extractionFaithfulnessTimeoutMs"),
+    60_000,
+  );
+
+  return {
+    extractionFaithfulnessGate,
+    extractionFaithfulnessModel,
+    extractionFaithfulnessBaseUrl,
+    extractionFaithfulnessContextChars,
+    extractionFaithfulnessTimeoutMs,
+  };
+}
+
+/**
+ * Parse the correction-intent config block (issue #1581 / #1585).
+ *
+ * The model-lab pointer for passive-correction detection: when both
+ * `correctionIntentModel` and `correctionIntentBaseUrl` are set, the detection
+ * path can route to that local fine-tuned classifier; empty defaults (the
+ * common case) keep the rule-based `detectPassiveCorrections` heuristic as the
+ * sole detector — byte-identical to the pre-feature path. Consumption by the
+ * detector is the consuming child's job (#1581's detector is a pure function;
+ * wiring a model call into it is out of scope for this config-pointer PR).
+ */
+export function parseCorrectionIntentConfig(cfg: Record<string, unknown>): {
+  correctionIntentModel: string;
+  correctionIntentBaseUrl: string;
+} {
+  return {
+    correctionIntentModel:
+      typeof cfg.correctionIntentModel === "string" ? cfg.correctionIntentModel : "",
+    correctionIntentBaseUrl:
+      typeof cfg.correctionIntentBaseUrl === "string" ? cfg.correctionIntentBaseUrl : "",
+  };
+}

package/src/local-model-endpoint.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Tests for the local model-lab endpoint resolver + openai-compatible caller
+ * (issue #1585). Pure unit tests — the fetch caller takes an injected
+ * `fetchImpl`, so no network, no GPU, no live server.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveFaithfulnessGateEndpoint,
+  resolveCorrectionIntentEndpoint,
+  callOpenAiCompatibleChat,
+  type EndpointChatMessage,
+} from "./local-model-endpoint.js";
+
+// ---------------------------------------------------------------------------
+// Resolvers
+// ---------------------------------------------------------------------------
+
+test("resolveFaithfulnessGateEndpoint: null when either key empty (default = no pointer)", () => {
+  assert.equal(resolveFaithfulnessGateEndpoint({ extractionFaithfulnessModel: "", extractionFaithfulnessBaseUrl: "" }), null);
+  assert.equal(resolveFaithfulnessGateEndpoint({ extractionFaithfulnessModel: "m", extractionFaithfulnessBaseUrl: "" }), null);
+  assert.equal(resolveFaithfulnessGateEndpoint({ extractionFaithfulnessModel: "", extractionFaithfulnessBaseUrl: "http://x/v1" }), null);
+  // whitespace-only counts as empty.
+  assert.equal(resolveFaithfulnessGateEndpoint({ extractionFaithfulnessModel: "  ", extractionFaithfulnessBaseUrl: "http://x/v1" }), null);
+});
+
+test("resolveFaithfulnessGateEndpoint: returns trimmed endpoint when both keys set", () => {
+  const ep = resolveFaithfulnessGateEndpoint({
+    extractionFaithfulnessModel: "  remnic-faithfulness-gate-v1  ",
+    extractionFaithfulnessBaseUrl: "http://localhost:11434/v1",
+  });
+  assert.deepEqual(ep, { baseUrl: "http://localhost:11434/v1", model: "remnic-faithfulness-gate-v1" });
+});
+
+test("resolveCorrectionIntentEndpoint: same contract as the gate resolver", () => {
+  assert.equal(resolveCorrectionIntentEndpoint({ correctionIntentModel: "", correctionIntentBaseUrl: "" }), null);
+  assert.equal(resolveCorrectionIntentEndpoint({ correctionIntentModel: "m", correctionIntentBaseUrl: "" }), null);
+  assert.deepEqual(
+    resolveCorrectionIntentEndpoint({ correctionIntentModel: "ci-v1", correctionIntentBaseUrl: "http://localhost:8000/v1" }),
+    { baseUrl: "http://localhost:8000/v1", model: "ci-v1" },
+  );
+});
+
+// ---------------------------------------------------------------------------
+// callOpenAiCompatibleChat — injected fetch, no network
+// ---------------------------------------------------------------------------
+
+/** Build a minimal Response-shaped object the caller reads (ok, json, .json). */
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+const MESSAGES: EndpointChatMessage[] = [
+  { role: "system", content: "verifier" },
+  { role: "user", content: "fact vs quote" },
+];
+
+test("callOpenAiCompatibleChat: happy path — first choice content + reported model", async () => {
+  let calledUrl = "";
+  let calledBody: Record<string, unknown> | undefined;
+  const fakeFetch = (url: string, init: RequestInit): Promise<Response> => {
+    calledUrl = url;
+    calledBody = JSON.parse(String(init.body));
+    return Promise.resolve(
+      jsonResponse(200, {
+        model: "remnic-faithfulness-gate-v1",
+        choices: [{ message: { content: '[{"index":0,"verdict":"entailed"}]' } }],
+      }),
+    );
+  };
+  const result = await callOpenAiCompatibleChat(
+    { baseUrl: "http://localhost:11434/v1", model: "remnic-faithfulness-gate-v1" },
+    MESSAGES,
+    { timeoutMs: 5000, temperature: 0.1, maxTokens: 2048, responseFormatJson: true },
+    fakeFetch as typeof fetch,
+  );
+  assert.equal(result?.content, '[{"index":0,"verdict":"entailed"}]');
+  assert.equal(result?.modelUsed, "remnic-faithfulness-gate-v1");
+  // URL joined correctly (no double slash), body carries model + json_object format.
+  assert.equal(calledUrl, "http://localhost:11434/v1/chat/completions");
+  assert.equal(calledBody?.model, "remnic-faithfulness-gate-v1");
+  assert.deepEqual(calledBody?.response_format, { type: "json_object" });
+  assert.equal(calledBody?.max_tokens, 2048);
+});
+
+test("callOpenAiCompatibleChat: trailing slash on baseUrl is tolerated", async () => {
+  const seen = (await callOpenAiCompatibleChat(
+    { baseUrl: "http://localhost:11434/v1/", model: "m" },
+    MESSAGES,
+    { timeoutMs: 1000 },
+    ((url: string) => {
+      assert.equal(url, "http://localhost:11434/v1/chat/completions");
+      return Promise.resolve(jsonResponse(200, { choices: [{ message: { content: "ok" } }] }));
+    }) as typeof fetch,
+  ))!;
+  assert.equal(seen.content, "ok");
+  assert.equal(seen.modelUsed, "m"); // server reported no model → falls back to requested name
+});
+
+test("callOpenAiCompatibleChat: returns null on non-2xx (fail closed)", async () => {
+  const result = await callOpenAiCompatibleChat(
+    { baseUrl: "http://x/v1", model: "m" },
+    MESSAGES,
+    { timeoutMs: 1000 },
+    (() => Promise.resolve(jsonResponse(500, { error: "boom" }))) as typeof fetch,
+  );
+  assert.equal(result, null);
+});
+
+test("callOpenAiCompatibleChat: returns null on network error (fail closed)", async () => {
+  const result = await callOpenAiCompatibleChat(
+    { baseUrl: "http://x/v1", model: "m" },
+    MESSAGES,
+    { timeoutMs: 1000 },
+    (() => Promise.reject(new Error("ECONNREFUSED"))) as typeof fetch,
+  );
+  assert.equal(result, null);
+});
+
+test("callOpenAiCompatibleChat: returns null on malformed body (no fabricated shape)", async () => {
+  for (const body of [
+    null,
+    {},
+    { choices: [] },
+    { choices: [{ message: {} }] },
+    { choices: [{ message: { content: 42 } }] }, // non-string content
+    { choices: "not-an-array" },
+  ]) {
+    const result = await callOpenAiCompatibleChat(
+      { baseUrl: "http://x/v1", model: "m" },
+      MESSAGES,
+      { timeoutMs: 1000 },
+      (() => Promise.resolve(jsonResponse(200, body))) as typeof fetch,
+    );
+    assert.equal(result, null, `body ${JSON.stringify(body)} should yield null`);
+  }
+});
+
+test("callOpenAiCompatibleChat: returns null on .json() throw", async () => {
+  const result = await callOpenAiCompatibleChat(
+    { baseUrl: "http://x/v1", model: "m" },
+    MESSAGES,
+    { timeoutMs: 1000 },
+    (() =>
+      Promise.resolve(
+        new Response("not-json", { status: 200, headers: { "content-type": "application/json" } }),
+      )) as typeof fetch,
+  );
+  assert.equal(result, null);
+});

package/src/local-model-endpoint.ts

@@ -0,0 +1,189 @@
+/**
+ * Local fine-tuned model endpoint resolver + openai-compatible caller
+ * (issue #1585 model-lab integration).
+ *
+ * Remnic's two classification workloads — the extraction faithfulness gate
+ * (#1576) and passive-correction intent detection (#1581) — can run on small
+ * fine-tuned models served locally (Ollama / vLLM) instead of prompted
+ * frontier LLMs. The model-lab (`model-lab/`) produces those models; this
+ * module is the config-side half: it resolves the optional local endpoint
+ * pointer from config and, when set, makes a minimal openai-compatible
+ * chat-completions call to it.
+ *
+ * Design:
+ *   - **Pointers are optional.** Empty defaults preserve the existing routing
+ *     chain exactly (rule 39 / byte-identical pre-feature). A resolver returns
+ *     `null` when the pointer is unset, so callers short-circuit before any
+ *     network.
+ *   - **Graceful degradation.** A local-endpoint failure (network, non-2xx,
+ *     malformed body, timeout) returns `null`; callers fall back to the
+ *     configured chain (checklist §4 — never block writes on a classifier).
+ *   - **No inline casts.** The fetch JSON is narrowed with `in` / `typeof`
+ *     guards (project rule: never assert a shape to read one property).
+ *   - **Injectable fetch.** `callOpenAiCompatibleChat` takes an optional
+ *     `fetchImpl` so the caller is unit-testable without a live server.
+ */
+
+import type { PluginConfig } from "./types.js";
+
+/** A resolved local endpoint: where to call + which model to name. */
+export interface LocalModelEndpoint {
+  /** Base URL, e.g. `http://localhost:11434/v1` (no trailing slash required). */
+  baseUrl: string;
+  /** Model name the server expects, e.g. `remnic-faithfulness-gate-v1`. */
+  model: string;
+}
+
+/** A chat message in the openai-compatible shape this caller sends. */
+export interface EndpointChatMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+/** 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). */
+  timeoutMs: number;
+  /** Sampling temperature — classification wants low entropy (0.0–0.2). */
+  temperature?: number;
+  /** Max output tokens. */
+  maxTokens?: number;
+  /** Request JSON-object output (the gate emits a JSON verdict array). */
+  responseFormatJson?: boolean;
+}
+
+/** Result of a local-endpoint chat call. */
+export interface EndpointChatResult {
+  content: string;
+  /** The model the server reports it used (falls back to the requested name). */
+  modelUsed: string;
+}
+
+/**
+ * Resolve the faithfulness-gate local endpoint from config (issue #1585).
+ *
+ * Returns the endpoint only when BOTH a base URL and a model name are
+ * configured; otherwise `null` (gate uses its existing routing chain). The
+ * gate's verifier needs a model identity, so a base URL alone is intentionally
+ * insufficient — silently calling whatever the server's default model is would
+ * be an unreviewed behavioral change.
+ */
+export function resolveFaithfulnessGateEndpoint(
+  config: Pick<PluginConfig, "extractionFaithfulnessModel" | "extractionFaithfulnessBaseUrl">,
+): LocalModelEndpoint | null {
+  const baseUrl = config.extractionFaithfulnessBaseUrl.trim();
+  const model = config.extractionFaithfulnessModel.trim();
+  if (!baseUrl || !model) return null;
+  return { baseUrl, model };
+}
+
+/**
+ * Resolve the correction-intent local endpoint from config (issue #1581/#1585).
+ *
+ * Same contract as the gate resolver. Consumption by the model-backed
+ * detector is the consuming child's job — the rule-based
+ * `detectPassiveCorrections` remains the default path; this pointer lets a
+ * future model-backed detector route to a fine-tuned local classifier when an
+ * operator configures one.
+ */
+export function resolveCorrectionIntentEndpoint(
+  config: Pick<PluginConfig, "correctionIntentModel" | "correctionIntentBaseUrl">,
+): LocalModelEndpoint | null {
+  const baseUrl = config.correctionIntentBaseUrl.trim();
+  const model = config.correctionIntentModel.trim();
+  if (!baseUrl || !model) return null;
+  return { baseUrl, model };
+}
+
+type FetchLike = typeof fetch;
+
+/**
+ * Make an openai-compatible chat-completions call to a local endpoint.
+ *
+ * POSTs to `${baseUrl}/chat/completions` with `{ model, messages, ... }` and
+ * returns the first choice's content. Any failure (non-2xx, network error,
+ * malformed body, timeout) returns `null` so callers fall back gracefully.
+ *
+ * The response is narrowed with runtime guards — never an unchecked cast — so
+ * a surprising server response fails closed (`null`) rather than reading a
+ * fabricated field.
+ */
+export async function callOpenAiCompatibleChat(
+  endpoint: LocalModelEndpoint,
+  messages: EndpointChatMessage[],
+  options: EndpointChatOptions,
+  fetchImpl: FetchLike = fetch,
+): Promise<EndpointChatResult | null> {
+  const url = joinBaseUrl(endpoint.baseUrl, "/chat/completions");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs);
+  try {
+    const body: Record<string, unknown> = {
+      model: endpoint.model,
+      messages,
+      temperature: options.temperature ?? 0.1,
+    };
+    if (typeof options.maxTokens === "number") {
+      body.max_tokens = options.maxTokens;
+    }
+    if (options.responseFormatJson) {
+      body.response_format = { type: "json_object" };
+    }
+    let response: Response;
+    try {
+      response = await fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+    } catch {
+      // Network error or abort — fail closed, let the caller fall back.
+      return null;
+    }
+    if (!response.ok) return null;
+    const parsed: unknown = await response.json().catch(() => null);
+    const content = extractFirstChoiceContent(parsed);
+    if (content === null) return null;
+    return { content, modelUsed: extractModel(parsed) ?? endpoint.model };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Join a base URL and a path, tolerating a trailing slash on the base. */
+function joinBaseUrl(base: string, path: string): string {
+  return base.endsWith("/") ? `${base.slice(0, -1)}${path}` : `${base}${path}`;
+}
+
+/**
+ * Narrow the openai-compatible response and pull the first choice's content.
+ *
+ * `in` / `typeof` guards only — no `as` cast (project rule). Returns `null`
+ * for any shape that isn't `{ choices: [{ message: { content: string } }, …] }`.
+ */
+function extractFirstChoiceContent(data: unknown): string | null {
+  if (!data || typeof data !== "object") return null;
+  // After `in`, TS narrows the property to `unknown` — read it directly, no cast.
+  if (!("choices" in data) || !Array.isArray(data.choices)) return null;
+  const choices: unknown[] = data.choices;
+  for (const choice of choices) {
+    if (!choice || typeof choice !== "object") continue;
+    if (!("message" in choice)) continue;
+    const message = choice.message;
+    if (!message || typeof message !== "object") continue;
+    if (!("content" in message)) continue;
+    const content = message.content;
+    if (typeof content === "string" && content.length > 0) return content;
+  }
+  return null;
+}
+
+/** Narrow the `model` field from the response (best-effort, may be absent). */
+function extractModel(data: unknown): string | null {
+  if (!data || typeof data !== "object" || !("model" in data)) return null;
+  const model = data.model;
+  return typeof model === "string" && model.length > 0 ? model : null;
+}

package/src/types.ts

@@ -1207,12 +1207,30 @@ export interface PluginConfig {
   // extracted facts against their verified source spans from #1575.
   /** Gate mode: "off" (default, byte-identical pre-feature), "shadow" (record only), "enforce" (route to pending_review). */
   extractionFaithfulnessGate: "off" | "shadow" | "enforce";
-  /** Override model/endpoint; empty string = default routing chain. */
+  /** Override model name; empty string = default routing chain. */
   extractionFaithfulnessModel: string;
+  /**
+   * Base URL of a local openai-compatible endpoint serving a fine-tuned
+   * faithfulness gate (issue #1585 model-lab), e.g.
+   * `http://localhost:11434/v1` (Ollama) or `http://localhost:8000/v1` (vLLM).
+   * Empty string (default) preserves the existing routing chain exactly;
+   * set together with `extractionFaithfulnessModel` to route the gate to the
+   * local model first, falling back to the chain on failure.
+   */
+  extractionFaithfulnessBaseUrl: string;
   /** Context window (chars) around the quote sent to the verifier. Default 400. */
   extractionFaithfulnessContextChars: number;
   /** Per-batch timeout in ms; timeout → tagged error, never blocks writes. Default 8000. */
   extractionFaithfulnessTimeoutMs: number;
+  /**
+   * Correction-intent model-lab pointer (issue #1581 / #1585). When both this
+   * and `correctionIntentBaseUrl` are set, the detection path can route to a
+   * local fine-tuned correction-intent classifier. Empty default keeps the
+   * rule-based passive-correction detector as the sole path (byte-identical).
+   */
+  correctionIntentModel: string;
+  /** Base URL of a local openai-compatible endpoint serving the correction-intent classifier (issue #1585). Empty default = rule-based detection. */
+  correctionIntentBaseUrl: string;
   // Hourly summaries
   hourlySummariesEnabled: boolean;
   daySummaryEnabled: boolean;