@remnic/core 9.25.7 → 9.26.0

package/dist/verified-recall.js

@@ -1,17 +1,16 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-SSYBI43M.js";
+} from "./chunk-VGEH3STZ.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-ZBJMUXZH.js";
-import "./chunk-K4DP5KZA.js";
-import "./chunk-2QMKMVHH.js";
+import "./chunk-UZK7VVPD.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-2QMKMVHH.js";
 import "./chunk-DEBHXHJR.js";
 import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-J6A3CX5N.js";
 import "./chunk-HKF5VASQ.js";
+import "./chunk-J6A3CX5N.js";
 import "./chunk-V25OWXAC.js";
 import "./chunk-XKGPIWGI.js";
 import "./chunk-EGGE52UU.js";
@@ -28,12 +27,12 @@ import "./chunk-R3DJVOSM.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-JYIJNNN3.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-W5H6ZRPT.js";
 import "./chunk-5VQJBH2G.js";
 import "./chunk-AITCS2RC.js";
 import "./chunk-XMMESCPD.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-PDJTHRAW.js";
+import "./chunk-W5H6ZRPT.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-C23BYTJV.js";
 import "./chunk-QIEUU4UK.js";
@@ -49,6 +48,7 @@ import "./chunk-EYIEWJNI.js";
 import "./chunk-JUC24CTX.js";
 import "./chunk-6MKAMLQL.js";
 import "./chunk-JAKIDQB2.js";
+import "./chunk-ZBJMUXZH.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.25.7",
+  "version": "9.26.0",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2420,6 +2420,26 @@
       "remnic-source": "./src/session-integrity.ts",
       "import": "./dist/session-integrity.js"
     },
