@remnic/core 10.0.39 → 10.0.40

package/dist/semantic-rule-promotion.js

@@ -1,13 +1,13 @@
 import {
   promoteSemanticRuleFromMemory,
   setSemanticRulePromotionTestHooks
-} from "./chunk-4LLV2N3R.js";
-import "./chunk-5KZNWERU.js";
+} from "./chunk-ONIVKGNC.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/semantic-rule-verifier.js

@@ -1,13 +1,13 @@
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-U66CTIF5.js";
-import "./chunk-5KZNWERU.js";
+} from "./chunk-F2RDRE7M.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/source-agent-qualifier.js

@@ -12,7 +12,7 @@ import "./chunk-VEWZZM3H.js";
 import "./chunk-M7KGIW5F.js";
 import "./chunk-5TJEOU6Y.js";
 import "./chunk-754XN6LX.js";
-import "./chunk-22YJQTPN.js";
+import "./chunk-QGNZ5QPV.js";
 import "./chunk-3UXOZBHV.js";
 import "./chunk-AL3TCNSJ.js";
 import "./chunk-6X3J4NLZ.js";
@@ -27,12 +27,12 @@ import "./chunk-236PXYG7.js";
 import "./chunk-ZCUTSMR2.js";
 import "./chunk-QDW3E4RD.js";
 import "./chunk-ZJP66Q4I.js";
-import "./chunk-5KZNWERU.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/standup/build.js

@@ -3,13 +3,13 @@ import {
   parseStandupDate,
   previousActiveDate,
   standupHelp
-} from "../chunk-GCW7UT5I.js";
-import "../chunk-5KZNWERU.js";
+} from "../chunk-JJSMSS45.js";
+import "../chunk-BIYVUPC6.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-DM5QZ3YU.js";
 import "../chunk-VY6BD5KB.js";
 import "../chunk-G6OFEGUR.js";
-import "../chunk-V2XMG7GM.js";
+import "../chunk-CHNZPOWX.js";
 import "../chunk-4QLKVZH6.js";
 import "../chunk-XKDQTDXN.js";
 import "../chunk-CYEPCZN5.js";

package/dist/storage.js

@@ -14,12 +14,12 @@ import {
   parseFrontmatter,
   parseFrontmatterStringValue,
   serializeEntityFile
-} from "./chunk-5KZNWERU.js";
+} from "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/support-passport/index.js

@@ -4,7 +4,7 @@ import {
   SUPPORT_PASSPORT_MODEL_RESULT_PATH,
   SupportPassportModelBridge,
   parseSupportPassportModelJob
-} from "../chunk-P3YUEPSQ.js";
+} from "../chunk-Y473XFTD.js";
 import {
   DEFAULT_SUPPORT_PASSPORT_CONFIG,
   parseSupportPassportConfig
@@ -14,8 +14,8 @@ import {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers,
   normalizeSupportPassportNetworkAddress
-} from "../chunk-ZXFKG7VZ.js";
-import "../chunk-4UT2NUAC.js";
+} from "../chunk-LB6HIXQC.js";
+import "../chunk-WJMAWDAU.js";
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES,
@@ -56,7 +56,7 @@ import {
   notifySupportPassportCommitted,
   resolveSupportPassportModelRoutePlan,
   syncDirectoryForDurability
-} from "../chunk-7IANFJ24.js";
+} from "../chunk-QFD7OANX.js";
 import "../chunk-W4F3C7N7.js";
 import "../chunk-MPC7TYTZ.js";
 import "../chunk-IJH6METJ.js";
@@ -64,7 +64,7 @@ import "../chunk-IFBSZGW3.js";
 import "../chunk-OGXXGHW6.js";
 import "../chunk-VSHWPOUB.js";
 import "../chunk-VQ7B2Q6M.js";
-import "../chunk-WT2VVYBM.js";
+import "../chunk-PJXSBXEC.js";
 import "../chunk-BANSBRNX.js";
 import "../chunk-GNVZQ5JN.js";
 import "../chunk-YN2UN7N3.js";
@@ -87,7 +87,7 @@ import "../chunk-H7XKCNR6.js";
 import "../chunk-WUL6LDJ4.js";
 import "../chunk-SOBJ6NEY.js";
 import "../chunk-VHBGJAYC.js";
