@openviking/openclaw-plugin 2026.9.4-2 → 2026.9.5

package/config.ts

@@ -907,7 +907,7 @@ export const memoryOpenVikingConfigSchema = {
     bypassSessionPatterns: {
       label: "Bypass Session Patterns",
       placeholder: "agent:*:cron:**",
-      help: "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
+      help: "Completely bypass OpenViking for matching session keys (no capture, recall, or commit; compaction falls back to OpenClaw's native compactor). Use * within one segment and ** across segments.",
       advanced: true,
     },
     commitTokenThresholdRatio: {

package/context-engine.ts

@@ -19,6 +19,7 @@ import {
   compactOpenVikingSession,
   commitOpenVikingSession,
 } from "./services/context-lifecycle-service.js";
+import { loadRuntimeCompactionDelegate } from "./plugin/openclaw-runtime-compaction.js";
 
 type ContextEngineInfo = {
   id: string;
@@ -437,6 +438,10 @@ export function createMemoryOpenVikingContextEngine(params: {
         logger,
         resolveAgentId,
         isBypassedSession,
+        runtimeCompact: async () => {
+          const delegate = await loadRuntimeCompactionDelegate();
+          return delegate ? delegate(compactParams) : undefined;
+        },
         diag,
       });
     },

package/dist/config.js

@@ -603,7 +603,7 @@ export const memoryOpenVikingConfigSchema = {
         bypassSessionPatterns: {
             label: "Bypass Session Patterns",
             placeholder: "agent:*:cron:**",
-            help: "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
+            help: "Completely bypass OpenViking for matching session keys (no capture, recall, or commit; compaction falls back to OpenClaw's native compactor). Use * within one segment and ** across segments.",
             advanced: true,
         },
         commitTokenThresholdRatio: {

package/dist/context-engine.js

@@ -3,6 +3,7 @@ import { compileSessionPatterns, shouldBypassSession, } from "./text-utils.js";
 import { estimateAgentMessageTokens, estimateAgentMessagesTokens } from "./token-estimator.js";
 import { openClawSessionToOvStorageId } from "./routing/identity-routing.js";
 import { assembleOpenVikingSession, afterTurnOpenVikingSession, compactOpenVikingSession, commitOpenVikingSession, } from "./services/context-lifecycle-service.js";
+import { loadRuntimeCompactionDelegate } from "./plugin/openclaw-runtime-compaction.js";
 function roughEstimate(messages) {
     return estimateAgentMessagesTokens(messages);
 }
@@ -255,6 +256,10 @@ export function createMemoryOpenVikingContextEngine(params) {
                 logger,
                 resolveAgentId,
                 isBypassedSession,
+                runtimeCompact: async () => {
+                    const delegate = await loadRuntimeCompactionDelegate();
+                    return delegate ? delegate(compactParams) : undefined;
+                },
                 diag,
             });
         },

package/dist/plugin/openclaw-runtime-compaction.js

@@ -0,0 +1,20 @@
+// Bridge to OpenClaw's built-in compactor for sessions that bypass OpenViking.
+// The host exports `delegateCompactionToRuntime` from `openclaw/plugin-sdk/core`
+// (present since the earliest supported host); it is resolved lazily because the
+// plugin builds without the host SDK installed.
+const PLUGIN_SDK_CORE_SPECIFIER = "openclaw/plugin-sdk/core";
+let cached;
+export function loadRuntimeCompactionDelegate() {
+    cached ??= (async () => {
+        try {
+            const mod = (await import(PLUGIN_SDK_CORE_SPECIFIER));
+            return typeof mod?.delegateCompactionToRuntime === "function"
+                ? mod.delegateCompactionToRuntime
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    return cached;
+}

package/dist/services/context-lifecycle-service.js

@@ -671,7 +671,7 @@ function compactFailureResult(reason, tokensBefore, details) {
         },
     };
 }
-export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBudget, currentTokenCount, force, compactionTarget, customInstructions, getClient, logger, resolveAgentId, isBypassedSession, diag, }) {
+export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBudget, currentTokenCount, force, compactionTarget, customInstructions, getClient, logger, resolveAgentId, isBypassedSession, runtimeCompact, diag, }) {
     const ovSessionId = openClawSessionToOvStorageId(sessionId, sessionKey);
     diag("compact_entry", ovSessionId, {
         tokenBudget,
@@ -682,6 +682,18 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
             customInstructions.trim().length > 0,
     });
     if (isBypassedSession({ sessionId, sessionKey })) {
+        // Bypassed sessions store nothing in OV, but the host still needs a real
+        // compaction (preflight hard-fails on an unknown skip reason), so hand the
+        // request to OpenClaw's native compactor.
+        const delegated = await runtimeCompact?.();
+        if (delegated) {
+            diag("compact_result", ovSessionId, {
+                ok: delegated.ok,
+                compacted: delegated.compacted,
+                reason: delegated.reason ?? "session_bypassed_runtime_compaction",
+            });
+            return delegated;
+        }
         diag("compact_result", ovSessionId, {
             ok: true,
             compacted: false,

package/openclaw.plugin.json

@@ -195,7 +195,7 @@
     "bypassSessionPatterns": {
       "label": "Bypass Session Patterns",
       "placeholder": "agent:*:cron:**",
-      "help": "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
+      "help": "Completely bypass OpenViking for matching session keys (no capture, recall, or commit; compaction falls back to OpenClaw's native compactor). Use * within one segment and ** across segments.",
       "advanced": true
     },
     "commitTokenThresholdRatio": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/openclaw-plugin",
-  "version": "2026.9.4-2",
+  "version": "2026.9.5",
   "displayName": "OpenViking",
   "description": "OpenClaw context-engine plugin — OpenViking AI memory, long-term memory, knowledge base, semantic search, RAG, context engine. 长期记忆 · 知识库 · 语义检索 · 上下文引擎",
   "type": "module",

package/plugin/openclaw-runtime-compaction.ts

@@ -0,0 +1,41 @@
+// Bridge to OpenClaw's built-in compactor for sessions that bypass OpenViking.
+// The host exports `delegateCompactionToRuntime` from `openclaw/plugin-sdk/core`
+// (present since the earliest supported host); it is resolved lazily because the
+// plugin builds without the host SDK installed.
+
+export type RuntimeCompactionResult = {
+  ok: boolean;
+  compacted: boolean;
+  reason?: string;
+  result?: {
+    summary?: string;
+    firstKeptEntryId?: string;
+    tokensBefore: number;
+    tokensAfter?: number;
+    details?: unknown;
+  };
+};
+
+export type RuntimeCompactionDelegate = (
+  params: Record<string, unknown>,
+) => Promise<RuntimeCompactionResult>;
+
+const PLUGIN_SDK_CORE_SPECIFIER = "openclaw/plugin-sdk/core";
+
+let cached: Promise<RuntimeCompactionDelegate | undefined> | undefined;
+
+export function loadRuntimeCompactionDelegate(): Promise<RuntimeCompactionDelegate | undefined> {
+  cached ??= (async () => {
+    try {
+      const mod = (await import(PLUGIN_SDK_CORE_SPECIFIER)) as {
+        delegateCompactionToRuntime?: unknown;
+      };
+      return typeof mod?.delegateCompactionToRuntime === "function"
+        ? (mod.delegateCompactionToRuntime as RuntimeCompactionDelegate)
+        : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+  return cached;
+}

package/services/context-lifecycle-service.ts

@@ -117,6 +117,8 @@ export type CompactOpenVikingSessionParams = {
   logger: ContextEngineLifecycleLogger;
   resolveAgentId: (sessionId: string, sessionKey?: string, ovSessionId?: string) => string;
   isBypassedSession: (params: { sessionId?: string; sessionKey?: string }) => boolean;
+  /** Host-native compaction for bypassed sessions; resolves undefined when unavailable. */
+  runtimeCompact?: () => Promise<CompactOpenVikingSessionResult | undefined>;
   diag: (stage: string, sessionId: string, data: Record<string, unknown>) => void;
 };
 
@@ -1014,6 +1016,7 @@ export async function compactOpenVikingSession({
   logger,
   resolveAgentId,
   isBypassedSession,
+  runtimeCompact,
   diag,
 }: CompactOpenVikingSessionParams): Promise<CompactOpenVikingSessionResult> {
   const ovSessionId = openClawSessionToOvStorageId(sessionId, sessionKey);
@@ -1027,6 +1030,18 @@ export async function compactOpenVikingSession({
   });
 
   if (isBypassedSession({ sessionId, sessionKey })) {
+    // Bypassed sessions store nothing in OV, but the host still needs a real
+    // compaction (preflight hard-fails on an unknown skip reason), so hand the
+    // request to OpenClaw's native compactor.
+    const delegated = await runtimeCompact?.();
+    if (delegated) {
+      diag("compact_result", ovSessionId, {
+        ok: delegated.ok,
+        compacted: delegated.compacted,
+        reason: delegated.reason ?? "session_bypassed_runtime_compaction",
+      });
+      return delegated;
+    }
     diag("compact_result", ovSessionId, {
       ok: true,
       compacted: false,