@remnic/core 9.7.12 → 9.7.14

package/src/local-llm.ts

@@ -999,6 +999,20 @@ export class LocalLlmClient {
         THINKING_COMPATIBLE_BACKENDS.has(this.detectedType)
       ) {
         requestBody.chat_template_kwargs = { enable_thinking: false };
+      } else if (shouldSuppressThinking && this.detectedType === "ollama") {
+        // Ollama's /v1 endpoint silently drops `chat_template_kwargs` AND
+        // `enable_thinking` — the ONLY field it maps to think-off is
+        // `reasoning_effort` ("none" → ThinkValue{false} in openai.go;
+        // verified against Ollama 0.32.0 source and live probes,
+        // issue #1996). Without this, thinking-capable models (Gemma 4,
+        // Qwen 3.5+) burn 1,700-2,000 reasoning tokens per extraction on
+        // Ollama, exceed the client timeout, and retry forever. The effort
+        // is configurable via `localLlmReasoningEffort` (default "none");
+        // an empty value disables injection (pre-#1996 behavior).
+        const effort = this.config.localLlmReasoningEffort;
+        if (effort) {
+          requestBody.reasoning_effort = effort;
+        }
       }
 
       // Normalize URL (use 127.0.0.1 instead of localhost)

package/src/relay/mission-access.test.ts