-import "../chunk-O2O4FDAH.js";
+import "../chunk-JXQTECMU.js";
 import "../chunk-7XZ7TOLQ.js";
 import "../chunk-E6UNM67F.js";
 import "../chunk-Z64TS5V4.js";
@@ -98,7 +98,7 @@ import "../chunk-IISBCCWR.js";
 import "../chunk-6ITNEPJO.js";
 import "../chunk-AER3HD3B.js";
 import "../chunk-2YA5N2BY.js";
-import "../chunk-JQCP5QW3.js";
+import "../chunk-O67H7OXJ.js";
 import "../chunk-HUDPXTXW.js";
 import "../chunk-AZEZSQ5R.js";
 import "../chunk-23ZMQONL.js";
@@ -120,12 +120,12 @@ import "../chunk-VZIAVM72.js";
 import "../chunk-LXATZLSC.js";
 import "../chunk-E3NBMTTX.js";
 import "../chunk-RF2SMMPP.js";
-import "../chunk-B7VKRCAG.js";
-import "../chunk-5Q6CR65T.js";
-import "../chunk-RO2NNWR5.js";
-import "../chunk-4HJ2QK32.js";
+import "../chunk-FNEYSTB6.js";
+import "../chunk-VTZSIG6O.js";
+import "../chunk-GAUS4XGN.js";
+import "../chunk-GDOI4U4D.js";
 import "../chunk-UFGFMWAD.js";
-import "../chunk-22YJQTPN.js";
+import "../chunk-QGNZ5QPV.js";
 import "../chunk-3UXOZBHV.js";
 import "../chunk-AL3TCNSJ.js";
 import "../chunk-WUBGMV3G.js";
@@ -145,7 +145,7 @@ import "../chunk-5YQXWVCP.js";
 import "../chunk-QEDLJDHP.js";
 import "../chunk-U4LUIE6Y.js";
 import "../chunk-ZY2MNJR6.js";
-import "../chunk-JZFJZLJY.js";
+import "../chunk-UGV256H3.js";
 import "../chunk-GZFKCLRC.js";
 import "../chunk-FRXS6SC7.js";
 import "../chunk-KZMRMKC7.js";
@@ -169,12 +169,12 @@ import "../chunk-ZCUTSMR2.js";
 import "../chunk-QDW3E4RD.js";
 import "../chunk-VECRSYQG.js";
 import "../chunk-ZJP66Q4I.js";
-import "../chunk-5KZNWERU.js";
+import "../chunk-BIYVUPC6.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-DM5QZ3YU.js";
 import "../chunk-VY6BD5KB.js";
 import "../chunk-G6OFEGUR.js";
-import "../chunk-V2XMG7GM.js";
+import "../chunk-CHNZPOWX.js";
 import "../chunk-4QLKVZH6.js";
 import "../chunk-XKDQTDXN.js";
 import "../chunk-CYEPCZN5.js";

package/dist/transfer/export-okf.js

@@ -4,18 +4,18 @@ import {
   exportOkfBundle,
   firstHeading,
   parseIncludeStatus
-} from "../chunk-GPVGAHXL.js";
+} from "../chunk-CNAL35D5.js";
 import {
   OKF_EXPORT_VERSION
 } from "../chunk-I7TR2OCU.js";
 import "../chunk-D24OXEPB.js";
 import "../chunk-3UXOZBHV.js";
-import "../chunk-5KZNWERU.js";
+import "../chunk-BIYVUPC6.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-DM5QZ3YU.js";
 import "../chunk-VY6BD5KB.js";
 import "../chunk-G6OFEGUR.js";
-import "../chunk-V2XMG7GM.js";
+import "../chunk-CHNZPOWX.js";
 import "../chunk-4QLKVZH6.js";
 import "../chunk-XKDQTDXN.js";
 import "../chunk-CYEPCZN5.js";

package/dist/verified-recall.js

@@ -1,14 +1,14 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-JOOGPZJE.js";
+} from "./chunk-XXW3P3RX.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-5KZNWERU.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/who-knows-cli.js

@@ -4,14 +4,14 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-GSBSGT43.js";
-import "./chunk-WT2VVYBM.js";
-import "./chunk-5KZNWERU.js";
+} from "./chunk-FPHU6KVI.js";
+import "./chunk-PJXSBXEC.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/dist/who-knows.js

