@remnic/plugin-openclaw 1.0.31 → 1.0.32

package/README.md

@@ -25,7 +25,10 @@ Add the plugin to your `openclaw.json`:
     "slots": { "memory": "openclaw-remnic" },
     "entries": {
       "openclaw-remnic": {
-        "package": "@remnic/plugin-openclaw"
+        "package": "@remnic/plugin-openclaw",
+        "hooks": {
+          "allowConversationAccess": true
+        }
       }
     }
   }
@@ -205,6 +208,15 @@ Remnic supports the following OpenClaw memory integration points:
 | `before_prompt_build` hook (new SDK) | Supported | 2026.3.22 |
 | `registerMemoryPromptSection()` (structured builder) | Supported | 2026.3.22 |
 | `registerMemoryCapability()` (unified capability) | Supported | 2026.4.5 |
+| `registerMemoryRuntime()` (split runtime surface) | Supported | 2026.4.x |
+| `registerMemoryFlushPlan()` (split flush-plan surface) | Supported | 2026.4.x |
+| `registerMemoryCorpusSupplement()` (read-only corpus supplement) | Supported | 2026.4.x |
+
+On current OpenClaw SDKs, Remnic registers both the unified memory capability
+and the compatible split surfaces. That lets OpenClaw consume Remnic through
+the active memory runtime, the explicit flush-plan resolver, and additive
+corpus search/read APIs without changing Remnic's ownership of storage,
+retrieval, extraction, and QMD behavior.
 
 ### Public Artifacts (memory-wiki bridge)
 
@@ -224,6 +236,10 @@ Private runtime state (state/, questions/, transcripts/, archive/, buffers) is n
 
 With this feature, `openclaw wiki status` reports Remnic artifacts, and `memory-wiki` bridge mode can discover and ingest them.
 
+The corpus supplement exposes read-only search/get access to Remnic memories as
+the `remnic` corpus under a service-scoped supplement ID. It does not expose
+private plugin state, transcript buffers, auth metadata, or artifact paths.
+
 ### Session Lifecycle
 
 | Feature | Status | Since |

package/dist/index.js

@@ -72718,6 +72718,9 @@ var NODE_FS_MODULE_ID = ["node", "fs"].join(":");
 var NODE_FS_PROMISES_MODULE_ID = ["node", "fs/promises"].join(":");
 var READ_FILE_SYNC_FIELD = ["read", "File", "Sync"].join("");
 var EXISTS_SYNC_FIELD = ["exists", "Sync"].join("");
+function isMemoryArtifactPath(p) {
+  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
+}
 function readTextFileNow(filePath) {
   const nodeRequire = createRequire3(import.meta.url);
   const fs19 = nodeRequire(NODE_FS_MODULE_ID);
@@ -74140,7 +74143,7 @@ Keep the reflection grounded in the evidence below.
         api.registerMemoryPromptSection(memoryBuildFn);
         memoryPromptBuilder = memoryBuildFn;
       }
