@remnic/core 9.7.10 → 9.7.11

package/dist/transfer/types.d.ts

@@ -20,26 +20,26 @@ declare const ExportManifestV1Schema: z.ZodObject<{
         bytes: number;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: 1;
+    format: "openclaw-engram-export";
     createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    format: "openclaw-engram-export";
-    pluginVersion: string;
+    schemaVersion: 1;
     includesTranscripts: boolean;
 }, {
-    schemaVersion: 1;
+    format: "openclaw-engram-export";
     createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    format: "openclaw-engram-export";
-    pluginVersion: string;
+    schemaVersion: 1;
     includesTranscripts: boolean;
 }>;
 type ExportManifestV1 = z.infer<typeof ExportManifestV1Schema>;
@@ -75,26 +75,26 @@ declare const ExportBundleV1Schema: z.ZodObject<{
             bytes: number;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: 1;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     }, {
-        schemaVersion: 1;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     }>;
     records: z.ZodArray<z.ZodObject<{
@@ -109,15 +109,15 @@ declare const ExportBundleV1Schema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     manifest: {
-        schemaVersion: 1;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     };
     records: {
@@ -126,15 +126,15 @@ declare const ExportBundleV1Schema: z.ZodObject<{
     }[];
 }, {
     manifest: {
-        schemaVersion: 1;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     };
     records: {
@@ -319,10 +319,10 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
+    description: string;
     id: string;
+    schemaVersion: string;
     version: string;
-    description: string;
     parentCapsule: string | null;
     retrievalPolicy: {
         tierWeights: Record<string, number>;
@@ -340,10 +340,10 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
+    description: string;
     id: string;
+    schemaVersion: string;
     version: string;
-    description: string;
     parentCapsule: string | null;
     retrievalPolicy: {
         tierWeights: Record<string, number>;
@@ -470,10 +470,10 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -491,10 +491,10 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -507,16 +507,14 @@ declare const ExportManifestV2Schema: z.ZodObject<{
         } | null | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: 2;
+    format: "openclaw-engram-export";
     createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    format: "openclaw-engram-export";
-    pluginVersion: string;
-    includesTranscripts: boolean;
     capsule: {
         includes: {
             procedural: boolean;
@@ -524,10 +522,10 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -539,17 +537,17 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             forkRoot: string;
         } | null;
     };
-}, {
     schemaVersion: 2;
+    includesTranscripts: boolean;
+}, {
+    format: "openclaw-engram-export";
     createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    format: "openclaw-engram-export";
-    pluginVersion: string;
-    includesTranscripts: boolean;
     capsule: {
         includes: {
             procedural: boolean;
@@ -557,10 +555,10 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -572,6 +570,8 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             forkRoot: string;
         } | null | undefined;
     };
+    schemaVersion: 2;
+    includesTranscripts: boolean;
 }>;
 type ExportManifestV2 = z.infer<typeof ExportManifestV2Schema>;
 declare const ExportBundleV2Schema: z.ZodObject<{
@@ -689,10 +689,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -710,10 +710,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -726,16 +726,14 @@ declare const ExportBundleV2Schema: z.ZodObject<{
             } | null | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: 2;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
             includes: {
                 procedural: boolean;
@@ -743,10 +741,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -758,17 +756,17 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null;
         };
-    }, {
         schemaVersion: 2;
+        includesTranscripts: boolean;
+    }, {
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
             includes: {
                 procedural: boolean;
@@ -776,10 +774,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -791,6 +789,8 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null | undefined;
         };
+        schemaVersion: 2;
+        includesTranscripts: boolean;
     }>;
     records: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
@@ -804,16 +804,14 @@ declare const ExportBundleV2Schema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     manifest: {
-        schemaVersion: 2;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
             includes: {
                 procedural: boolean;
@@ -821,10 +819,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -836,6 +834,8 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null;
         };
+        schemaVersion: 2;
+        includesTranscripts: boolean;
     };
     records: {
         content: string;
@@ -843,16 +843,14 @@ declare const ExportBundleV2Schema: z.ZodObject<{
     }[];
 }, {
     manifest: {
-        schemaVersion: 2;
+        format: "openclaw-engram-export";
         createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        format: "openclaw-engram-export";
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
             includes: {
                 procedural: boolean;
@@ -860,10 +858,10 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -875,6 +873,8 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null | undefined;
         };
+        schemaVersion: 2;
+        includesTranscripts: boolean;
     };
     records: {
         content: string;

package/package.json

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

package/src/access-boundary.ts

@@ -102,6 +102,8 @@ export const OPERATION_NAMES = [
   "shared_context_write_output",
   "shared_feedback_record",
   "shared_priorities_append",
+  "relay_mission_append",
+  "relay_mission_read",
   "shared_context_cross_signals_run",
   "shared_context_curate_daily",
   "compounding_weekly_synthesize",

package/src/access-http.ts

@@ -53,6 +53,7 @@ import { handleChatMessage, handleChatEventsSSE } from "./chat/chat-http.js";
 import { cleanupExpiredChatSessions, enforceChatSessionNamespace } from "./chat/chat-session.js";
 import { isDefaultReviewNamespace, listPairs, readPair } from "./contradiction/contradiction-review.js";
 import { isValidResolutionVerb, executeResolution } from "./contradiction/resolution.js";
+import { RelayMissionStoreError } from "./relay/mission.js";
 
 export interface AccessHttpReadinessState {
   ready: boolean;
@@ -339,6 +340,22 @@ function decodePeerIdSegment(raw: string): string {
   }
 }
 
+function decodeRelayMissionIdSegment(raw: string): string {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    throw new EngramAccessInputError(
+      "missionId path segment is not valid percent-encoded input",
+    );
+  }
+}
+
+function rejectBlankRelayNamespace(value: string | null | undefined): void {
+  if (value !== undefined && value !== null && value.trim().length === 0) {
+    throw new EngramAccessInputError("Relay namespace must not be blank when provided");
+  }
+}
+
 function codingContextFromProjectTag(projectTag: string): {
   projectId: string;
   branch: string | null;
@@ -378,7 +395,7 @@ export class EngramAccessHttpServer {
     res: ServerResponse,
     ctx: { authorized: boolean },
   ) => Promise<boolean>;
-  private readonly writeRequestTimestamps: number[] = [];
+  private readonly writeRequestSlots: Array<{ readonly recordedAt: number }> = [];
   private readonly writeRateLimitMaxRequests: number;
   private readonly writeRateLimitWindowMs: number;
   private readonly mcpServer: EngramMcpServer;
@@ -499,6 +516,20 @@ export class EngramAccessHttpServer {
             this.respondJson(res, 400, { error: err.message, code: "correction_contract_error" });
             return;
           }
+          if (err instanceof RelayMissionStoreError) {
+            const status = err.code === "idempotency_conflict"
+              ? 409
+              : err.code === "limit_exceeded"
+                ? 413
+                : err.code === "lock_unavailable"
+                  ? 503
+                  : 500;
+            this.respondJson(res, status, {
+              error: status >= 500 ? "relay_backend_unavailable" : err.message,
+              code: `relay_${err.code}`,
+            });
+            return;
+          }
           if (res.headersSent) {
             res.destroy(err as Error);
             return;
@@ -1670,6 +1701,103 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    // Remnic Relay mission receipts (issue #1966). These two routes share the
+    // access-boundary schemas and namespace-resolved storage contract. The
+    // browser receives an already-reduced snapshot; it never scans general
+    // memories, recall logs, or production state.
+    const relayEventMatch = /^\/engram\/v1\/relay\/missions\/([^/]+)\/events$/.exec(pathname);
+    if (req.method === "POST" && relayEventMatch) {
+      const missionId = decodeRelayMissionIdSegment(relayEventMatch[1] ?? "");
+      const body = await this.readJsonBody(req);
+      const unexpectedFields = Object.keys(body).filter(
+        (key) => key !== "namespace" && key !== "event",
+      );
+      if (unexpectedFields.length > 0) {
+        throw new EngramAccessInputError(
+          `Relay append body contains unexpected field(s): ${unexpectedFields.sort().join(", ")}`,
+        );
+      }
+      if (!Object.prototype.hasOwnProperty.call(body, "event")) {
+        throw new EngramAccessInputError("Relay append body must contain an event object");
+      }
+      if (
+        Object.prototype.hasOwnProperty.call(body, "namespace") &&
+        body.namespace !== undefined &&
+        body.namespace !== null &&
+        typeof body.namespace !== "string"
+      ) {
+        throw new EngramAccessInputError("namespace must be a string when provided");
+      }
+      rejectBlankRelayNamespace(
+        typeof body.namespace === "string" ? body.namespace : undefined,
+      );
+      const namespace = this.resolveNamespace(
+        req,
+        typeof body.namespace === "string" ? body.namespace : undefined,
+      );
+      const op = getOperation("relay_mission_append");
+      if (!op) {
+        throw new Error("access-boundary: operation not registered: relay_mission_append");
+      }
+      let releaseWriteQuota: (() => void) | undefined;
+      try {
+        const output = (await op.run(
+          { missionId, namespace, event: body.event },
+          {
+            service: this.service,
+            authenticatedPrincipal: this.resolveRequestPrincipal(req),
+            hooks: {
+              enforceWriteQuota: () => {
+                releaseWriteQuota ??= this.reserveWriteRateLimitSlot();
+              },
+            },
+          },
+        )) as { result: { appended: boolean; replayed: boolean; event: unknown } };
+        if (output.result.appended) {
+          // The reservation is now the committed quota hit. Do not record a
+          // second timestamp after the append returns.
+          releaseWriteQuota = undefined;
+        }
+        this.respondJson(res, output.result.appended ? 201 : 200, output.result);
+      } finally {
+        // Replays never invoke the hook. If a future store path invokes it but
+        // does not append, or persistence throws after reservation, return the
+        // slot so a failed write cannot exhaust the rolling window.
+        releaseWriteQuota?.();
+      }
+      return;
+    }
+
+    const relayMissionMatch = /^\/engram\/v1\/relay\/missions\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && relayMissionMatch) {
+      const missionId = decodeRelayMissionIdSegment(relayMissionMatch[1] ?? "");
+      rejectBlankRelayNamespace(parsed.searchParams.get("namespace"));
+      const namespace = this.resolveNamespace(
+        req,
+        parsed.searchParams.get("namespace") ?? undefined,
+      );
+      const op = getOperation("relay_mission_read");
+      if (!op) {
+        throw new Error("access-boundary: operation not registered: relay_mission_read");
+      }
+      const output = (await op.run(
+        {
+          missionId,
+          namespace,
+          since: parsed.searchParams.get("since") ?? undefined,
+          until: parsed.searchParams.get("until") ?? undefined,
+          limit: parsed.searchParams.get("limit") ?? undefined,
+        },
+        {
+          service: this.service,
+          authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        },
+      )) as { result: unknown };
+      res.setHeader("cache-control", "no-store");
+      this.respondJson(res, 200, output.result);
+      return;
+    }
+
     if (req.method === "POST" && pathname === "/engram/v1/memories") {
       // Migrated through the access boundary (issue #1525): the registry
       // entry owns schema validation, normalization, and service dispatch.
@@ -3711,18 +3839,31 @@ export class EngramAccessHttpServer {
   private ensureWriteRateLimitAvailable(): void {
     const now = Date.now();
     while (
-      this.writeRequestTimestamps.length > 0 &&
-      now - (this.writeRequestTimestamps[0] ?? 0) > this.writeRateLimitWindowMs
+      this.writeRequestSlots.length > 0 &&
+      now - (this.writeRequestSlots[0]?.recordedAt ?? 0) > this.writeRateLimitWindowMs
     ) {
-      this.writeRequestTimestamps.shift();
+      this.writeRequestSlots.shift();
     }
-    if (this.writeRequestTimestamps.length >= this.writeRateLimitMaxRequests) {
+    if (this.writeRequestSlots.length >= this.writeRateLimitMaxRequests) {
       throw new HttpError(429, "write_rate_limited", "write_rate_limited");
     }
   }
 
   private recordWriteRateLimitHit(): void {
-    this.writeRequestTimestamps.push(Date.now());
+    this.writeRequestSlots.push({ recordedAt: Date.now() });
+  }
+
+  private reserveWriteRateLimitSlot(): () => void {
+    this.ensureWriteRateLimitAvailable();
+    const slot = { recordedAt: Date.now() };
+    this.writeRequestSlots.push(slot);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      const index = this.writeRequestSlots.indexOf(slot);
+      if (index >= 0) this.writeRequestSlots.splice(index, 1);
+    };
   }
 
   private shouldCountWriteRateLimit(response: { dryRun?: boolean; idempotencyReplay?: boolean }): boolean {

package/src/access-mcp-cancellation.test.ts

@@ -282,7 +282,7 @@ test("MCP write quota is recorded after commit even when the client disconnects
   });
   const serverHost = server as unknown as {
     mcpServer: EngramMcpServer;
-    writeRequestTimestamps: number[];
+    writeRequestSlots: Array<{ readonly recordedAt: number }>;
   };
   const originalHandleRequest = serverHost.mcpServer.handleRequest.bind(serverHost.mcpServer);
   serverHost.mcpServer.handleRequest = async (request, options) => {
@@ -318,7 +318,7 @@ test("MCP write quota is recorded after commit even when the client disconnects
 
     await waitFor(operationSettled.promise);
     await new Promise<void>((resolve) => setImmediate(resolve));
-    assert.equal(serverHost.writeRequestTimestamps.length, 1);
+    assert.equal(serverHost.writeRequestSlots.length, 1);
     assert.equal(responseStarted, false, "the disconnected client must not receive the committed write response");
   } finally {
     releaseOperation.resolve();

package/src/access-operations.ts

@@ -678,6 +678,8 @@ export const codegraphIngestTracesOperation = defineOperation<
 // Batch-migrated operations (issue #1525): registers all remaining
 // handlers through the boundary as a side effect of importing this module.
 import "./access-operations-batch.js";
+// Remnic Relay mission evidence operations (issue #1966).
+import "./relay/mission-access.js";
 
 export const REGISTERED_OPERATIONS = [
   memoryGetOperation.spec.name,

package/src/access-surface-catalog.ts

@@ -193,6 +193,8 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "POST", pathname: "/engram/v1/lcm/compaction/flush", operation: "lcm_compaction_flush" },
   { method: "POST", pathname: "/engram/v1/lcm/compaction/record", operation: "lcm_compaction_record" },
   { method: "GET", pathname: "/engram/v1/lcm/status", operation: "lcm_status" },
+  { method: "GET", pathname: "/engram/v1/relay/missions/:id", operation: "relay_mission_read" },
+  { method: "POST", pathname: "/engram/v1/relay/missions/:id/events", operation: "relay_mission_append" },
   // Correction Contract (issue #1580) — plan/apply/pending.
   { method: "POST", pathname: "/engram/v1/correction/plan", operation: "memory_correct_plan" },
   { method: "POST", pathname: "/engram/v1/correction/apply", operation: "memory_correct_apply" },