@@ -9,13 +9,13 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-WT2VVYBM.js";
-import "./chunk-5KZNWERU.js";
+} from "./chunk-PJXSBXEC.js";
+import "./chunk-BIYVUPC6.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
 import "./chunk-G6OFEGUR.js";
-import "./chunk-V2XMG7GM.js";
+import "./chunk-CHNZPOWX.js";
 import "./chunk-4QLKVZH6.js";
 import "./chunk-XKDQTDXN.js";
 import "./chunk-CYEPCZN5.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.39",
+  "version": "10.0.40",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3347,7 +3347,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.39"
+    "@remnic/coding-graph": "^10.0.40"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-entity-principal.test.ts

@@ -0,0 +1,190 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test, { type TestContext } from "node:test";
+import { EngramAccessHttpServer } from "./access-http.js";
+import { getOperation } from "./access-boundary.js";
+import { EngramAccessService } from "./access-service.js";
+import { createChatExecutor } from "./chat/chat-executor.js";
+import { parseConfig } from "./config.js";
+import { NamespaceStorageRouter } from "./namespaces/storage.js";
+import type { Orchestrator } from "./orchestrator.js";
+
+interface EntityHttpBody {
+  error?: string;
+  found?: boolean;
+  namespace?: string;
+  entities?: Array<{ name?: string }>;
+  entity?: { name?: string };
+}
+
+interface McpToolBody {
+  result: { isError: boolean; content: Array<{ text: string }>; structuredContent: { entity: { name: string } } };
+}
+
+async function readMcp(response: Response): Promise<McpToolBody> {
+  // SAFETY: /mcp answers tools/call with the JSON-RPC result shape named above; each test asserts the fields it reads.
+  return (await response.json()) as McpToolBody;
+}
+
+async function readBody(response: Response): Promise<EntityHttpBody> {
+  // SAFETY: the access server answers these routes with the JSON shape named above; each test asserts the fields it reads.
+  return (await response.json()) as EntityHttpBody;
+}
+
+/** Entity reads need only config and real storage routing from the orchestrator. */
+async function createFixture(t: TestContext, namespacesEnabled = true) {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-entity-acl-"));
+  t.after(() => rm(memoryDir, { recursive: true, force: true }));
+  const config = parseConfig({
+    memoryDir,
+    namespacesEnabled,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [
+      { name: "default", readPrincipals: ["owner"], writePrincipals: ["owner"] },
+      { name: "restricted", readPrincipals: ["owner", "reader"], writePrincipals: ["owner"] },
+    ],
+  });
+  const router = new NamespaceStorageRouter(config);
+  for (const namespace of namespacesEnabled ? ["default", "restricted"] : ["default"]) {
+    const storage = await router.storageFor(namespace);
+    const entitiesDir = path.join(storage.dir, "entities");
+    await mkdir(entitiesDir, { recursive: true });
+    await writeFile(path.join(entitiesDir, "project-widget.md"), [
+      `# Widget-${namespace}`,
+      "",
+      "**Type:** project",
+      "",
+      "## Summary",
+      "",
+      `Synthetic entity in ${namespace}.`,
+      "",
+    ].join("\n"));
+  }
+  const dependencies: Pick<Orchestrator, "config" | "getStorage"> = {
+    config,
+    getStorage: (namespace) => router.storageFor(namespace ?? config.defaultNamespace),
+  };
+  // SAFETY: the entity read paths touch only `config` and `getStorage` (the Pick above); the rest of the Orchestrator is unused here.
+  return new EngramAccessService(dependencies as Orchestrator);
+}
+
+test("entity service enforces read ACLs and requires a principal before list/get", async (t) => {
+  const service = await createFixture(t);
+  await assert.rejects(() => service.entityList({ namespace: "restricted" }, "intruder"), /not readable/);
+  await assert.rejects(() => service.entityGet("project-widget", "restricted", "intruder"), /not readable/);
+  await assert.rejects(() => service.entityList({ namespace: "restricted" }), /authentication required/);
+  await assert.rejects(() => service.entityGet("project-widget", "restricted"), /authentication required/);
+  await assert.rejects(() => service.entityList({}, "reader"), /not readable/);
+  await assert.rejects(() => service.entityGet("project-widget", undefined, "reader"), /not readable/);
+
+  const list = await service.entityList({ namespace: " restricted ", query: "widget", limit: 1 }, "reader");
+  assert.equal(list.namespace, "restricted");
+  assert.equal(list.total, 1);
+  assert.equal(list.entities[0]?.name, "Widget-restricted");
+  const entity = await service.entityGet("project-widget", " restricted ", "reader");
+  assert.equal(entity.namespace, "restricted");
+  assert.equal(entity.entity?.name, "Widget-restricted");
+  assert.deepEqual(await service.entityGet("missing", "restricted", "reader"), {
+    found: false, namespace: "restricted",
+  });
+});
+
+test("entity service retains principal-free reads when namespaces are disabled", async (t) => {
+  const service = await createFixture(t, false);
+  assert.equal((await service.entityList()).entities[0]?.name, "Widget-default");
+  assert.equal((await service.entityGet("project-widget")).entity?.name, "Widget-default");
+});
+
+test("entity_list registry dispatch preserves the trusted principal", async (t) => {
+  const service = await createFixture(t);
+  const operation = getOperation("entity_list");
+  assert.ok(operation);
+  await assert.rejects(
+    () => operation.run({ principal: "owner" }, { service, authenticatedPrincipal: "reader" }),
+    /not readable/,
+  );
+  const output = await operation.run({}, { service, authenticatedPrincipal: "owner" });
+  const result = JSON.parse(JSON.stringify(output)).result;
+  assert.equal(result.namespace, "default");
+  assert.equal(result.entities[0]?.name, "Widget-default");
+});
+
+test("HTTP and MCP entity reads bind ACLs to the transport principal across aliases", async (t) => {
+  const service = await createFixture(t);
+  const token = "synthetic-entity-token";
+  const server = new EngramAccessHttpServer({
+    service,
+    host: "127.0.0.1",
+    port: 0,
+    principal: "reader",
+    enableAdapters: false,
+    trustPrincipalHeader: false,
+    authTokenEntriesGetter: () => [{
+      token,
+      capabilities: { version: 1, ops: ["entity_get", "entity_list"], namespaces: ["default", "restricted"] },
+    }],
+  });
+  const started = await server.start();
+  t.after(() => server.stop());
+  const base = `http://${started.host}:${started.port}`;
+  const headers = {
+    authorization: `Bearer ${token}`,
+    "content-type": "application/json",
+    "x-engram-principal": "owner",
+  };
+  for (const prefix of ["engram", "remnic"]) {
+    // The entity HTTP routes are served under /engram/v1 only; the /remnic prefix is an alias for the MCP tool names below.
+    for (const suffix of prefix === "engram" ? ["entities", "entities/project-widget"] : []) {
+      const denied = await fetch(`${base}/${prefix}/v1/${suffix}?namespace=default&principal=owner`, { headers });
+      assert.equal(denied.status, 400);
+      assert.match((await readBody(denied)).error ?? "", /not readable/);
+      const allowed = await fetch(`${base}/${prefix}/v1/${suffix}?namespace=restricted`, { headers });
+      assert.equal(allowed.status, 200);
+      const body = await readBody(allowed);
+      assert.equal(body.namespace, "restricted");
+      assert.equal(suffix === "entities" ? body.entities?.[0]?.name : body.entity?.name, "Widget-restricted");
+    }
+    if (prefix === "engram") {
+      const missing = await fetch(`${base}/${prefix}/v1/entities/missing?namespace=restricted`, { headers });
+      assert.equal(missing.status, 404);
+      assert.equal((await readBody(missing)).found, false);
+    }
+
+    for (const namespace of ["default", "restricted"]) {
+      const response = await fetch(`${base}/mcp`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: `${prefix}-${namespace}`,
+          method: "tools/call",
+          params: {
+            name: `${prefix}.entity_get`,
+            arguments: {
+              name: "project-widget", namespace, principal: "owner", authenticatedPrincipal: "owner",
+            },
+          },
+        }),
+      });
+      assert.equal(response.status, 200);
+      const body = await readMcp(response);
+      assert.equal(body.result.isError, namespace === "default");
+      if (namespace === "default") {
+        assert.match(body.result.content[0].text, /not readable/);
+      } else {
+        assert.equal(body.result.structuredContent.entity.name, "Widget-restricted");
+      }
+    }
+  }
+});
+
+test("chat entity reads preserve the bound principal instead of losing identity", async (t) => {
+  const service = await createFixture(t);
+  const allowed = createChatExecutor({ service, namespace: "restricted", principal: "reader" });
+  assert.equal(JSON.parse(await allowed.entityGet("project-widget")).entity.name, "Widget-restricted");
+  const denied = createChatExecutor({ service, namespace: "default", principal: "reader" });
+  await assert.rejects(() => denied.entityGet("project-widget"), /not readable/);
+});

