@remnic/core 9.3.551 → 9.3.552

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.551",
+  "version": "9.3.552",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-http.ts

@@ -861,6 +861,7 @@ export class EngramAccessHttpServer {
       const response = await this.service.recallExplain({
         sessionKey: body.sessionKey,
         namespace: this.resolveNamespace(req, body.namespace),
+        authenticatedPrincipal: this.resolveRequestPrincipal(req),
       });
       this.respondJson(res, 200, response);
       return;

package/src/access-mcp.ts

@@ -2136,6 +2136,7 @@ export class EngramMcpServer {
         return this.service.recallExplain({
           sessionKey: typeof args.sessionKey === "string" ? args.sessionKey : undefined,
           namespace: typeof args.namespace === "string" ? args.namespace : undefined,
+          authenticatedPrincipal: effectivePrincipal,
         });
       case "engram.set_coding_context": {
         // Issue #569 PR 7 — MCP tool for clients that don't ship cwd.

package/src/access-service.ts

@@ -354,6 +354,8 @@ export interface EngramAccessRecallResponse {
 export interface EngramAccessRecallExplainRequest {
   sessionKey?: string;
   namespace?: string;
+  /** Caller principal for namespace access checks. Transport-bound; never from untrusted payloads. */
+  authenticatedPrincipal?: string;
 }
 
 export interface EngramAccessRecallExplainResponse {
@@ -1094,7 +1096,7 @@ export class EngramAccessService {
     return resolved;
   }
 
-  private resolveRequestPrincipal(sessionKey: string | undefined, authenticatedPrincipal?: string): string {
+  private resolveRequestPrincipal(sessionKey: string | undefined, authenticatedPrincipal?: string): string | undefined {
     const trusted = authenticatedPrincipal?.trim();
     if (trusted) return trusted;
     return resolvePrincipal(sessionKey, this.orchestrator.config);
@@ -1763,7 +1765,13 @@ export class EngramAccessService {
     const normalizedRequest = { ...request, query };
     const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
     const principal = this.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
-    return this.withBudgetLock(principal, async () => {
+    if (this.orchestrator.config.namespacesEnabled && !principal) {
+      throw new EngramAccessInputError(
+        "authentication required: namespaces are enabled and no principal was supplied",
+      );
+    }
+    const budgetLockPrincipal = principal ?? "default";
+    return this.withBudgetLock(budgetLockPrincipal, async () => {
       let budgetRecordPrincipal: string | null = null;
       const response = await this.handleIdempotentRead({
         operation: "recall",
@@ -1839,7 +1847,13 @@ export class EngramAccessService {
     // Normalize mode early so that no_recall / invalid modes skip budget
     // accounting (Codex P1: budget recorded before mode validation).
     const mode = this.normalizeRecallMode(request.mode);
-    const principal = this.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
+    const maybePrincipal = this.resolveRequestPrincipal(request.sessionKey, authenticatedPrincipal);
+    if (this.orchestrator.config.namespacesEnabled && !maybePrincipal) {
+      throw new EngramAccessInputError(
+        "authentication required: namespaces are enabled and no principal was supplied",
+      );
+    }
+    const principal = maybePrincipal ?? "default";
     const principalNamespace = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
     // Skip budget checks for modes that never perform a cross-namespace read.
     const modeSkipsBudget = mode === "no_recall";
@@ -2096,7 +2110,7 @@ export class EngramAccessService {
     let auditAnomalies: AccessAuditResult["anomalies"] | undefined;
     if (this.auditAdapter) {
       try {
-        const resolvedAgentId = principal;
+        const resolvedAgentId = principal ?? "__anonymous__";
         const auditEntry = {
           ts: new Date().toISOString(),
           sessionKey: request.sessionKey ?? "",
@@ -2160,11 +2174,19 @@ export class EngramAccessService {
     const requestedNamespace = request.namespace?.trim()
       ? this.resolveNamespace(request.namespace)
       : undefined;
+    const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+    const principal =
+      authenticatedPrincipal
+      || resolvePrincipal(request.sessionKey, this.orchestrator.config);
     if (requestedNamespace) {
-      const principal = resolvePrincipal(request.sessionKey, this.orchestrator.config);
       if (!canReadNamespace(principal, requestedNamespace, this.orchestrator.config)) {
         return { found: false };
       }
+    } else if (
+      this.orchestrator.config.namespacesEnabled
+      && !principal
+    ) {
+      return { found: false };
     }
     const snapshot = request.sessionKey
       ? (() => {
@@ -2179,13 +2201,29 @@ export class EngramAccessService {
         if (!requestedNamespace) return candidate;
         return candidate.namespace === requestedNamespace ? candidate : null;
       })();
-    const namespace = requestedNamespace ?? snapshot?.namespace ?? this.orchestrator.config.defaultNamespace;
+    const readableSnapshot = (() => {
+      if (!snapshot || !this.orchestrator.config.namespacesEnabled) return snapshot;
+      const snapshotNamespace = snapshot.namespace ?? this.orchestrator.config.defaultNamespace;
+      return canReadNamespace(principal, snapshotNamespace, this.orchestrator.config)
+        ? snapshot
+        : null;
+    })();
+    const namespace = (() => {
+      if (requestedNamespace) return requestedNamespace;
+      if (readableSnapshot?.namespace) return readableSnapshot.namespace;
+      const fallbackNamespace = this.orchestrator.config.defaultNamespace;
+      if (!this.orchestrator.config.namespacesEnabled) return fallbackNamespace;
+      return canReadNamespace(principal, fallbackNamespace, this.orchestrator.config)
+        ? fallbackNamespace
+        : null;
+    })();
+    if (!namespace) return { found: false };
     const [intent, graph] = await Promise.all([
       this.orchestrator.getLastIntentSnapshot(namespace),
       this.orchestrator.getLastGraphRecallSnapshot(namespace),
     ]);
-    if (!snapshot && !intent && !graph) return { found: false };
-    return { found: true, snapshot: snapshot ?? undefined, intent, graph };
+    if (!readableSnapshot && !intent && !graph) return { found: false };
+    return { found: true, snapshot: readableSnapshot ?? undefined, intent, graph };
   }
 
   async recallTierExplain(

package/src/active-memory-bridge.test.ts

@@ -134,6 +134,34 @@ test("recallForActiveMemory ignores explicit namespace filters when namespaces a
   assert.deepEqual(receivedNamespaces, ["self-namespace"]);
 });
 
+test("recallForActiveMemory denies blank session keys when namespaces are enabled", async () => {
+  const orchestrator = {
+    config: {
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      sharedNamespace: "shared",
+      namespacePolicies: [],
+      principalFromSessionKeyMode: "disabled",
+      principalFromSessionKeyRules: [],
+    },
+    searchAcrossNamespaces: async () => {
+      throw new Error("search should not run without an authenticated principal");
+    },
+  };
+
+  await assert.rejects(
+    () =>
+      recallForActiveMemory(orchestrator as never, {
+        query: "api docs",
+        sessionKey: "   ",
+        filters: {
+          namespace: "default",
+        },
+      }),
+    /authentication required/,
+  );
+});
+
 test("recallForActiveMemory marks results truncated when the underlying recall exceeds the requested limit", async () => {
   const orchestrator = {
     resolveSelfNamespace: () => "session-namespace",

package/src/active-memory-bridge.ts

@@ -38,7 +38,7 @@ export interface ActiveMemoryRecallParams {
 
 interface ActiveMemoryScopedOrchestrator {
   config?: PluginConfig;
-  resolvePrincipal?: (sessionKey?: string) => string;
+  resolvePrincipal?: (sessionKey?: string) => string | undefined;
   resolveSelfNamespace?: (sessionKey?: string) => string;
 }
 
@@ -105,6 +105,9 @@ function resolveActiveMemoryNamespace(
     typeof orchestrator.resolvePrincipal === "function"
       ? orchestrator.resolvePrincipal(sessionKey)
       : resolvePrincipal(sessionKey, config);
+  if (config.namespacesEnabled && !principal) {
+    throw new Error("authentication required: namespaces are enabled and no principal was supplied");
+  }
   if (explicitNamespace) {
     if (!canReadNamespace(principal, explicitNamespace, config)) {
       throw new Error(`namespace ${explicitNamespace} is not readable for principal ${principal}`);
@@ -120,7 +123,7 @@ function resolveActiveMemoryNamespace(
 export async function recallForActiveMemory(
   orchestrator: {
     config?: PluginConfig;
-    resolvePrincipal?: (sessionKey?: string) => string;
+    resolvePrincipal?: (sessionKey?: string) => string | undefined;
     resolveSelfNamespace?: (sessionKey?: string) => string;
     searchAcrossNamespaces: (params: {
       query: string;

package/src/namespaces/principal.test.ts

@@ -196,6 +196,26 @@ test("canReadNamespace: namespacesEnabled=true + no policy for namespace → all
   assert.equal(canReadNamespace("alice", "unknown-ns", config), false, "unknown namespace without policy is denied");
 });
 
+test("resolvePrincipal: missing session key cannot read implicit namespaces when namespaces are enabled", () => {
+  const config = makeConfig(true, []);
+
+  const principal = resolvePrincipal(undefined, config);
+
+  assert.equal(principal, undefined);
+  assert.equal(canReadNamespace(principal, "default", config), false);
+  assert.equal(canReadNamespace(principal, "shared", config), false);
+});
+
+test("resolvePrincipal: blank session key cannot read implicit namespaces when namespaces are enabled", () => {
+  const config = makeConfig(true, []);
+
+  const principal = resolvePrincipal("   ", config);
+
+  assert.equal(principal, undefined);
+  assert.equal(canReadNamespace(principal, "default", config), false);
+  assert.equal(canReadNamespace(principal, "shared", config), false);
+});
+
 test("resolvePrincipal: safe regex rules can resolve a principal", () => {
   const config = makeConfig(true, [], {
     principalFromSessionKeyMode: "regex",

package/src/namespaces/principal.ts

@@ -12,13 +12,15 @@ function compileSafePrincipalRegex(pattern: string): RegExp | null {
   }
 }
 
-export function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string {
+export function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string | undefined {
   if (!config.namespacesEnabled) return "default";
-  const sk = sessionKey ?? "";
+  const sk = typeof sessionKey === "string" && sessionKey.trim().length > 0
+    ? sessionKey
+    : "";
   const mode = config.principalFromSessionKeyMode;
   const rules = config.principalFromSessionKeyRules ?? [];
 
-  if (!sk) return "default";
+  if (!sk) return undefined;
 
   if (mode === "prefix") {
     for (const r of rules) {
@@ -48,15 +50,17 @@ export function resolvePrincipal(sessionKey: string | undefined, config: PluginC
   return "default";
 }
 
-export function canReadNamespace(principal: string, namespace: string, config: PluginConfig): boolean {
+export function canReadNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {
   if (!config.namespacesEnabled) return true;
+  if (!principal) return false;
   const policy = config.namespacePolicies.find((p) => p.name === namespace);
   if (!policy) return namespace === config.defaultNamespace || namespace === config.sharedNamespace;
   return policy.readPrincipals.includes(principal) || policy.readPrincipals.includes("*");
 }
 
-export function canWriteNamespace(principal: string, namespace: string, config: PluginConfig): boolean {
+export function canWriteNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {
   if (!config.namespacesEnabled) return true;
+  if (!principal) return false;
   const policy = config.namespacePolicies.find((p) => p.name === namespace);
   if (!policy) return namespace === config.defaultNamespace;
   return policy.writePrincipals.includes(principal) || policy.writePrincipals.includes("*");
@@ -69,15 +73,17 @@ export function canWriteNamespace(principal: string, namespace: string, config:
  * - If there's a namespace policy with the same name as the principal, use it.
  * - Otherwise use config.defaultNamespace.
  */
-export function defaultNamespaceForPrincipal(principal: string, config: PluginConfig): string {
+export function defaultNamespaceForPrincipal(principal: string | undefined, config: PluginConfig): string {
   if (!config.namespacesEnabled) return config.defaultNamespace;
+  if (!principal) return config.defaultNamespace;
   const exists = config.namespacePolicies.some((p) => p.name === principal);
   return exists ? principal : config.defaultNamespace;
 }
 
-export function recallNamespacesForPrincipal(principal: string, config: PluginConfig): string[] {
+export function recallNamespacesForPrincipal(principal: string | undefined, config: PluginConfig): string[] {
   const out: string[] = [];
   if (!config.namespacesEnabled) return [config.defaultNamespace];
+  if (!principal) return out;
 
   const selfNs = defaultNamespaceForPrincipal(principal, config);
   if (config.defaultRecallNamespaces.includes("self") && canReadNamespace(principal, selfNs, config)) {

package/src/orchestrator.ts

@@ -1686,7 +1686,7 @@ export class Orchestrator {
     this._recallWorkspaceOverrides.delete(sessionKey);
   }
 
-  resolvePrincipal(sessionKey?: string): string {
+  resolvePrincipal(sessionKey?: string): string | undefined {
     return resolvePrincipal(sessionKey, this.config);
   }
 
@@ -4841,6 +4841,15 @@ export class Orchestrator {
       options.abortSignal?.addEventListener("abort", onAbort, { once: true });
     }
 
+    const principal =
+      typeof options.principalOverride === "string" &&
+      options.principalOverride.length > 0
+        ? options.principalOverride
+        : resolvePrincipal(sessionKey, this.config);
+    if (this.config.namespacesEnabled && !principal) {
+      throw new Error("authentication required: namespaces are enabled and no principal was supplied");
+    }
+
     // Wait for initialization to complete before attempting recall. The timeout
     // is configurable so OpenClaw's per-hook budget and Remnic's internal init
     // gate can stay aligned during cold starts.
@@ -6451,6 +6460,9 @@ export class Orchestrator {
         && options.principalOverride.length > 0
         ? options.principalOverride
         : resolvePrincipal(sessionKey, this.config);
+    if (this.config.namespacesEnabled && !principal) {
+      throw new Error("authentication required: namespaces are enabled and no principal was supplied");
+    }
     const namespaceOverride = options.namespace?.trim() || undefined;
     const readableRecallNamespaces = recallNamespacesForPrincipal(
       principal,