+    "./session-namespace-bindings": {
+      "types": "./dist/session-namespace-bindings.d.ts",
+      "remnic-source": "./src/session-namespace-bindings.ts",
+      "import": "./dist/session-namespace-bindings.js"
+    },
+    "./session-namespace-bindings.js": {
+      "types": "./dist/session-namespace-bindings.d.ts",
+      "remnic-source": "./src/session-namespace-bindings.ts",
+      "import": "./dist/session-namespace-bindings.js"
+    },
+    "./testing/lifecycle-matrix": {
+      "types": "./dist/testing/lifecycle-matrix.d.ts",
+      "remnic-source": "./src/testing/lifecycle-matrix.ts",
+      "import": "./dist/testing/lifecycle-matrix.js"
+    },
+    "./testing/lifecycle-matrix.js": {
+      "types": "./dist/testing/lifecycle-matrix.d.ts",
+      "remnic-source": "./src/testing/lifecycle-matrix.ts",
+      "import": "./dist/testing/lifecycle-matrix.js"
+    },
     "./session-observer-bands": {
       "types": "./dist/session-observer-bands.d.ts",
       "remnic-source": "./src/session-observer-bands.ts",
@@ -3056,7 +3076,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.25.7"
+    "@remnic/coding-graph": "^9.26.0"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-http-lcm-compaction.ts

@@ -0,0 +1,116 @@
+import type { ServerResponse } from "node:http";
+
+import type { LcmCompactionFlushRequest } from "./access-schema.js";
+import type { EngramAccessLcmCompactionFlushResponse, EngramAccessService } from "./access-service.js";
+
+type LcmCompactionService = Pick<EngramAccessService, "lcmCompactionFlush">;
+type JsonResponder = (res: ServerResponse, status: number, payload: unknown) => void;
+
+export interface LcmCompactionFlushHttpOptions {
+  body: LcmCompactionFlushRequest;
+  service: LcmCompactionService;
+  response: ServerResponse;
+  ensureWriteRateLimitAvailable: () => void;
+  recordWriteRateLimitHit: () => void;
+  resolveNamespace: (namespace?: string) => string | undefined;
+  defaultNamespace?: string;
+  resolveRequestPrincipal: () => string | undefined;
+  respondJson: JsonResponder;
+}
+
+export function respondLcmCompactionCapabilitiesHttp(response: ServerResponse): void {
+  response.statusCode = 200;
+  response.setHeader("content-type", "application/json; charset=utf-8");
+  response.end(JSON.stringify({ lcmCompactionFlushBatch: true }, null, 2));
+}
+
+export async function handleLcmCompactionFlushHttp({
+  body,
+  service,
+  response,
+  ensureWriteRateLimitAvailable,
+  recordWriteRateLimitHit,
+  resolveNamespace,
+  defaultNamespace,
+  resolveRequestPrincipal,
+  respondJson,
+}: LcmCompactionFlushHttpOptions): Promise<void> {
+  ensureWriteRateLimitAvailable();
+  const requestedNamespaces = body.namespaces;
+  if (requestedNamespaces === undefined) {
+    const result = await service.lcmCompactionFlush({
+      sessionKey: body.sessionKey,
+      namespace: resolveNamespace(body.namespace),
+      authenticatedPrincipal: resolveRequestPrincipal(),
+    });
+    recordWriteRateLimitHit();
+    respondJson(response, 200, result);
+    return;
+  }
+  const resolutionOutcomes = await Promise.allSettled(
+    requestedNamespaces.map(async (requestedNamespace) => {
+      const namespace = resolveNamespace(requestedNamespace);
+      return {
+        requestedNamespace,
+        namespace,
+        effectiveNamespace: namespace ?? defaultNamespace ?? "",
+      };
+    })
+  );
+  const uniqueResolvedNamespaces: Array<{
+    requestedNamespace: string;
+    namespace: string | undefined;
+    effectiveNamespace: string;
+  }> = [];
+  const queuedEffectiveNamespaces = new Set<string>();
+  for (const outcome of resolutionOutcomes) {
+    if (outcome.status === "fulfilled" && !queuedEffectiveNamespaces.has(outcome.value.effectiveNamespace)) {
+      queuedEffectiveNamespaces.add(outcome.value.effectiveNamespace);
+      uniqueResolvedNamespaces.push(outcome.value);
+    }
+  }
+  const serviceOutcomes = await Promise.allSettled(
+    uniqueResolvedNamespaces.map(({ namespace }) =>
+      service.lcmCompactionFlush({
+        sessionKey: body.sessionKey,
+        namespace,
+        authenticatedPrincipal: resolveRequestPrincipal(),
+      })
+    )
+  );
+  const serviceOutcomesByEffectiveNamespace = new Map<
+    string,
+    PromiseSettledResult<EngramAccessLcmCompactionFlushResponse>
+  >();
+  for (const [index, resolved] of uniqueResolvedNamespaces.entries()) {
+    const serviceOutcome = serviceOutcomes[index];
+    if (serviceOutcome !== undefined) {
+      serviceOutcomesByEffectiveNamespace.set(resolved.effectiveNamespace, serviceOutcome);
+    }
+  }
+  type BatchResult =
+    | {
+        requestedNamespace: string;
+        status: "fulfilled";
+        result: EngramAccessLcmCompactionFlushResponse;
+      }
+    | { requestedNamespace: string; status: "rejected" };
+  const results: BatchResult[] = resolutionOutcomes.map((outcome, index) => {
+    const requestedNamespace = requestedNamespaces[index] ?? "";
+    if (outcome.status === "rejected") {
+      return { status: "rejected", requestedNamespace };
+    }
+    const serviceOutcome = serviceOutcomesByEffectiveNamespace.get(outcome.value.effectiveNamespace);
+    return serviceOutcome?.status === "fulfilled"
+      ? { status: "fulfilled", requestedNamespace, result: serviceOutcome.value }
+      : { status: "rejected", requestedNamespace };
+  });
+  recordWriteRateLimitHit();
+  respondJson(response, 200, {
+    enabled: results.every((result) => result.status === "fulfilled" && result.result.enabled !== false),
+    flushed: results.every((result) => result.status === "fulfilled" && result.result.flushed !== false),
+    sessionKey: body.sessionKey,
+    namespaces: requestedNamespaces,
+    results: results.map(({ requestedNamespace, ...result }) => ({ ...result, namespace: requestedNamespace })),
+  });
+}

package/src/access-http.test.ts

@@ -108,6 +108,224 @@ test("HTTP memory browse rejects malformed pagination and sort query values", as
   }
 });
 