@@ -60,13 +60,33 @@ test("HTTP fixture endpoint returns one complete, namespace-authorized Relay rec
       service: fakeService(root, calls),
       port: 0,
       authToken: "relay-token",
-      principal: "relay-operator",
+      principal: "operator-build-week",
       adminConsoleEnabled: false,
     });
     const status = await server.start();
     const base = `http://127.0.0.1:${status.port}/engram/v1/relay/missions/${RELAY_DEMO_MISSION_ID}`;
     try {
       const fixture = createRelayMissionFixture();
+      const approval = fixture.find((event) => event.payload.kind === "correction_approved");
+      assert.ok(approval && approval.payload.kind === "correction_approved");
+      const mismatchedApproval = await fetch(`${base}/events`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify({
+          namespace: RELAY_DEMO_NAMESPACE,
+          event: {
+            ...approval,
+            idempotencyKey: "mismatched-human-approval",
+            payload: {
+              ...approval.payload,
+              approvedBy: { ...approval.payload.approvedBy, id: "different-operator" },
+            },
+          },
+        }),
+      });
+      assert.equal(mismatchedApproval.status, 400);
+      assert.equal(((await mismatchedApproval.json()) as { code: string }).code, "input_error");
+
       const blankNamespace = await fetch(`${base}/events`, {
         method: "POST",
         headers: authHeaders(),
@@ -91,7 +111,7 @@ test("HTTP fixture endpoint returns one complete, namespace-authorized Relay rec
         assert.equal(response.status, 201, responseBody);
         assert.equal(
           (JSON.parse(responseBody) as { event: { authenticatedPrincipal?: string } }).event.authenticatedPrincipal,
-          "relay-operator"
+          "operator-build-week"
         );
       }
 
@@ -108,6 +128,7 @@ test("HTTP fixture endpoint returns one complete, namespace-authorized Relay rec
       });
       assert.equal(response.status, 200);
       assert.equal(response.headers.get("cache-control"), "no-store");
+      assert.equal(response.headers.get("x-remnic-authenticated-principal"), "operator-build-week");
       const snapshot = (await response.json()) as RelayMissionSnapshot;
       assert.equal(snapshot.receipt.complete, true);
       assert.deepEqual(snapshot.receipt.activeDecisionIds, ["decision-refresh-after-expiry"]);
@@ -115,7 +136,40 @@ test("HTTP fixture endpoint returns one complete, namespace-authorized Relay rec
       assert.equal(snapshot.agents.length, 3);
       assert.equal(snapshot.tests.at(-1)?.status, "passed");
       assert.ok(calls.every((call) => call.namespace === RELAY_DEMO_NAMESPACE));
-      assert.ok(calls.every((call) => call.principal === "relay-operator"));
+      assert.ok(calls.every((call) => call.principal === "operator-build-week"));
+    } finally {
+      await server.stop();
+    }
+  });
+});
+
+test("HTTP Relay rejects human approval without a server-resolved principal before persistence", async () => {
+  await withTempRoot(async (root) => {
+    const server = new EngramAccessHttpServer({
+      service: fakeService(root, []),
+      port: 0,
+      authToken: "relay-token",
+      adminConsoleEnabled: false,
+    });
+    const status = await server.start();
+    const base = `http://127.0.0.1:${status.port}/engram/v1/relay/missions/${RELAY_DEMO_MISSION_ID}`;
+    try {
+      const approval = createRelayMissionFixture().find((event) => event.payload.kind === "correction_approved");
+      assert.ok(approval);
+      const rejected = await fetch(`${base}/events`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify({ namespace: RELAY_DEMO_NAMESPACE, event: approval }),
+      });
+      assert.equal(rejected.status, 400);
+      assert.equal(((await rejected.json()) as { code: string }).code, "input_error");
+
+      const snapshotResponse = await fetch(`${base}?namespace=${RELAY_DEMO_NAMESPACE}`, {
+        headers: authHeaders(),
+      });
+      assert.equal(snapshotResponse.status, 200);
+      assert.equal(snapshotResponse.headers.get("x-remnic-authenticated-principal"), null);
+      assert.equal(((await snapshotResponse.json()) as RelayMissionSnapshot).found, false);
     } finally {
       await server.stop();
     }
@@ -150,6 +204,7 @@ test("HTTP Relay surface distinguishes empty, invalid, unauthorized, and backend
 
       const empty = await fetch(emptyUrl, { headers: authHeaders("read-token") });
       assert.equal(empty.status, 200);
+      assert.equal(empty.headers.get("x-remnic-authenticated-principal"), null);
       assert.deepEqual(await empty.json(), assertEmptyMissionShape());
 
       const badLimit = await fetch(`${emptyUrl}&limit=501`, {

package/src/relay/mission-access.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 import { type OperationContext, defineOperation } from "../access-boundary.js";
-import type { EngramAccessService } from "../access-service.js";
+import { EngramAccessInputError, type EngramAccessService } from "../access-service.js";
 import {
   RELAY_MISSION_MAX_EVENT_LIMIT,
   RelayIsoDateTimeSchema,
@@ -76,12 +76,26 @@ export async function appendRelayMissionEvent(
   authenticatedPrincipal?: string,
   beforeAppend?: () => void | Promise<void>
 ): Promise<RelayMissionAppendResult> {
-  const resolved = await service.getWritableStorageForNamespace(input.namespace ?? undefined, authenticatedPrincipal);
+  const event = RelayMissionEventInputSchema.parse(input.event);
+  const approvalPrincipal = authenticatedPrincipal?.trim() || undefined;
+  if (event.payload.kind === "correction_approved" && event.payload.approvedBy.kind === "human") {
+    if (!approvalPrincipal) {
+      throw new EngramAccessInputError(
+        "Relay human approval requires a server-resolved authenticated principal"
+      );
+    }
+    if (event.payload.approvedBy.id !== approvalPrincipal) {
+      throw new EngramAccessInputError(
+        "Relay human approval identity must match the server-resolved authenticated principal"
+      );
+    }
+  }
+  const resolved = await service.getWritableStorageForNamespace(input.namespace ?? undefined, approvalPrincipal);
   const store = new RelayMissionStore({
     rootDir: resolved.storage.dir,
     namespace: resolved.namespace,
   });
-  return store.append(input.missionId, input.event, { authenticatedPrincipal, beforeAppend });
+  return store.append(input.missionId, event, { authenticatedPrincipal: approvalPrincipal, beforeAppend });
 }
 
 /** Namespace-authorized, bounded Relay snapshot read shared by HTTP and UI. */

package/src/relay/mission-ui.test.ts

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import { EngramAccessHttpServer } from "../access-http.js";
+import type { EngramAccessService } from "../access-service.js";
+import type { StorageManager } from "../storage.js";
+
+const adminConsolePublicDir = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../../../../admin-console/public"
+);
+
+async function withTempRoot(run: (root: string) => Promise<void>): Promise<void> {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-relay-ui-"));
+  try {
+    await run(root);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
+function fakeService(root: string): EngramAccessService {
+  const storage = { dir: root } as StorageManager;
+  return {
+    configRef: { defaultNamespace: "relay-build-week", namespacesEnabled: true },
+    getReadableStorageForNamespace: async (namespace?: string) => ({ namespace: namespace ?? "relay-build-week", storage }),
+    getWritableStorageForNamespace: async (namespace?: string) => ({ namespace: namespace ?? "relay-build-week", storage }),
+  } as unknown as EngramAccessService;
+}
+
+test("Relay Mission Control serves both aliases from one exact static allow-list", async () => {
+  await withTempRoot(async (root) => {
+    const server = new EngramAccessHttpServer({
+      service: fakeService(root),
+      host: "127.0.0.1",
+      port: 0,
+      authToken: "relay-token",
+      principal: "relay-operator",
+      adminConsoleEnabled: true,
+      adminConsolePublicDir,
+      adminConsolePrefillToken: true,
+    });
+    const status = await server.start();
+    const origin = `http://127.0.0.1:${status.port}`;
+    try {
+      for (const prefix of ["remnic", "engram"]) {
+        const redirect = await fetch(`${origin}/${prefix}/ui/relay`, { redirect: "manual" });
+        assert.equal(redirect.status, 301);
+        assert.equal(redirect.headers.get("location"), `/${prefix}/ui/relay/`);
+
+        const shell = await fetch(`${origin}/${prefix}/ui/relay/`);
+        assert.equal(shell.status, 200);
+        assert.match(shell.headers.get("content-type") ?? "", /^text\/html/);
+        assert.doesNotMatch(await shell.text(), /__REMNIC_ADMIN_CONSOLE_PREFILL_TOKEN__/);
+
+        const authorizedShell = await fetch(`${origin}/${prefix}/ui/relay/`, {
+          headers: { authorization: "Bearer relay-token" },
+        });
+        assert.equal(authorizedShell.status, 200);
+        assert.equal(authorizedShell.headers.get("cache-control"), "private, no-store");
+        assert.match(await authorizedShell.text(), /__REMNIC_ADMIN_CONSOLE_PREFILL_TOKEN__="relay-token"/);
+
+        const expectedAssets = new Map([
+          ["relay.css", /^text\/css/],
+          ["relay-model.js", /^application\/javascript/],
+          ["relay.js", /^application\/javascript/],
+          ["replay.json", /^application\/json/],
+        ]);
+        for (const [fileName, contentType] of expectedAssets) {
+          const asset = await fetch(`${origin}/${prefix}/ui/relay/${fileName}`);
+          assert.equal(asset.status, 200, `${prefix}/${fileName}`);
+          assert.match(asset.headers.get("content-type") ?? "", contentType);
+          assert.ok((await asset.text()).length > 100);
+        }
+
+        const auth = { authorization: "Bearer relay-token" };
+        const unknown = await fetch(`${origin}/${prefix}/ui/relay/not-allowed.js`, { headers: auth });
+        assert.equal(unknown.status, 404);
+        const nested = await fetch(`${origin}/${prefix}/ui/relay/relay.js/extra`, { headers: auth });
+        assert.equal(nested.status, 404);
+      }
+    } finally {
+      await server.stop();
+    }
+  });
+});

package/src/types.ts

@@ -1595,6 +1595,12 @@ export interface PluginConfig {
   localLlmRetryBackoffMs: number;
   localLlm400TripThreshold: number;
   localLlm400CooldownMs: number;
+  /** Ollama-backend thinking suppression: `reasoning_effort` value injected on
+   *  `/v1/chat/completions` for THINKING_SUPPRESSED_OPERATIONS ("none" | "low" |
+   *  "medium" | "high" | "max"; "" disables injection). Ollama ignores
+   *  `chat_template_kwargs`, so this is the only think-off dialect it honors.
+   *  Issue #1996. */
+  localLlmReasoningEffort: string;
   // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
   /** Master gate. When false, restores pre-change behavior (extractor called on every triggered observe; no gate). */
   extractionRetryEnabled: boolean;