package/src/access-http.ts

@@ -2168,7 +2168,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
         query: parsed.searchParams.get("q") ?? undefined,
         limit,
         offset,
-      });
+      }, this.resolveRequestPrincipal(req));
       this.respondJson(res, 200, response);
       return;
     }
@@ -2178,7 +2178,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       this.enforceTokenOp("entity_get"); // boundary dispatch (issue #1525)
       const entityName = decodeURIComponent(entityMatch[1] ?? "");
       const namespace = this.resolveNamespace(req, parsed.searchParams.get("namespace") ?? undefined);
-      const response = await this.service.entityGet(entityName, namespace);
+      const response = await this.service.entityGet(entityName, namespace, this.resolveRequestPrincipal(req));
       this.respondJson(res, response.found ? 200 : 404, response);
       return;
     }

package/src/access-operations-batch.ts

@@ -279,7 +279,7 @@ defineOperation({
     };
   },
 });
-defineOperation({ name: "entity_get", description: "Get entity.", schema: strictSchema({ name: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.entityGet(optStr(input.name) ?? "", optStr(input.namespace)) }) });
+defineOperation({ name: "entity_get", description: "Get entity.", schema: strictSchema({ name: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.entityGet(optStr(input.name) ?? "", optStr(input.namespace), ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "review_queue_list", description: "List review queue.", schema: strictSchema({ runId: S.str, namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.reviewQueue(optStr(input.runId) ?? "", optStr(input.namespace), ctx.authenticatedPrincipal) }) });
 // Issue #2482: observe validates through the canonical observeRequestSchema
 // (same as HTTP/MCP wire validation). Nullable wire fields (parts /
@@ -472,7 +472,7 @@ defineOperation({
     return { result: getRecallTimingStatus(ctx.service.configRef) };
   },
 });
-defineOperation({ name: "entity_list", description: "List entities.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.entityList() }) });
+defineOperation({ name: "entity_list", description: "List entities.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.entityList({}, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "maintenance_status", description: "Maintenance status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.maintenance() }) });
 defineOperation({ name: "quality_status", description: "Quality status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.quality() }) });
 defineOperation({ name: "trust_zones_status", description: "Trust-zone status.", schema: strictSchema({}), handler: async (_i, ctx) => ({ result: await ctx.service.trustZoneStatus() }) });

package/src/access-service.ts

@@ -3506,10 +3506,11 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
       query?: string;
       limit?: number;
       offset?: number;
-    } = {}
+    } = {},
+    principal?: string
   ): Promise<EngramAccessEntityListResponse> {
-    const storage = await this.orchestrator.getStorage(options.namespace);
-    const resolvedNamespace = options.namespace?.trim() || this.orchestrator.config.defaultNamespace;
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const { limit, offset } = normalizePagination(options.limit, options.offset);
     const query = options.query?.trim().toLowerCase() ?? "";
 
@@ -3553,9 +3554,9 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     };
   }
 