+test("HTTP batch LCM flush isolates namespace failures and charges one write quota", async () => {
+  const calls: Array<{ namespace?: string; sessionKey: string; authenticatedPrincipal?: string }> = [];
+  const service = {
+    lcmCompactionFlush: async (request: {
+      namespace?: string;
+      sessionKey: string;
+      authenticatedPrincipal?: string;
+    }) => {
+      calls.push(request);
+      if (request.namespace === "team-b") throw new Error("team-b flush failed");
+      return { enabled: true, flushed: true };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "batch-session",
+        namespaces: ["team-a", "team-b"],
+      }),
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      enabled: false,
+      flushed: false,
+      sessionKey: "batch-session",
+      namespaces: ["team-a", "team-b"],
+      results: [
+        {
+          status: "fulfilled",
+          namespace: "team-a",
+          result: { enabled: true, flushed: true },
+        },
+        { status: "rejected", namespace: "team-b" },
+      ],
+    });
+    assert.deepEqual(calls, [
+      {
+        sessionKey: "batch-session",
+        namespace: "team-a",
+        authenticatedPrincipal: undefined,
+      },
+      {
+        sessionKey: "batch-session",
+        namespace: "team-b",
+        authenticatedPrincipal: undefined,
+      },
+    ]);
+
+    const conflicting = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "batch-session",
+        namespace: "team-a",
+        namespaces: ["team-b"],
+      }),
+    });
+    assert.equal(conflicting.status, 400);
+    assert.equal(calls.length, 2, "conflicting namespace forms must fail before dispatch");
+
+    const rateLimited = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "batch-session",
+        namespaces: ["team-a"],
+      }),
+    });
+    assert.equal(rateLimited.status, 429);
+    assert.equal(calls.length, 2, "a batch consumes one write quota unit");
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP batch LCM flush deduplicates aliases after effective namespace resolution", async () => {
+  const calls: Array<{ namespace?: string; sessionKey: string; authenticatedPrincipal?: string }> = [];
+  const service = {
+    configRef: parseConfig({ namespacesEnabled: true, defaultNamespace: "default" }),
+    lcmCompactionFlush: async (request: {
+      namespace?: string;
+      sessionKey: string;
+      authenticatedPrincipal?: string;
+    }) => {
+      calls.push(request);
+      return { enabled: true, flushed: true };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "effective-namespace-session",
+        namespaces: ["", "default"],
+      }),
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      enabled: true,
+      flushed: true,
+      sessionKey: "effective-namespace-session",
+      namespaces: ["", "default"],
+      results: [
+        {
+          status: "fulfilled",
+          namespace: "",
+          result: { enabled: true, flushed: true },
+        },
+        {
+          status: "fulfilled",
+          namespace: "default",
+          result: { enabled: true, flushed: true },
+        },
+      ],
+    });
+    assert.deepEqual(calls, [
+      {
+        sessionKey: "effective-namespace-session",
+        namespace: undefined,
+        authenticatedPrincipal: undefined,
+      },
+    ]);
+  } finally {
+    await server.stop();
+  }
+});
+
+
+test("HTTP batch LCM flush isolates per-namespace authorization failures", async () => {
+  const calls: string[] = [];
+  const service = {
+    lcmCompactionFlush: async (request: { namespace?: string }) => {
+      calls.push(request.namespace ?? "");
+      return { enabled: true, flushed: true };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "unused-token",
+    authTokenEntriesGetter: () => [
+      {
+        token: "scoped-token",
+        capabilities: {
+          version: 1,
+          ops: ["lcm_compaction_flush"],
+          namespaces: ["team-a"],
+        },
+      },
+    ],
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer scoped-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "authorized-batch-session",
+        namespaces: ["team-a", "team-b"],
+      }),
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      enabled: false,
+      flushed: false,
+      sessionKey: "authorized-batch-session",
+      namespaces: ["team-a", "team-b"],
+      results: [
+        {
+          status: "fulfilled",
+          namespace: "team-a",
+          result: { enabled: true, flushed: true },
+        },
+        { status: "rejected", namespace: "team-b" },
+      ],
+    });
+    assert.deepEqual(calls, ["team-a"]);
+  } finally {
+    await server.stop();
+  }
+});
 test("HTTP admin console assets are public but API routes require bearer authentication", async () => {
   const service = {} as EngramAccessService;
   const server = new EngramAccessHttpServer({

package/src/access-http.ts

@@ -40,6 +40,7 @@ import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { getOperation, type OperationName } from "./access-boundary.js";
 import { authorizationProbeNamespaces, probeOperationAuthorization } from "./access-authorization-probe.js";
 import { resolveQueryNamespaceWritablePreflight } from "./access-namespace-preflight.js";
+import * as lcm from "./access-http-lcm-compaction.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -889,7 +890,7 @@ export class EngramAccessHttpServer {
       this.respondJson(res, 200, await this.service.health());
       return;
     }
-
+    if (req.method === "GET" && pathname === "/engram/v1/capabilities") return lcm.respondLcmCompactionCapabilitiesHttp(res);
     if (req.method === "GET" && pathname === "/engram/v1/authorization") {
       res.setHeader("cache-control", "no-store");
       const probe = probeOperationAuthorization(tokenCapabilityStore.getStore(), parsed.searchParams.getAll("op"));
@@ -1674,14 +1675,13 @@ export class EngramAccessHttpServer {
     ) {
       this.enforceTokenOp("lcm_compaction_flush"); // boundary dispatch (issue #1525)
       const body = await this.readValidatedBody(req, "lcmCompactionFlush");
-      this.ensureWriteRateLimitAvailable(req);
-      const response = await this.service.lcmCompactionFlush({
-        sessionKey: body.sessionKey,
-        namespace: this.resolveNamespace(req, body.namespace),
-        authenticatedPrincipal: this.resolveRequestPrincipal(req),
+      await lcm.handleLcmCompactionFlushHttp({
+        body, service: this.service,
+        response: res, ensureWriteRateLimitAvailable: () => this.ensureWriteRateLimitAvailable(req),
+        recordWriteRateLimitHit: () => this.recordWriteRateLimitHit(req),
+        resolveNamespace: (namespace) => this.resolveNamespace(req, namespace), defaultNamespace: this.service.configRef?.defaultNamespace,
+        resolveRequestPrincipal: () => this.resolveRequestPrincipal(req), respondJson: this.respondJson.bind(this),
       });
-      this.recordWriteRateLimitHit(req);
-      this.respondJson(res, 200, response);
       return;
     }
 

package/src/access-schema-pi.test.ts

@@ -49,6 +49,15 @@ test("LCM compaction schemas validate Pi extension requests", () => {
   assert.equal(record.success, true);
 });
 
+test("LCM compaction flush rejects duplicate namespace batches", () => {
+  const result = validateRequest("lcmCompactionFlush", {
+    sessionKey: "pi:session",
+    namespaces: ["work", "work"],
+  });
+
+  assert.equal(result.success, false);
+});
+
 test("LCM compaction record rejects invalid token counts", () => {
   const result = validateRequest("lcmCompactionRecord", {
     sessionKey: "pi:session",

package/src/access-schema.ts

@@ -331,10 +331,35 @@ export const lcmSearchRequestSchema = z.object({
   limit: z.number().int().min(1).max(100).optional(),
 });
 
-export const lcmCompactionFlushRequestSchema = z.object({
-  sessionKey: z.string().trim().min(1, "sessionKey is required").max(512),
-  namespace: namespaceSchema,
-});
+export const lcmCompactionFlushRequestSchema = z
+  .object({
+    sessionKey: z.string().trim().min(1, "sessionKey is required").max(512),
+    namespace: namespaceSchema,
+    /**
+     * Optional multi-namespace flush used by delegate lifecycle replay. The
+     * server handles the whole list as one quota-counted write.
+     */
+    namespaces: z.array(z.string().trim().max(256)).min(1).max(64).optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (value.namespace !== undefined && value.namespaces !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "namespace and namespaces are mutually exclusive",
+        path: ["namespaces"],
+      });
+    }
+    if (
+      value.namespaces !== undefined &&
+      new Set(value.namespaces).size !== value.namespaces.length
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "namespaces must not contain duplicates",
+        path: ["namespaces"],
+      });
+    }
+  });
 
 export const lcmCompactionRecordRequestSchema = z.object({
   sessionKey: z.string().trim().min(1, "sessionKey is required").max(512),

package/src/access-surface-catalog.test.ts

@@ -534,6 +534,7 @@ test("HTTP handler source routes match the catalog (static completeness)", () =>
 
   const INFRA = [
     /^\/engram\/v1\/health$/,
+    /^\/engram\/v1\/capabilities$/,
     /^\/engram\/v1\/authorization$/,
     /^\/engram\/v1\/admin\//,
     /^\/engram\/ui/,