@openviking/openclaw-plugin 2026.9.9 → 2026.9.10

package/README.md

@@ -23,7 +23,7 @@ The agent runs install → setup → restart → verify automatically. See [INST
 
 | Stage | What happens |
 |-------|-------------|
-| **Every turn** (`afterTurn`) | New messages are appended to an OpenViking session; commit/extraction is threshold-triggered |
+| **Every turn** (`afterTurn` or `commitTurn`, depending on host/runner) | New messages are appended to an OpenViking session; commit/extraction is threshold-triggered |
 | **Explicit remember** (`memory_store`) | Important long-term facts can be written and committed immediately |
 | **On `/compact`** (`compact`) | Pending session messages are committed and extracted into long-term memories |
 | **Before each reply** (`assemble`) | Relevant memories are auto-retrieved and injected into context |
@@ -202,6 +202,17 @@ That means OpenClaw sees "compressed history summary + archive index + active me
 
 `afterTurn()` has a narrower job: append only the new turn into the OpenViking session.
 
+Capture ownership depends on the **host** version from `api.runtime.version`:
+
+- Before OpenClaw 2026.9.3, `afterTurn` captures messages; `commitTurn` only acknowledges the turn to avoid writing those messages twice.
+- Starting with 2026.9.3, admitted/deferred turns are captured inside `commitTurn` before acknowledgment. Standalone runners still capture via `afterTurn`.
+- The minimum supported OpenClaw version remains 2026.5.27. Missing/unparseable versions and ambiguous 2026.9.3 prereleases reject `commitTurn` rather than silently discarding queued messages; `afterTurn` remains available. Numeric packaging revisions such as `2026.9.3-1` use the 9.3 behavior.
+
+Durable capture propagates client/write/commit failures to the host for retry and shares one in-flight write between concurrent deliveries of the same advancement key. Disabled capture, heartbeats, bypassed sessions, and empty turns are intentional skips. The legacy `afterTurn` callback retains best-effort error handling.
+
+The host's durable delivery does not supply the model token budget or sender runtime context: this path uses the 128,000-token fallback and cannot attach the runtime sender ID to user messages. Message writes remain non-transactional: replay after partial writes or a process crash can duplicate messages. The in-memory advancement-key cache does not provide server-side exactly-once delivery.
+
+
 - it slices only the newly added messages
 - it keeps only `user` / `assistant` capture text
 - it preserves `toolCall` / `toolResult` content in the serialized turn text
@@ -214,7 +225,7 @@ After that, the plugin checks `pending_tokens`. Once it reaches `commitTokenThre
 - the current turn is not blocked waiting for extraction
 - if `logFindRequests` is enabled, the logs include the task id and follow-up extraction detail
 
-This automatic path is best-effort and commit-dependent. Short but important facts can stay only in the live session until a threshold commit, `/compact`, or an explicit store happens.
+Memory extraction on this automatic path is commit-dependent. Short but important facts can stay only in the live session until a threshold commit, `/compact`, or an explicit store happens.
 
 ### Explicit long-term memory writes
 

package/context-engine.ts

@@ -245,10 +245,34 @@ function validTokenBudget(raw: unknown): number | undefined {
   return undefined;
 }
 
+// OpenClaw 9.1/9.2 still capture via afterTurn even when commitTurn exists.
+// 9.3 (#140024) defers admitted turns to commitTurn; standalone runners keep
+// afterTurn. The registration API's runtime.version is the HOST version.
+function usesDeferredTurnCapture(version: string | undefined): boolean | undefined {
+  const match = version?.trim().match(
+    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/,
+  );
+  if (!match) return undefined;
+  const parts = match.slice(1, 4).map(Number);
+  if (!parts.every(Number.isSafeInteger)) return undefined;
+  const [year, month, day] = parts;
+  // OpenClaw uses 0.0.0 when version metadata cannot be resolved. More generally,
+  // versions outside our supported range cannot prove who owns capture.
+  if (year < 2026 || (year === 2026 && (month < 5 || (month === 5 && day < 27)))) {
+    return undefined;
+  }
+  const boundary = year === 2026 && month === 9 && day === 3;
+  // The 9.3 prerelease train can straddle the host change. Numeric packaging
+  // revisions (-1, -2, ...) refer to the stable release; do not guess for betas.
+  if (boundary && match[4] && !/^\d+$/.test(match[4])) return undefined;
+  return year > 2026 || (year === 2026 && (month > 9 || (month === 9 && day >= 3)));
+}
+
 export function createMemoryOpenVikingContextEngine(params: {
   id: string;
   name: string;
   version?: string;
+  hostVersion?: string;
   cfg: ParsedMemoryOpenVikingConfig;
   logger: Logger;
   getClient: () => Promise<OpenVikingClient>;
@@ -333,6 +357,8 @@ export function createMemoryOpenVikingContextEngine(params: {
   }
 
   const committedTurnKeys = new Set<string>();
+  const inFlightTurns = new Map<string, Promise<void>>();
+  const deferredTurnCapture = usesDeferredTurnCapture(params.hostVersion);
 
   return {
     info: {
@@ -388,20 +414,56 @@ export function createMemoryOpenVikingContextEngine(params: {
       });
     },
 
-    // Capture still happens in afterTurn (host calls it per LLM call + on finalize);
-    // commitTurn only acknowledges the accepted turn so OpenClaw drains its outbox.
-    // ponytail: in-memory key set, not durable across restarts — the host outbox is.
-    async commitTurn({ advancementKey, sessionId }): Promise<{ status: "committed" | "duplicate" }> {
+    async commitTurn(commitParams): Promise<{ status: "committed" | "duplicate" }> {
+      const { advancementKey, sessionId } = commitParams;
+      if (deferredTurnCapture === undefined) {
+        // ACKing with an unknown capture owner can discard the only copy in the
+        // host outbox. Reject instead; legacy afterTurn remains available.
+        throw new Error(`openviking: cannot select turn capture for OpenClaw version ${params.hostVersion ?? "(missing)"}`);
+      }
       if (committedTurnKeys.has(advancementKey)) {
         diag("commitTurn_duplicate", sessionId, { advancementKey });
         return { status: "duplicate" };
       }
-      committedTurnKeys.add(advancementKey);
-      if (committedTurnKeys.size > 1024) {
-        committedTurnKeys.delete(committedTurnKeys.values().next().value as string);
+      const pending = inFlightTurns.get(advancementKey);
+      if (pending) {
+        await pending;
+        return { status: "duplicate" };
+      }
+      // Publish the promise before capture begins so concurrent deliveries share
+      // both success and failure. Completion keys are intentionally process-local.
+      const capture = Promise.resolve().then(async () => {
+        if (deferredTurnCapture) {
+          await afterTurnOpenVikingSession({
+            sessionId,
+            sessionKey: resolveSessionKey(commitParams),
+            messages: commitParams.messages,
+            prePromptMessageCount: 0, // Host already supplies the closed-turn range.
+            isHeartbeat: commitParams.isHeartbeat,
+            tokenBudget: 128_000, // Durable delivery does not carry a token budget.
+            throwOnError: true,
+            cfg,
+            getClient,
+            logger,
+            resolveAgentId,
+            rememberSessionAgentId,
+            isBypassedSession,
+            diag,
+          });
+        }
+        committedTurnKeys.add(advancementKey);
+        if (committedTurnKeys.size > 1024) {
+          committedTurnKeys.delete(committedTurnKeys.values().next().value as string);
+        }
+        diag("commitTurn", sessionId, { advancementKey, deferredTurnCapture });
+      });
+      inFlightTurns.set(advancementKey, capture);
+      try {
+        await capture;
+        return { status: "committed" };
+      } finally {
+        inFlightTurns.delete(advancementKey);
       }
-      diag("commitTurn", sessionId, { advancementKey });
-      return { status: "committed" };
     },
 
     async afterTurn(afterTurnParams): Promise<void> {

package/dist/context-engine.js

@@ -121,6 +121,29 @@ function validTokenBudget(raw) {
     }
     return undefined;
 }
+// OpenClaw 9.1/9.2 still capture via afterTurn even when commitTurn exists.
+// 9.3 (#140024) defers admitted turns to commitTurn; standalone runners keep
+// afterTurn. The registration API's runtime.version is the HOST version.
+function usesDeferredTurnCapture(version) {
+    const match = version?.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match)
+        return undefined;
+    const parts = match.slice(1, 4).map(Number);
+    if (!parts.every(Number.isSafeInteger))
+        return undefined;
+    const [year, month, day] = parts;
+    // OpenClaw uses 0.0.0 when version metadata cannot be resolved. More generally,
+    // versions outside our supported range cannot prove who owns capture.
+    if (year < 2026 || (year === 2026 && (month < 5 || (month === 5 && day < 27)))) {
+        return undefined;
+    }
+    const boundary = year === 2026 && month === 9 && day === 3;
+    // The 9.3 prerelease train can straddle the host change. Numeric packaging
+    // revisions (-1, -2, ...) refer to the stable release; do not guess for betas.
+    if (boundary && match[4] && !/^\d+$/.test(match[4]))
+        return undefined;
+    return year > 2026 || (year === 2026 && (month > 9 || (month === 9 && day >= 3)));
+}
 export function createMemoryOpenVikingContextEngine(params) {
     const { id, name, version, cfg, logger, getClient, resolveAgentId, rememberSessionAgentId, queryConfigStore, traceRecorder, } = params;
     const diagEnabled = cfg.emitStandardDiagnostics;
@@ -161,6 +184,8 @@ export function createMemoryOpenVikingContextEngine(params) {
         };
     }
     const committedTurnKeys = new Set();
+    const inFlightTurns = new Map();
+    const deferredTurnCapture = usesDeferredTurnCapture(params.hostVersion);
     return {
         info: {
             id,
@@ -208,20 +233,57 @@ export function createMemoryOpenVikingContextEngine(params) {
                 prependRecallToLatestUserMessage,
             });
         },
-        // Capture still happens in afterTurn (host calls it per LLM call + on finalize);
-        // commitTurn only acknowledges the accepted turn so OpenClaw drains its outbox.
-        // ponytail: in-memory key set, not durable across restarts — the host outbox is.
-        async commitTurn({ advancementKey, sessionId }) {
+        async commitTurn(commitParams) {
+            const { advancementKey, sessionId } = commitParams;
+            if (deferredTurnCapture === undefined) {
+                // ACKing with an unknown capture owner can discard the only copy in the
+                // host outbox. Reject instead; legacy afterTurn remains available.
+                throw new Error(`openviking: cannot select turn capture for OpenClaw version ${params.hostVersion ?? "(missing)"}`);
+            }
             if (committedTurnKeys.has(advancementKey)) {
                 diag("commitTurn_duplicate", sessionId, { advancementKey });
                 return { status: "duplicate" };
             }
-            committedTurnKeys.add(advancementKey);
-            if (committedTurnKeys.size > 1024) {
-                committedTurnKeys.delete(committedTurnKeys.values().next().value);
+            const pending = inFlightTurns.get(advancementKey);
+            if (pending) {
+                await pending;
+                return { status: "duplicate" };
+            }
+            // Publish the promise before capture begins so concurrent deliveries share
+            // both success and failure. Completion keys are intentionally process-local.
+            const capture = Promise.resolve().then(async () => {
+                if (deferredTurnCapture) {
+                    await afterTurnOpenVikingSession({
+                        sessionId,
+                        sessionKey: resolveSessionKey(commitParams),
+                        messages: commitParams.messages,
+                        prePromptMessageCount: 0, // Host already supplies the closed-turn range.
+                        isHeartbeat: commitParams.isHeartbeat,
+                        tokenBudget: 128_000, // Durable delivery does not carry a token budget.
+                        throwOnError: true,
+                        cfg,
+                        getClient,
+                        logger,
+                        resolveAgentId,
+                        rememberSessionAgentId,
+                        isBypassedSession,
+                        diag,
+                    });
+                }
+                committedTurnKeys.add(advancementKey);
+                if (committedTurnKeys.size > 1024) {
+                    committedTurnKeys.delete(committedTurnKeys.values().next().value);
+                }
+                diag("commitTurn", sessionId, { advancementKey, deferredTurnCapture });
+            });
+            inFlightTurns.set(advancementKey, capture);
+            try {
+                await capture;
+                return { status: "committed" };
+            }
+            finally {
+                inFlightTurns.delete(advancementKey);
             }
-            diag("commitTurn", sessionId, { advancementKey });
-            return { status: "committed" };
         },
         async afterTurn(afterTurnParams) {
             const tokenBudget = validTokenBudget(afterTurnParams.tokenBudget) ?? 128_000;

package/dist/plugin/openviking-context-engine-registration.js

@@ -8,6 +8,7 @@ export function registerOpenVikingContextEngine(deps) {
             id: deps.plugin.id,
             name: deps.plugin.name,
             version: deps.version,
+            hostVersion: deps.api.runtime?.version,
             cfg: deps.cfg,
             logger: deps.logger,
             getClient: deps.getClient,

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

@@ -501,7 +501,7 @@ function messageDigest(messages, maxCharsPerMsg = 2000) {
         };
     });
 }
-export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messages: rawMessages, prePromptMessageCount, isHeartbeat, tokenBudget, runtimeContext, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, }) {
+export async function afterTurnOpenVikingSession({ throwOnError = false, sessionId, sessionKey, messages: rawMessages, prePromptMessageCount, isHeartbeat, tokenBudget, runtimeContext, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, }) {
     if (!cfg.autoCapture) {
         return;
     }
@@ -650,6 +650,9 @@ export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messag
             senderIdFound: sender.found,
             senderId: sender.senderId ?? null,
         });
+        if (throwOnError) {
+            throw err;
+        }
     }
 }
 function validTokenCount(value) {

package/index.ts

@@ -95,6 +95,7 @@ type ToolContext = {
 };
 
 type OpenClawPluginApi = {
+  runtime?: { version?: string };
   pluginConfig?: unknown;
   openVikingTransport?: HttpTransport;
   logger: PluginLogger;

package/package.json

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

package/plugin/openviking-context-engine-registration.ts

@@ -1,4 +1,5 @@
 export type OpenVikingContextEngineRegistrationApi = {
+  runtime?: { version?: string };
   registerContextEngine?: (id: string, factory: () => unknown) => void;
 };
 
@@ -22,6 +23,7 @@ export type OpenVikingContextEngineCreateParams<
   id: string;
   name: string;
   version: string;
+  hostVersion?: string;
   cfg: TCfg;
   logger: TLogger;
   getClient: () => Promise<TClient>;
@@ -80,6 +82,7 @@ export function registerOpenVikingContextEngine<
       id: deps.plugin.id,
       name: deps.plugin.name,
       version: deps.version,
+      hostVersion: deps.api.runtime?.version,
       cfg: deps.cfg,
       logger: deps.logger,
       getClient: deps.getClient,

package/services/context-lifecycle-service.ts

@@ -125,6 +125,8 @@ export type CompactOpenVikingSessionParams = {
 type AfterTurnClient = Pick<OpenVikingClient, "addSessionMessage" | "getSession" | "commitSession" | "getTask">;
 
 export type AfterTurnOpenVikingSessionParams = {
+  /** Durable delivery must reject failed writes so the host retains its outbox row. */
+  throwOnError?: boolean;
   sessionId: string;
   sessionKey?: string;
   messages?: AgentMessage[];
@@ -786,6 +788,7 @@ function messageDigest(messages: AgentMessage[], maxCharsPerMsg = 2000): Array<{
 }
 
 export async function afterTurnOpenVikingSession({
+  throwOnError = false,
   sessionId,
   sessionKey,
   messages: rawMessages,
@@ -976,6 +979,9 @@ export async function afterTurnOpenVikingSession({
       senderIdFound: sender.found,
       senderId: sender.senderId ?? null,
     });
+    if (throwOnError) {
+      throw err;
+    }
   }
 }