-      if (sdkCaps.hasRegisterMemoryCapability && typeof api.registerMemoryCapability === "function") {
+      if (sdkCaps.hasRegisterMemoryCapability && typeof api.registerMemoryCapability === "function" || typeof api.registerMemoryRuntime === "function" || typeof api.registerMemoryFlushPlan === "function") {
         const capabilityPromptBuilder = memoryPromptBuilder ? (params) => {
           const key = params?.sessionKey ?? "default";
           return consumePromptMemoryLines2(key, { destructive: false });
@@ -74249,11 +74252,10 @@ Keep the reflection grounded in the evidence below.
                     namespaces: namespace ? [namespace] : void 0,
                     mode: resolvedMode
                   });
-                  const isArtifactPath2 = (p) => /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(p);
                   return rawResults.filter((result) => {
                     const candidate = result;
                     const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
-                    return !isArtifactPath2(p);
+                    return !isMemoryArtifactPath(p);
                   }).map((result, index) => {
                     const candidate = result;
                     const rawPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `memory-${index + 1}`;
@@ -74365,6 +74367,18 @@ Keep the reflection grounded in the evidence below.
           async closeAllMemorySearchManagers() {
           }
         };
+        const remnicMemoryFlushPlanResolver = () => {
+          const maxTurnChars = typeof cfg.extractionMaxTurnChars === "number" && Number.isFinite(cfg.extractionMaxTurnChars) ? Math.max(1e3, Math.floor(cfg.extractionMaxTurnChars)) : 8e3;
+          return {
+            softThresholdTokens: 24e3,
+            forceFlushTranscriptBytes: Math.max(16384, maxTurnChars * 4),
+            reserveTokensFloor: 2e3,
+            model: typeof cfg.summaryModel === "string" && cfg.summaryModel.length > 0 ? cfg.summaryModel : cfg.model,
+            prompt: "Flush the recent OpenClaw transcript into Remnic memory. Preserve durable user preferences, project facts, decisions, corrections, and commitments. Ignore runtime metadata, credentials, and transient command noise.",
+            systemPrompt: "You are Remnic's memory flush planner. Produce concise durable memory candidates only when the transcript contains information worth remembering.",
+            relativePath: ["state", "plugins", serviceId, "flush-plan.md"].join("/")
+          };
+        };
         const memoryCapability = {
           // Include the promptBuilder so runtimes that treat unified capability
           // registration as authoritative (SDK >=2026.4.5) continue to inject
@@ -74372,6 +74386,7 @@ Keep the reflection grounded in the evidence below.
           // Respect promptInjectionAllowed policy — omit promptBuilder if injection
           // is disabled, so the capability only provides publicArtifacts.
           ...promptInjectionAllowed ? { promptBuilder: capabilityPromptBuilder } : {},
+          flushPlanResolver: remnicMemoryFlushPlanResolver,
           runtime: remnicMemoryRuntime,
           publicArtifacts: {
             listArtifacts: async (_params) => {
@@ -74388,9 +74403,18 @@ Keep the reflection grounded in the evidence below.
             }
           }
         };
-        api.registerMemoryCapability(memoryCapability);
+        if (typeof api.registerMemoryCapability === "function") {
+          api.registerMemoryCapability(memoryCapability);
+        }
+        if (typeof api.registerMemoryRuntime === "function") {
+          api.registerMemoryRuntime(remnicMemoryRuntime);
+        }
+        if (typeof api.registerMemoryFlushPlan === "function") {
+          api.registerMemoryFlushPlan(remnicMemoryFlushPlanResolver);
+        }
         const builderDesc = !promptInjectionAllowed ? " (promptBuilder omitted \u2014 injection disabled by policy)" : memoryPromptBuilder ? " and promptBuilder (from registerMemoryPromptSection)" : " and promptBuilder (capability-only fallback)";
-        log.info(`registered memory capability with runtime and publicArtifacts provider${builderDesc}`);
+        const capabilityDesc = typeof api.registerMemoryCapability === "function" ? `memory capability with publicArtifacts provider${builderDesc}` : "split memory runtime/flush-plan surfaces";
+        log.info(`registered ${capabilityDesc}`);
       }
       api.on(
         "agent_end",
@@ -74992,6 +75016,151 @@ Keep the reflection grounded in the evidence below.
         log.error("failed to auto-register hourly summary cron job:", err);
       }
     }
