@openviking/openclaw-plugin 2026.9.9 → 2026.9.10-1

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/auto-recall.ts

@@ -331,6 +331,7 @@ export async function buildAutoRecallContext(params: {
   rawUserTextPreview?: string;
   queryTruncated?: boolean;
   resourceTypes?: RecallResourceType[];
+  dedupTurns?: number;
 }): Promise<{ block?: string; memoryCount: number; estimatedTokens: number }> {
   const { cfg, client, agentId, actorPeerId, queryText, logger, verbose } = params;
   const queryConfig = params.queryConfig;
@@ -373,7 +374,7 @@ export async function buildAutoRecallContext(params: {
           queryExpansion: "auto",
           maxTokens,
           detail: recallPreferAbstract ? "abstract" : undefined,
-          dedupTurns: params.ovSessionId ? AUTO_RECALL_DEDUP_TURNS : undefined,
+          dedupTurns: params.dedupTurns ?? (params.ovSessionId ? AUTO_RECALL_DEDUP_TURNS : undefined),
           peerScope: "actor",
           actorPeerId,
           requestTimeoutMs: cfg.autoRecallTimeoutMs,

package/client.ts

@@ -508,6 +508,7 @@ export class OpenVikingClient {
     };
     const body = {
       ...buildContextSearchBody(contractConfig, { sessionId: options.sessionId }),
+      ...(options.dedupTurns === 0 ? { dedup_turns: 0 } : {}),
       query,
       ...(options.contextType !== undefined ? { context_type: options.contextType } : {}),
       ...(options.detail !== undefined ? { detail: options.detail } : {}),

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: {
@@ -368,6 +394,7 @@ export function createMemoryOpenVikingContextEngine(params: {
         sessionId: assembleParams.sessionId,
         sessionKey: resolveSessionKey(assembleParams),
         messages: assembleParams.messages,
+        prompt: assembleParams.prompt,
         tokenBudget,
         runtimeContext: assembleParams.runtimeContext,
         isMainAssemble,
@@ -388,20 +415,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/auto-recall.js

@@ -244,7 +244,7 @@ export async function buildAutoRecallContext(params) {
                 queryExpansion: "auto",
                 maxTokens,
                 detail: recallPreferAbstract ? "abstract" : undefined,
-                dedupTurns: params.ovSessionId ? AUTO_RECALL_DEDUP_TURNS : undefined,
+                dedupTurns: params.dedupTurns ?? (params.ovSessionId ? AUTO_RECALL_DEDUP_TURNS : undefined),
                 peerScope: "actor",
                 actorPeerId,
                 requestTimeoutMs: cfg.autoRecallTimeoutMs,

package/dist/client.js

@@ -205,6 +205,7 @@ export class OpenVikingClient {
         };
         const body = {
             ...buildContextSearchBody(contractConfig, { sessionId: options.sessionId }),
+            ...(options.dedupTurns === 0 ? { dedup_turns: 0 } : {}),
             query,
             ...(options.contextType !== undefined ? { context_type: options.contextType } : {}),
             ...(options.detail !== undefined ? { detail: options.detail } : {}),

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,
@@ -189,6 +214,7 @@ export function createMemoryOpenVikingContextEngine(params) {
                 sessionId: assembleParams.sessionId,
                 sessionKey: resolveSessionKey(assembleParams),
                 messages: assembleParams.messages,
+                prompt: assembleParams.prompt,
                 tokenBudget,
                 runtimeContext: assembleParams.runtimeContext,
                 isMainAssemble,
@@ -208,20 +234,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

@@ -195,7 +195,73 @@ function isSessionNotFoundError(err) {
     const errorMessage = String(err);
     return errorMessage.includes("[NOT_FOUND]") && errorMessage.includes("Session not found");
 }
-export async function assembleOpenVikingSession({ sessionId, sessionKey, messages, tokenBudget, runtimeContext, isMainAssemble, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, queryConfigStore, traceRecorder, diag, roughEstimate, messageDigest, extractAgentMessageText, hasAutoRecallBlock, prependRecallToLatestUserMessage, }) {
+async function recallForAssemble(params, recallQuery) {
+    const { sessionId, sessionKey, cfg, getClient, resolveAgentId, queryConfigStore, logger, traceRecorder } = params;
+    const ovSessionId = openClawSessionToOvStorageId(sessionId, sessionKey);
+    const sender = extractRuntimeSenderId(params.runtimeContext);
+    const client = await getClient();
+    const routingRef = sessionId ?? sessionKey ?? ovSessionId;
+    const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
+    const actorPeerId = resolveOpenVikingActorPeerId({
+        peerRole: cfg.peer_role ?? "none",
+        senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
+        assistantPeerId: agentId,
+    });
+    const queryConfig = await queryConfigStore?.getEffective({
+        agentId,
+        sessionId,
+        sessionKey,
+        ovSessionId,
+    });
+    return buildAutoRecallContext({
+        cfg,
+        queryConfig,
+        client,
+        agentId,
+        actorPeerId,
+        queryText: recallQuery.query,
+        logger,
+        verbose: (message) => logger.info(message),
+        traceRecorder: traceRecorder,
+        sessionId,
+        sessionKey,
+        ovSessionId,
+        queryTruncated: recallQuery.truncated,
+        rawUserTextPreview: recallQuery.query,
+        // System additions are transient; the next turn must be able to recall the same URI.
+        dedupTurns: params.isMainAssemble ? 0 : undefined,
+    });
+}
+export async function assembleOpenVikingSession(params) {
+    const assembled = await assembleSessionContext(params);
+    // Current OpenClaw supplies the pending turn separately from history. Keep
+    // recalled context out of persisted messages and let the host own that turn.
+    if (!params.isMainAssemble || !params.cfg.autoRecall || !params.prompt ||
+        params.isBypassedSession(params)) {
+        return assembled;
+    }
+    const query = prepareRecallQuery(params.prompt);
+    if (query.query.length < 5)
+        return assembled;
+    try {
+        const recall = await recallForAssemble(params, query);
+        if (!recall.block)
+            return assembled;
+        const systemPromptAddition = [assembled.systemPromptAddition, recall.block].filter(Boolean).join("\n\n");
+        const estimatedTokens = assembled.estimatedTokens
+            + estimateTextTokens(systemPromptAddition)
+            - estimateTextTokens(assembled.systemPromptAddition ?? "");
+        if (estimatedTokens > params.tokenBudget)
+            return assembled;
+        return { ...assembled, systemPromptAddition, estimatedTokens };
+    }
+    catch (err) {
+        params.logger.warn?.(`openviking: auto-recall failed: ${String(err)}`);
+        return assembled;
+    }
+}
+async function assembleSessionContext(params) {
+    const { sessionId, sessionKey, messages, tokenBudget, runtimeContext, isMainAssemble, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, roughEstimate, messageDigest, extractAgentMessageText, hasAutoRecallBlock, prependRecallToLatestUserMessage, } = params;
     const latestMessage = messages.at(-1);
     const isTransformContextAssemble = !isMainAssemble;
     // Tool-loop calls do no recall work on non-user tails; avoid scanning the full history.
@@ -239,36 +305,7 @@ export async function assembleOpenVikingSession({ sessionId, sessionKey, message
                 `chars=${recallQuery.originalChars}->${recallQuery.finalChars})`);
         }
         try {
-            const client = await getClient();
-            const routingRef = sessionId ?? sessionKey ?? ovSessionId;
-            const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
-            const actorPeerId = resolveOpenVikingActorPeerId({
-                peerRole: cfg.peer_role ?? "none",
-                senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
-                assistantPeerId: agentId,
-            });
-            const queryConfig = await queryConfigStore?.getEffective({
-                agentId,
-                sessionId,
-                sessionKey,
-                ovSessionId,
-            });
-            const recall = await buildAutoRecallContext({
-                cfg,
-                queryConfig,
-                client,
-                agentId,
-                actorPeerId,
-                queryText: recallQuery.query,
-                logger,
-                verbose: (message) => logger.info(message),
-                traceRecorder: traceRecorder,
-                sessionId,
-                sessionKey,
-                ovSessionId,
-                queryTruncated: recallQuery.truncated,
-                rawUserTextPreview: recallQuery.query,
-            });
+            const recall = await recallForAssemble(params, recallQuery);
             if (!recall.block) {
                 return assemblePassthrough({
                     diag,
@@ -501,7 +538,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 +687,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-1",
   "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

@@ -72,6 +72,7 @@ export type AssembleOpenVikingSessionParams = {
   sessionId: string;
   sessionKey?: string;
   messages: AgentMessage[];
+  prompt?: string;
   tokenBudget: number;
   runtimeContext?: Record<string, unknown>;
   isMainAssemble: boolean;
@@ -125,6 +126,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[];
@@ -421,28 +424,98 @@ function isSessionNotFoundError(err: unknown): boolean {
   return errorMessage.includes("[NOT_FOUND]") && errorMessage.includes("Session not found");
 }
 
-export async function assembleOpenVikingSession({
-  sessionId,
-  sessionKey,
-  messages,
-  tokenBudget,
-  runtimeContext,
-  isMainAssemble,
-  cfg,
-  getClient,
-  logger,
-  resolveAgentId,
-  rememberSessionAgentId,
-  isBypassedSession,
-  queryConfigStore,
-  traceRecorder,
-  diag,
-  roughEstimate,
-  messageDigest,
-  extractAgentMessageText,
-  hasAutoRecallBlock,
-  prependRecallToLatestUserMessage,
-}: AssembleOpenVikingSessionParams): Promise<AssembleOpenVikingSessionResult> {
+async function recallForAssemble(
+  params: AssembleOpenVikingSessionParams,
+  recallQuery: ReturnType<typeof prepareRecallQuery>,
+) {
+  const { sessionId, sessionKey, cfg, getClient, resolveAgentId, queryConfigStore, logger, traceRecorder } = params;
+  const ovSessionId = openClawSessionToOvStorageId(sessionId, sessionKey);
+  const sender = extractRuntimeSenderId(params.runtimeContext);
+  const client = await getClient();
+  const routingRef = sessionId ?? sessionKey ?? ovSessionId;
+  const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
+  const actorPeerId = resolveOpenVikingActorPeerId({
+    peerRole: cfg.peer_role ?? "none",
+    senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
+    assistantPeerId: agentId,
+  });
+  const queryConfig = await queryConfigStore?.getEffective({
+    agentId,
+    sessionId,
+    sessionKey,
+    ovSessionId,
+  });
+  return buildAutoRecallContext({
+    cfg,
+    queryConfig,
+    client,
+    agentId,
+    actorPeerId,
+    queryText: recallQuery.query,
+    logger,
+    verbose: (message) => logger.info(message),
+    traceRecorder: traceRecorder as never,
+    sessionId,
+    sessionKey,
+    ovSessionId,
+    queryTruncated: recallQuery.truncated,
+    rawUserTextPreview: recallQuery.query,
+    // System additions are transient; the next turn must be able to recall the same URI.
+    dedupTurns: params.isMainAssemble ? 0 : undefined,
+  });
+}
+
+export async function assembleOpenVikingSession(
+  params: AssembleOpenVikingSessionParams,
+): Promise<AssembleOpenVikingSessionResult> {
+  const assembled = await assembleSessionContext(params);
+  // Current OpenClaw supplies the pending turn separately from history. Keep
+  // recalled context out of persisted messages and let the host own that turn.
+  if (
+    !params.isMainAssemble || !params.cfg.autoRecall || !params.prompt ||
+    params.isBypassedSession(params)
+  ) {
+    return assembled;
+  }
+  const query = prepareRecallQuery(params.prompt);
+  if (query.query.length < 5) return assembled;
+
+  try {
+    const recall = await recallForAssemble(params, query);
+    if (!recall.block) return assembled;
+    const systemPromptAddition = [assembled.systemPromptAddition, recall.block].filter(Boolean).join("\n\n");
+    const estimatedTokens = assembled.estimatedTokens
+      + estimateTextTokens(systemPromptAddition)
+      - estimateTextTokens(assembled.systemPromptAddition ?? "");
+    if (estimatedTokens > params.tokenBudget) return assembled;
+    return { ...assembled, systemPromptAddition, estimatedTokens };
+  } catch (err) {
+    params.logger.warn?.(`openviking: auto-recall failed: ${String(err)}`);
+    return assembled;
+  }
+}
+
+async function assembleSessionContext(params: AssembleOpenVikingSessionParams): Promise<AssembleOpenVikingSessionResult> {
+  const {
+    sessionId,
+    sessionKey,
+    messages,
+    tokenBudget,
+    runtimeContext,
+    isMainAssemble,
+    cfg,
+    getClient,
+    logger,
+    resolveAgentId,
+    rememberSessionAgentId,
+    isBypassedSession,
+    diag,
+    roughEstimate,
+    messageDigest,
+    extractAgentMessageText,
+    hasAutoRecallBlock,
+    prependRecallToLatestUserMessage,
+  } = params;
   const latestMessage = messages.at(-1);
   const isTransformContextAssemble = !isMainAssemble;
 
@@ -495,36 +568,7 @@ export async function assembleOpenVikingSession({
     }
 
     try {
-      const client = await getClient();
-      const routingRef = sessionId ?? sessionKey ?? ovSessionId;
-      const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
-      const actorPeerId = resolveOpenVikingActorPeerId({
-        peerRole: cfg.peer_role ?? "none",
-        senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
-        assistantPeerId: agentId,
-      });
-      const queryConfig = await queryConfigStore?.getEffective({
-        agentId,
-        sessionId,
-        sessionKey,
-        ovSessionId,
-      });
-      const recall = await buildAutoRecallContext({
-        cfg,
-        queryConfig,
-        client,
-        agentId,
-        actorPeerId,
-        queryText: recallQuery.query,
-        logger,
-        verbose: (message) => logger.info(message),
-        traceRecorder: traceRecorder as never,
-        sessionId,
-        sessionKey,
-        ovSessionId,
-        queryTruncated: recallQuery.truncated,
-        rawUserTextPreview: recallQuery.query,
-      });
+      const recall = await recallForAssemble(params, recallQuery);
 
       if (!recall.block) {
         return assemblePassthrough({
@@ -786,6 +830,7 @@ function messageDigest(messages: AgentMessage[], maxCharsPerMsg = 2000): Array<{
 }
 
 export async function afterTurnOpenVikingSession({
+  throwOnError = false,
   sessionId,
   sessionKey,
   messages: rawMessages,
@@ -976,6 +1021,9 @@ export async function afterTurnOpenVikingSession({
       senderIdFound: sender.found,
       senderId: sender.senderId ?? null,
     });
+    if (throwOnError) {
+      throw err;
+    }
   }
 }