-  async entityGet(name: string, namespace?: string): Promise<EngramAccessEntityResponse> {
-    const storage = await this.orchestrator.getStorage(namespace);
-    const resolvedNamespace = namespace?.trim() || this.orchestrator.config.defaultNamespace;
+  async entityGet(name: string, namespace?: string, principal?: string): Promise<EngramAccessEntityResponse> {
+    const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const raw = await storage.readEntity(name);
     if (!raw) return { found: false, namespace: resolvedNamespace };
     return {

package/src/chat/chat-executor.ts

@@ -60,7 +60,7 @@ export function createChatExecutor(bindings: ChatExecutorBindings): ChatToolExec
     },
 
     async entityGet(name: string): Promise<string> {
-      const result = await service.entityGet(name, namespace);
+      const result = await service.entityGet(name, namespace, principal);
       return JSON.stringify(result);
     },
 

package/src/extraction-error-classification.ts

@@ -85,3 +85,26 @@ export function formatExtractionParseFailureLog(input: {
     `traceId=${input.traceId}`,
   ].join(" ");
 }
+
+/**
+ * The local endpoint answered, and what it said rejects this input (unusable content, or a client error that is not
+ * auth, timeout or rate limiting): the chunk's problem, not an outage. Retried like an empty parse, and a trigger-drain
+ * chunk that keeps drawing it is dropped after its recovery copy is saved.
+ */
+export class LocalLlmRejectedError extends Error {
+  constructor(readonly httpStatus?: number) {
+    super(httpStatus === undefined ? "local LLM answered with unusable content" : `local LLM rejected the input (HTTP ${httpStatus})`);
+    this.name = "LocalLlmRejectedError";
+  }
+}
+
+/** What the local client recorded about a failed call (`failureDiag`). */
+export interface LocalFailureDiag {
+  lastError?: unknown;
+}
+
+/** The HTTP status when the local endpoint answered and refuses this input (400, 413, 422); else undefined. A wrong model name or route (404, 405, 410), auth, timeout and rate limiting are the setup's problem, not the chunk's. */
+export function localRejectionStatus(diag: LocalFailureDiag): number | undefined {
+  const status = httpStatusFromError(diag.lastError);
+  return status !== undefined && [400, 413, 422].includes(status) ? status : undefined;
+}

package/src/extraction-local-failure-class.test.ts

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import { ExtractionEngine } from "./extraction.js";
+import type { BufferTurn } from "./types.js";
+
+// Follow-up to #3266: the trigger drain drops a chunk after N failures, but not for an outage. Whether a local-model failure
+// is the chunk's fault is decided here, by what the local endpoint did.
+const TURNS: BufferTurn[] = [
+  { role: "user", content: "I keep my backups on the NAS in the garage.", timestamp: "2026-10-30T01:00:00.000Z" },
+  { role: "assistant", content: "Noted.", timestamp: "2026-10-30T01:00:05.000Z" },
+];
+
+type LocalMessages = Array<{ role: string; content: string }>;
+type LocalStub = (messages: LocalMessages, options: { failureDiag?: { lastError?: Error } }) => Promise<{ content: string } | null>;
+
+async function extractWith(local: LocalStub) {
+  const engine = new ExtractionEngine(parseConfig({ localLlmEnabled: true, localLlmModel: "fixture-local", localLlmFallback: false }));
+  const modelRegistry = { calculateContextSizes: () => ({ maxInputChars: 8_000, maxOutputTokens: 1_000, description: "fixture" }) };
+  assert.equal(Reflect.set(engine, "localLlm", { chatCompletion: local }), true);
+  assert.equal(Reflect.set(engine, "modelRegistry", modelRegistry), true);
+  return await engine.extract(TURNS);
+}
+
+const withStatus = (status: number) => Object.assign(new Error("local LLM http failure"), { status });
+
+test("a local endpoint that answers with something unusable rejects the chunk: parse_empty", async () => {
+  const result = await extractWith(async () => ({ content: "I cannot help with that request." }));
+  assert.equal(result.extractionFailure, "local_llm_error");
+  assert.equal(result.extractionFailureClass, "parse_empty");
+});
+
+test("a local endpoint that answers with a client error rejects the chunk: parse_empty", async () => {
+  for (const status of [400, 413, 422]) {
+    const result = await extractWith(async (_messages, options) => {
+      if (options.failureDiag) options.failureDiag.lastError = withStatus(status);
+      return null;
+    });
+    assert.equal(result.extractionFailureClass, "parse_empty", `HTTP ${status}`);
+  }
+});
+
+test("not the chunk's fault: unreachable, timeout, 5xx, 429, auth and a wrong model or route (404) stay provider_retryable", async () => {
+  const outage = await extractWith(async () => null);
+  assert.equal(outage.extractionFailure, "local_llm_unavailable");
+  assert.equal(outage.extractionFailureClass, "provider_retryable");
+  for (const status of [401, 403, 404, 405, 408, 410, 429, 500, 503]) {
+    const result = await extractWith(async (_messages, options) => {
+      if (options.failureDiag) options.failureDiag.lastError = withStatus(status);
+      return null;
+    });
+    assert.equal(result.extractionFailureClass, "provider_retryable", `HTTP ${status}`);
+  }
+});