+    if (typeof api.registerMemoryCorpusSupplement === "function") {
+      const normalizeCorpusLookup = (lookup) => typeof lookup === "string" && lookup.trim().length > 0 ? lookup.trim() : null;
+      const resolveCorpusStorage = async (agentSessionKey) => {
+        const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(agentSessionKey) : void 0;
+        return typeof orchestrator.getStorageForNamespace === "function" ? await orchestrator.getStorageForNamespace(namespace) : orchestrator.storage;
+      };
+      const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+      const pathIsInside = (root, candidate) => {
+        const relative = path99.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path99.isAbsolute(relative);
+      };
+      const corpusPathCandidates = (rawPath, storageDir) => {
+        const candidates = /* @__PURE__ */ new Set();
+        const trimmed = rawPath.trim();
+        if (!trimmed) return [];
+        candidates.add(normalizeCorpusPath(trimmed));
+        if (path99.isAbsolute(trimmed)) {
+          const absolutePath = path99.resolve(trimmed);
+          const absoluteStorageDir = path99.resolve(storageDir);
+          if (pathIsInside(absoluteStorageDir, absolutePath)) {
+            candidates.add(normalizeCorpusPath(path99.relative(absoluteStorageDir, absolutePath)));
+          }
+        }
+        candidates.add(path99.basename(trimmed));
+        return [...candidates].filter((candidate) => candidate.length > 0);
+      };
+      const displayCorpusPath = (rawPath, storageDir) => {
+        const trimmed = rawPath.trim();
+        if (!trimmed) return "";
+        if (path99.isAbsolute(trimmed)) {
+          const absolutePath = path99.resolve(trimmed);
+          const absoluteStorageDir = path99.resolve(storageDir);
+          if (pathIsInside(absoluteStorageDir, absolutePath)) {
+            return normalizeCorpusPath(path99.relative(absoluteStorageDir, absolutePath));
+          }
+        }
+        return normalizeCorpusPath(trimmed);
+      };
+      const readMemoryByLookup = async (lookup, agentSessionKey) => {
+        const storage = await resolveCorpusStorage(agentSessionKey);
+        const storageDir = typeof storage.dir === "string" && storage.dir.length > 0 ? storage.dir : orchestrator.config.memoryDir;
+        const memories = await storage.readAllMemories();
+        const normalizedLookup = normalizeCorpusPath(lookup);
+        const matched = memories.find((memory) => memory.frontmatter.id === lookup) ?? memories.find(
+          (memory) => corpusPathCandidates(memory.path, storageDir).includes(normalizedLookup)
+        ) ?? null;
+        if (!matched) return null;
+        const displayPath = displayCorpusPath(matched.path, storageDir);
+        return { memory: matched, displayPath };
+      };
+      const corpusBackendError = (operation, err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = new Error(`Remnic corpus ${operation} failed: ${message}`);
+        error.cause = err;
+        return error;
+      };
+      const remnicCorpusSupplement = {
+        id: `${serviceId}:remnic-memory-corpus`,
+        label: "Remnic Memory Corpus",
+        async search(params) {
+          const query = normalizeCorpusLookup(
+            typeof params === "string" ? params : params?.query
+          );
+          if (!query) return [];
+          const maxResults = typeof params === "object" && typeof params.maxResults === "number" && Number.isFinite(params.maxResults) ? Math.max(1, Math.floor(params.maxResults)) : 8;
+          const agentSessionKey = typeof params === "object" ? params.agentSessionKey : void 0;
+          const namespace = typeof orchestrator.resolveSelfNamespace === "function" ? orchestrator.resolveSelfNamespace(agentSessionKey) : void 0;
+          try {
+            const rawResults = await orchestrator.searchAcrossNamespaces({
+              query,
+              maxResults,
+              namespaces: namespace ? [namespace] : void 0,
+              mode: "search"
+            });
+            return rawResults.filter((result) => {
+              const candidate = result;
+              const p = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : "";
+              return !isMemoryArtifactPath(p);
+            }).map((result, index) => {
+              const candidate = result;
+              const lookupPath = typeof candidate.path === "string" ? candidate.path : typeof candidate.id === "string" ? candidate.id : `remnic-memory-${index + 1}`;
+              const startLine = typeof candidate.startLine === "number" && Number.isFinite(candidate.startLine) ? Math.max(1, Math.floor(candidate.startLine)) : 1;
+              const endLine = typeof candidate.endLine === "number" && Number.isFinite(candidate.endLine) ? Math.max(startLine, Math.floor(candidate.endLine)) : startLine;
+              return {
+                corpus: "remnic",
+                path: lookupPath,
+                title: typeof candidate.id === "string" && candidate.id.length > 0 ? candidate.id : lookupPath,
+                kind: "memory",
+                score: typeof candidate.score === "number" && Number.isFinite(candidate.score) ? candidate.score : 0,
+                snippet: typeof candidate.snippet === "string" ? candidate.snippet : typeof candidate.text === "string" ? candidate.text : "",
+                id: typeof candidate.id === "string" ? candidate.id : lookupPath,
+                startLine,
+                endLine,
+                citation: lookupPath,
+                source: "remnic",
+                provenanceLabel: "Remnic",
+                sourceType: "memory",
+                sourcePath: lookupPath,
+                updatedAt: typeof candidate.metadata?.updatedAt === "string" ? candidate.metadata.updatedAt : void 0
+              };
+            });
+          } catch (err) {
+            log.warn(`memory corpus search failed: ${err}`);
+            throw corpusBackendError("search", err);
+          }
+        },
+        async get(params) {
+          const lookup = normalizeCorpusLookup(
+            typeof params === "string" ? params : params?.lookup
+          );
+          if (!lookup || isMemoryArtifactPath(lookup)) return null;
+          const agentSessionKey = typeof params === "object" ? params.agentSessionKey : void 0;
+          try {
+            const resolved = await readMemoryByLookup(lookup, agentSessionKey);
+            if (!resolved) return null;
+            const { memory, displayPath } = resolved;
+            if (isMemoryArtifactPath(displayPath) || isMemoryArtifactPath(memory.path)) {
+              return null;
+            }
+            const allLines = memory.content.split(/\r?\n/);
+            const fromLine = typeof params === "object" && typeof params.fromLine === "number" && Number.isFinite(params.fromLine) ? Math.max(1, Math.floor(params.fromLine)) : 1;
+            const lineCount = typeof params === "object" && typeof params.lineCount === "number" && Number.isFinite(params.lineCount) ? Math.max(1, Math.floor(params.lineCount)) : allLines.length;
+            const selected = allLines.slice(fromLine - 1, fromLine - 1 + lineCount);
+            return {
+              corpus: "remnic",
+              path: displayPath,
+              title: memory.frontmatter.id,
+              kind: memory.frontmatter.category,
+              content: selected.join("\n"),
+              fromLine,
+              lineCount: selected.length,
+              id: memory.frontmatter.id,
+              provenanceLabel: "Remnic",
+              sourceType: "memory",
+              sourcePath: displayPath,
+              updatedAt: memory.frontmatter.updated
+            };
+          } catch (err) {
+            log.warn(`memory corpus get failed: ${err}`);
+            throw corpusBackendError("get", err);
+          }
+        }
+      };
+      api.registerMemoryCorpusSupplement(remnicCorpusSupplement);
+    }
     if (cfg.openclawToolsEnabled !== false && typeof api.registerTool === "function") {
       api.registerTool(
         buildMemorySearchTool(orchestrator, {

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-remnic",
   "name": "Remnic OpenClaw Plugin",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "kind": "memory",
   "description": "Local semantic memory for OpenClaw with bundled Remnic core runtime. Requires plugins.slots.memory set to this plugin id for hooks to fire.",
   "setup": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/plugin-openclaw",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "OpenClaw adapter for Remnic memory with bundled @remnic/core runtime",
   "type": "module",
   "main": "dist/index.js",
@@ -63,7 +63,7 @@
   },
   "dependencies": {
     "openai": "^6.0.0",
-    "@remnic/core": "^1.1.8"
+    "@remnic/core": "^1.1.9"
   },
   "peerDependencies": {
     "openclaw": ">=2026.4.8"