@remnic/core 9.63.0 → 9.63.1

package/dist/transfer/types.d.ts

@@ -20,26 +20,26 @@ declare const ExportManifestV1Schema: z.ZodObject<{
         bytes: number;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: 1;
-    createdAt: string;
     format: "openclaw-engram-export";
+    createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    pluginVersion: string;
+    schemaVersion: 1;
     includesTranscripts: boolean;
 }, {
-    schemaVersion: 1;
-    createdAt: string;
     format: "openclaw-engram-export";
+    createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    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;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     }, {
-        schemaVersion: 1;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        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;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     };
     records: {
@@ -126,15 +126,15 @@ declare const ExportBundleV1Schema: z.ZodObject<{
     }[];
 }, {
     manifest: {
-        schemaVersion: 1;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
+        schemaVersion: 1;
         includesTranscripts: boolean;
     };
     records: {
@@ -313,16 +313,16 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    description: string;
     id: string;
+    schemaVersion: string;
     version: string;
-    description: string;
     parentCapsule: string | null;
     retrievalPolicy: {
         tierWeights: Record<string, number>;
@@ -334,16 +334,16 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         forkRoot: string;
     } | null;
 }, {
-    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
+    description: string;
     id: string;
+    schemaVersion: string;
     version: string;
-    description: string;
     parentCapsule: string | null;
     retrievalPolicy: {
         tierWeights: Record<string, number>;
@@ -464,16 +464,16 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -485,16 +485,16 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             forkRoot: string;
         } | null;
     }, {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -507,27 +507,25 @@ declare const ExportManifestV2Schema: z.ZodObject<{
         } | null | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
-    schemaVersion: 2;
-    createdAt: string;
     format: "openclaw-engram-export";
+    createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    pluginVersion: string;
-    includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        description: string;
         id: string;
+        schemaVersion: string;
         version: string;
-        description: string;
         parentCapsule: string | null;
         retrievalPolicy: {
             tierWeights: Record<string, number>;
@@ -539,28 +537,28 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             forkRoot: string;
         } | null;
     };
-}, {
     schemaVersion: 2;
-    createdAt: string;
+    includesTranscripts: boolean;
+}, {
     format: "openclaw-engram-export";
+    createdAt: string;
+    pluginVersion: string;
     files: {
         path: string;
         sha256: string;
         bytes: number;
     }[];
-    pluginVersion: string;
-    includesTranscripts: boolean;
     capsule: {
-        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
+        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<{
@@ -683,16 +683,16 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -704,16 +704,16 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null;
         }, {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -726,27 +726,25 @@ declare const ExportBundleV2Schema: z.ZodObject<{
             } | null | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
-        schemaVersion: 2;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            description: string;
             id: string;
+            schemaVersion: string;
             version: string;
-            description: string;
             parentCapsule: string | null;
             retrievalPolicy: {
                 tierWeights: Record<string, number>;
@@ -758,28 +756,28 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 forkRoot: string;
             } | null;
         };
-    }, {
         schemaVersion: 2;
-        createdAt: string;
+        includesTranscripts: boolean;
+    }, {
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            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,27 +804,25 @@ declare const ExportBundleV2Schema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     manifest: {
-        schemaVersion: 2;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            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,27 +843,25 @@ declare const ExportBundleV2Schema: z.ZodObject<{
     }[];
 }, {
     manifest: {
-        schemaVersion: 2;
-        createdAt: string;
         format: "openclaw-engram-export";
+        createdAt: string;
+        pluginVersion: string;
         files: {
             path: string;
             sha256: string;
             bytes: number;
         }[];
-        pluginVersion: string;
-        includesTranscripts: boolean;
         capsule: {
-            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
+            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/dist/verified-recall.js

@@ -1,14 +1,14 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-BHO6RHE5.js";
+} from "./chunk-BE5SVRFC.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-CALURYWR.js";
+import "./chunk-OF6KQJ35.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-SXIMQLGV.js";
-import "./chunk-JFLKSD5V.js";
-import "./chunk-LTJTP5YQ.js";
+import "./chunk-A5BYPCDI.js";
+import "./chunk-4WW5FMUD.js";
 import "./chunk-CYEPCZN5.js";
 import "./chunk-DCUMFQYM.js";
 import "./chunk-VYISFWVX.js";
@@ -43,7 +43,7 @@ import "./chunk-RBOJCG4T.js";
 import "./chunk-GSTIBXBW.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-QCECHYZL.js";
+import "./chunk-E2GYBTSP.js";
 import "./chunk-URS5GSM7.js";
 import "./chunk-ZLQ37WJX.js";
 import "./chunk-IUM3VSHI.js";

package/package.json

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

package/src/orchestration/turn-ingestion.ts

@@ -123,6 +123,25 @@ export interface TurnIngestionOptions extends SourceConnectorProvenance {
   turnFingerprint?: string;
 }
 
+/**
+ * Flush-plan recovery imports are compacted material the host already
+ * summarized before appending it to the flush-plan file. Feeding those
+ * turns through LCM observation again re-summarizes the same content
+ * (issue #2457). The producer stamps both a dedicated `sourceLabel` and a
+ * `:flush-plan[:chunk]`-shaped `sourceId`, so either marker identifies a
+ * recovery turn; ordinary bulk-import turns never carry either.
+ */
+function isFlushPlanRecoveryTurn(
+  turn: Pick<BufferTurn, "importProvenance">,
+): boolean {
+  const provenance = turn.importProvenance;
+  if (provenance?.sourceLabel === "OpenClaw flush plan") return true;
+  return (
+    typeof provenance?.sourceId === "string" &&
+    /:flush-plan(:\d+\/\d+)?$/.test(provenance.sourceId)
+  );
+}
+
 export class TurnIngestionCoordinator {
   constructor(
     private readonly deps: TurnIngestionDeps,
@@ -456,7 +475,11 @@ export class TurnIngestionCoordinator {
       };
     }
 
-    if (this.deps.lcmEngine?.enabled) {
+    // Skip LCM only when every turn is flush-plan recovery material; a mixed
+    // batch keeps the ordinary observe path (issue #2457). Extraction and
+    // persistence below are unaffected either way.
+    const skipLcmObservation = sessionTurns.every(isFlushPlanRecoveryTurn);
+    if (!skipLcmObservation && this.deps.lcmEngine?.enabled) {
       await this.deps.lcmEngine.observeMessages(
         sessionKey,
         sessionTurns.map((turn) => ({

package/src/orchestrator-flush.test.ts

@@ -12,8 +12,10 @@ import { TurnIngestionCoordinator } from "./orchestration/turn-ingestion.js";
 import { SmartBuffer } from "./buffer.js";
 import { parseConfig } from "./config.js";
 import { stableHash } from "./coding/git-context.js";
-import type { BufferState, BufferTurn } from "./types.js";
+import type { BufferState, BufferTurn, PluginConfig } from "./types.js";
 import type { ImportTurn } from "./bulk-import/types.js";
+import type { LcmEngine } from "./lcm/index.js";
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
 import { namespaceIdentityToken } from "./namespaces/identity.js";
 import { readNamespaceMaintenanceStatuses } from "./maintenance/namespace-planner.js";
 import { stubPersistExtraction } from "./testing/orchestrator-lite.js";
@@ -28,6 +30,22 @@ function makeTurn(sessionKey: string, content: string, sessionOwnerPrincipal?: s
   };
 }
 
+/**
+ * Writable orchestrator double for `ingestBulkImportBatch` slice tests: the
+ * real prototype methods run, but the per-test stub surface must stay
+ * assignable (the real class marks these fields readonly).
+ */
+interface BulkImportTestDouble {
+  config: PluginConfig;
+  extractionQueueCoordinator: ExtractionQueueCoordinator;
+  lcmEngine: LcmEngine | null;
+  runExtraction: (
+    turns: BufferTurn[],
+    options?: Record<string, unknown>,
+  ) => Promise<ExtractionRunResult>;
+  ingestBulkImportBatch: Orchestrator["ingestBulkImportBatch"];
+}
+
 interface ScopedFlushTestDouble {
   buffer: {
     getTurns(bufferKey: string): BufferTurn[];
@@ -804,6 +822,129 @@ test("ingestBulkImportBatch can disable source-valid-at replay context", async (
   );
 });
 
+test("ingestBulkImportBatch skips LCM observation for flush-plan recovery batches (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observedSessionKeys: string[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (sessionKey: string) => {
+      observedSessionKeys.push(sessionKey);
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  const extractedSlices: BufferTurn[][] = [];
+  orchestrator.runExtraction = async (turns: BufferTurn[]) => {
+    extractedSlices.push(turns);
+    return { status: "completed", persistedCount: 1, durableOutputCount: 1 };
+  };
+
+  const result = await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Recovery material the host already compacted once.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan",
+      },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Chunked recovery material.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan:2/3",
+      },
+    },
+  ]);
+
+  assert.deepEqual(observedSessionKeys, []);
+  assert.equal(extractedSlices.length, 2);
+  assert.equal(result.extractionCount, 2);
+  assert.equal(result.persistedCount, 2);
+});
+
+test("ingestBulkImportBatch still observes ordinary bulk imports through LCM (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observed: { sessionKey: string; turnCount: number }[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (sessionKey: string, messages: unknown[]) => {
+      observed.push({ sessionKey, turnCount: messages.length });
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  orchestrator.runExtraction = async () => ({
+    status: "completed",
+    persistedCount: 1,
+    durableOutputCount: 1,
+  });
+
+  await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Ordinary chatgpt import turn.",
+      importProvenance: { sourceLabel: "chatgpt", sourceId: "cg-1" },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Ordinary turn without provenance.",
+    },
+  ]);
+
+  assert.deepEqual(
+    observed.map((entry) => entry.turnCount),
+    [2],
+  );
+  assert.ok(observed[0]?.sessionKey.startsWith("bulk-import:batch:"));
+});
+
+test("ingestBulkImportBatch observes mixed batches that contain flush-plan turns (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observed: number[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (_sessionKey: string, messages: unknown[]) => {
+      observed.push(messages.length);
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  orchestrator.runExtraction = async () => ({
+    status: "completed",
+    persistedCount: 1,
+    durableOutputCount: 1,
+  });
+
+  await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Recovery material mixed into an ordinary batch.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan",
+      },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Ordinary chatgpt import turn.",
+      importProvenance: { sourceLabel: "chatgpt", sourceId: "cg-2" },
+    },
+  ]);
+
+  assert.deepEqual(observed, [2]);
+});
+
 test("ingestBulkImportBatch preserves partial metadata failure before a later slice rejects", async () => {
   const orchestrator = Object.create(Orchestrator.prototype) as any;
   orchestrator.config = parseConfig({});