@openviking/openclaw-plugin 2026.8.11 → 2026.8.13-1

package/client.ts

@@ -378,13 +378,17 @@ export class OpenVikingClient {
       const payload = (await response.json().catch(() => ({}))) as {
         status?: string;
         result?: T;
-        error?: { code?: string; message?: string };
+        error?: { code?: string; message?: string; trace_id?: string };
       };
 
       if (!response.ok || payload.status === "error") {
         const code = payload.error?.code ? ` [${payload.error.code}]` : "";
         const message = payload.error?.message ?? `HTTP ${response.status}`;
-        throw new Error(`OpenViking request failed${code}: ${message}`);
+        const traceId = payload.error?.trace_id;
+        throw new Error(
+          `OpenViking request failed${code}: ${message}` +
+            (traceId ? ` (trace_id=${traceId})` : ""),
+        );
       }
 
       return (payload.result ?? payload) as T;

package/config.ts

@@ -190,9 +190,6 @@ export const OPENVIKING_TOOL_GROUPS: Record<string, readonly OpenVikingToolName[
   default: OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES,
   memory: ["memory_recall", "memory_store", "memory_forget"],
   resource_query: ["ov_search", "ov_read", "ov_multi_read", "ov_list"],
-  // Migration alias for configurations that previously selected the removed
-  // search_experience/read_experience tools.
-  experience: ["ov_search", "ov_read"],
   import: ["add_resource", "add_skill"],
   recall_trace: ["ov_recall_trace"],
   archive: ["ov_archive_search", "ov_archive_expand"],
@@ -951,7 +948,7 @@ export const memoryOpenVikingConfigSchema = {
     enabledTools: {
       label: "Enabled Tools",
       placeholder: "default",
-      help: "Agent-visible tool allowlist. Accepts tool names or groups: default, all, memory, resource_query, experience (legacy alias), import, recall_trace, archive, tool_result. add_resource also requires enableAddResourceTool=true.",
+      help: "Agent-visible tool allowlist. Accepts tool names or groups: default, all, memory, resource_query, import, recall_trace, archive, tool_result. add_resource also requires enableAddResourceTool=true.",
       advanced: true,
     },
     disabledTools: {

package/dist/client.js

@@ -150,7 +150,9 @@ export class OpenVikingClient {
             if (!response.ok || payload.status === "error") {
                 const code = payload.error?.code ? ` [${payload.error.code}]` : "";
                 const message = payload.error?.message ?? `HTTP ${response.status}`;
-                throw new Error(`OpenViking request failed${code}: ${message}`);
+                const traceId = payload.error?.trace_id;
+                throw new Error(`OpenViking request failed${code}: ${message}` +
+                    (traceId ? ` (trace_id=${traceId})` : ""));
             }
             return (payload.result ?? payload);
         }

package/dist/config.js

@@ -54,9 +54,6 @@ export const OPENVIKING_TOOL_GROUPS = {
     default: OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES,
     memory: ["memory_recall", "memory_store", "memory_forget"],
     resource_query: ["ov_search", "ov_read", "ov_multi_read", "ov_list"],
-    // Migration alias for configurations that previously selected the removed
-    // search_experience/read_experience tools.
-    experience: ["ov_search", "ov_read"],
     import: ["add_resource", "add_skill"],
     recall_trace: ["ov_recall_trace"],
     archive: ["ov_archive_search", "ov_archive_expand"],
@@ -653,7 +650,7 @@ export const memoryOpenVikingConfigSchema = {
         enabledTools: {
             label: "Enabled Tools",
             placeholder: "default",
-            help: "Agent-visible tool allowlist. Accepts tool names or groups: default, all, memory, resource_query, experience (legacy alias), import, recall_trace, archive, tool_result. add_resource also requires enableAddResourceTool=true.",
+            help: "Agent-visible tool allowlist. Accepts tool names or groups: default, all, memory, resource_query, import, recall_trace, archive, tool_result. add_resource also requires enableAddResourceTool=true.",
             advanced: true,
         },
         disabledTools: {

package/dist/plugin/openviking-memory-tools.js

@@ -55,27 +55,41 @@ export function registerOpenVikingMemoryTools(deps) {
                 });
                 const memoriesCount = totalCommitMemories(commitResult);
                 if (commitResult.status === "failed") {
-                    deps.logger.warn(`openviking: memory_store commit failed (sessionId=${sessionId}): ${commitResult.error ?? "unknown"}`);
+                    deps.logger.warn(`openviking: memory_store commit failed (sessionId=${sessionId}): ` +
+                        `${commitResult.error ?? "unknown"}, trace_id=${commitResult.trace_id ?? "none"}`);
                     return {
-                        content: [{ type: "text", text: `Memory extraction failed for session ${sessionId}: ${commitResult.error ?? "unknown"}` }],
+                        content: [{
+                                type: "text",
+                                text: `Memory extraction failed for session ${sessionId}: ${commitResult.error ?? "unknown"}` +
+                                    (commitResult.trace_id ? ` (trace_id=${commitResult.trace_id})` : ""),
+                            }],
                         details: {
                             action: "failed",
                             sessionId,
                             status: "failed",
                             error: commitResult.error,
+                            traceId: commitResult.trace_id,
                             usedTempSession,
                         },
                     };
                 }
                 if (commitResult.status === "timeout") {
-                    deps.logger.warn(`openviking: memory_store commit timed out (sessionId=${sessionId}), task_id=${commitResult.task_id ?? "none"}. Memories may still be extracting in background.`);
+                    deps.logger.warn(`openviking: memory_store commit timed out (sessionId=${sessionId}), ` +
+                        `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}. ` +
+                        "Memories may still be extracting in background.");
                     return {
-                        content: [{ type: "text", text: `Memory extraction timed out for session ${sessionId}. It may still complete in the background (task_id=${commitResult.task_id ?? "none"}).` }],
+                        content: [{
+                                type: "text",
+                                text: `Memory extraction timed out for session ${sessionId}. ` +
+                                    `It may still complete in the background (task_id=${commitResult.task_id ?? "none"}` +
+                                    `${commitResult.trace_id ? `, trace_id=${commitResult.trace_id}` : ""}).`,
+                            }],
                         details: {
                             action: "timeout",
                             sessionId,
                             status: "timeout",
                             taskId: commitResult.task_id,
+                            traceId: commitResult.trace_id,
                             usedTempSession,
                         },
                     };
@@ -85,13 +99,15 @@ export function registerOpenVikingMemoryTools(deps) {
                         "Check OpenViking server logs for embedding/extract errors (e.g. 401 API key, or extraction pipeline).");
                 }
                 else {
-                    deps.logger.info?.(`openviking: memory_store committed, memories=${memoriesCount}`);
+                    deps.logger.info?.(`openviking: memory_store committed, memories=${memoriesCount}, ` +
+                        `trace_id=${commitResult.trace_id ?? "none"}`);
                 }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Stored in OpenViking session ${sessionId} and committed ${memoriesCount} memories.`,
+                            text: `Stored in OpenViking session ${sessionId} and committed ${memoriesCount} memories.` +
+                                (commitResult.trace_id ? ` (trace_id=${commitResult.trace_id})` : ""),
                         },
                     ],
                     details: {
@@ -100,6 +116,7 @@ export function registerOpenVikingMemoryTools(deps) {
                         memoriesCount,
                         status: commitResult.status,
                         archived: commitResult.archived ?? false,
+                        traceId: commitResult.trace_id,
                         usedTempSession,
                     },
                 };

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

@@ -160,11 +160,13 @@ export async function commitOpenVikingSession({ sessionId, sessionKey, getClient
         });
         const memCount = totalExtractedMemories(commitResult.memories_extracted);
         if (commitResult.status === "failed") {
-            logger.warn?.(`openviking: commit Phase 2 failed for session=${sessionId}: ${commitResult.error ?? "unknown"}`);
+            logger.warn?.(`openviking: commit Phase 2 failed for session=${sessionId}: ${commitResult.error ?? "unknown"}, ` +
+                `trace_id=${commitResult.trace_id ?? "none"}`);
             return false;
         }
         if (commitResult.status === "timeout") {
-            logger.warn?.(`openviking: commit Phase 2 timed out for session=${sessionId}, task_id=${commitResult.task_id ?? "none"}`);
+            logger.warn?.(`openviking: commit Phase 2 timed out for session=${sessionId}, ` +
+                `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}`);
             return false;
         }
         logger.info(`openviking: committed OV session=${sessionId} ovId=${ovId}, archived=${commitResult.archived ?? false}, memories=${memCount}, task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}`);
@@ -722,7 +724,8 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
         });
         const memCount = totalExtractedMemories(commitResult.memories_extracted);
         if (commitResult.status === "failed") {
-            logger.warn?.(`openviking: compact commit Phase 2 failed for session=${ovSessionId}: ${commitResult.error ?? "unknown"}`);
+            logger.warn?.(`openviking: compact commit Phase 2 failed for session=${ovSessionId}: ` +
+                `${commitResult.error ?? "unknown"}, trace_id=${commitResult.trace_id ?? "none"}`);
             diag("compact_result", ovSessionId, {
                 ok: false,
                 compacted: false,
@@ -735,7 +738,8 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
             return compactFailureResult("commit_failed", tokensBefore, { commit: commitResult });
         }
         if (commitResult.status === "timeout") {
-            logger.warn?.(`openviking: compact commit Phase 2 timed out for session=${ovSessionId}, task_id=${commitResult.task_id ?? "none"}`);
+            logger.warn?.(`openviking: compact commit Phase 2 timed out for session=${ovSessionId}, ` +
+                `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}`);
             diag("compact_result", ovSessionId, {
                 ok: false,
                 compacted: false,

package/install-manifest.json

@@ -41,6 +41,7 @@
       ".gitignore",
       "skills/install-openviking-memory/SKILL.md",
       "skills/openviking-context-database/SKILL.md",
+      "skills/ov-experience-memory/SKILL.md",
       "INSTALL-AGENT.md"
     ]
   },

package/openclaw.plugin.json

@@ -50,7 +50,8 @@
   },
   "skills": [
     "./skills/install-openviking-memory",
-    "./skills/openviking-context-database"
+    "./skills/openviking-context-database",
+    "./skills/ov-experience-memory"
   ],
   "setup": {
     "providers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/openclaw-plugin",
-  "version": "2026.8.11",
+  "version": "2026.8.13-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-memory-tools.ts

@@ -132,30 +132,44 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
           const memoriesCount = totalCommitMemories(commitResult);
           if (commitResult.status === "failed") {
             deps.logger.warn(
-              `openviking: memory_store commit failed (sessionId=${sessionId}): ${commitResult.error ?? "unknown"}`,
+              `openviking: memory_store commit failed (sessionId=${sessionId}): ` +
+                `${commitResult.error ?? "unknown"}, trace_id=${commitResult.trace_id ?? "none"}`,
             );
             return {
-              content: [{ type: "text", text: `Memory extraction failed for session ${sessionId}: ${commitResult.error ?? "unknown"}` }],
+              content: [{
+                type: "text",
+                text: `Memory extraction failed for session ${sessionId}: ${commitResult.error ?? "unknown"}` +
+                  (commitResult.trace_id ? ` (trace_id=${commitResult.trace_id})` : ""),
+              }],
               details: {
                 action: "failed",
                 sessionId,
                 status: "failed",
                 error: commitResult.error,
+                traceId: commitResult.trace_id,
                 usedTempSession,
               },
             };
           }
           if (commitResult.status === "timeout") {
             deps.logger.warn(
-              `openviking: memory_store commit timed out (sessionId=${sessionId}), task_id=${commitResult.task_id ?? "none"}. Memories may still be extracting in background.`,
+              `openviking: memory_store commit timed out (sessionId=${sessionId}), ` +
+                `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}. ` +
+                "Memories may still be extracting in background.",
             );
             return {
-              content: [{ type: "text", text: `Memory extraction timed out for session ${sessionId}. It may still complete in the background (task_id=${commitResult.task_id ?? "none"}).` }],
+              content: [{
+                type: "text",
+                text: `Memory extraction timed out for session ${sessionId}. ` +
+                  `It may still complete in the background (task_id=${commitResult.task_id ?? "none"}` +
+                  `${commitResult.trace_id ? `, trace_id=${commitResult.trace_id}` : ""}).`,
+              }],
               details: {
                 action: "timeout",
                 sessionId,
                 status: "timeout",
                 taskId: commitResult.task_id,
+                traceId: commitResult.trace_id,
                 usedTempSession,
               },
             };
@@ -166,13 +180,17 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
                 "Check OpenViking server logs for embedding/extract errors (e.g. 401 API key, or extraction pipeline).",
             );
           } else {
-            deps.logger.info?.(`openviking: memory_store committed, memories=${memoriesCount}`);
+            deps.logger.info?.(
+              `openviking: memory_store committed, memories=${memoriesCount}, ` +
+                `trace_id=${commitResult.trace_id ?? "none"}`,
+            );
           }
           return {
             content: [
               {
                 type: "text",
-                text: `Stored in OpenViking session ${sessionId} and committed ${memoriesCount} memories.`,
+                text: `Stored in OpenViking session ${sessionId} and committed ${memoriesCount} memories.` +
+                  (commitResult.trace_id ? ` (trace_id=${commitResult.trace_id})` : ""),
               },
             ],
             details: {
@@ -181,6 +199,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
               memoriesCount,
               status: commitResult.status,
               archived: commitResult.archived ?? false,
+              traceId: commitResult.trace_id,
               usedTempSession,
             },
           };

package/services/context-lifecycle-service.ts

@@ -368,11 +368,17 @@ export async function commitOpenVikingSession({
     });
     const memCount = totalExtractedMemories(commitResult.memories_extracted);
     if (commitResult.status === "failed") {
-      logger.warn?.(`openviking: commit Phase 2 failed for session=${sessionId}: ${commitResult.error ?? "unknown"}`);
+      logger.warn?.(
+        `openviking: commit Phase 2 failed for session=${sessionId}: ${commitResult.error ?? "unknown"}, ` +
+          `trace_id=${commitResult.trace_id ?? "none"}`,
+      );
       return false;
     }
     if (commitResult.status === "timeout") {
-      logger.warn?.(`openviking: commit Phase 2 timed out for session=${sessionId}, task_id=${commitResult.task_id ?? "none"}`);
+      logger.warn?.(
+        `openviking: commit Phase 2 timed out for session=${sessionId}, ` +
+          `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}`,
+      );
       return false;
     }
     logger.info(
@@ -1069,7 +1075,8 @@ export async function compactOpenVikingSession({
 
     if (commitResult.status === "failed") {
       logger.warn?.(
-        `openviking: compact commit Phase 2 failed for session=${ovSessionId}: ${commitResult.error ?? "unknown"}`,
+        `openviking: compact commit Phase 2 failed for session=${ovSessionId}: ` +
+          `${commitResult.error ?? "unknown"}, trace_id=${commitResult.trace_id ?? "none"}`,
       );
       diag("compact_result", ovSessionId, {
         ok: false,
@@ -1085,7 +1092,8 @@ export async function compactOpenVikingSession({
 
     if (commitResult.status === "timeout") {
       logger.warn?.(
-        `openviking: compact commit Phase 2 timed out for session=${ovSessionId}, task_id=${commitResult.task_id ?? "none"}`,
+        `openviking: compact commit Phase 2 timed out for session=${ovSessionId}, ` +
+          `task_id=${commitResult.task_id ?? "none"}, trace_id=${commitResult.trace_id ?? "none"}`,
       );
       diag("compact_result", ovSessionId, {
         ok: false,

package/skills/ov-experience-memory/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: ov-experience-memory
+description: Retrieve and apply OpenViking Experience memories through the Agent runtime's generic OpenViking search and read tools. Use before or during executable, multi-step, or tool-based work such as coding, file or data changes, configuration, deployment, workflow execution, and failure recovery when prior operational guidance could improve reliability. Do not use for casual chat or simple factual questions.
+---
+
+# OpenViking Experience Memory
+
+Use prior task Experience as advisory operational guidance. Keep the current
+user request, current environment, and verified tool results authoritative.
+Experience retrieval supplements normal context retrieval; it does not replace
+user memory, events, preferences, session archives, resources, or Agent Skills.
+
+## Preconditions
+
+- Use only OpenViking tools that are actually registered in the current Agent
+  runtime.
+- Require both a semantic search capability and an exact URI read capability.
+- If either capability is unavailable, continue without Experience. Do not
+  invent a tool call, fabricate a ToolPart, or replace the Agent tool call with
+  direct HTTP or CLI access.
+- Do not substitute broad memory `recall` for a search scoped to the Experience
+  root. Continue using the runtime's normal recall and retrieval flows when the
+  task also needs user facts, events, decisions, prior conversation, or domain
+  resources.
+
+## Select Runtime Tools
+
+Choose the registered names that match the current runtime:
+
+| Runtime | Search | Read |
+| --- | --- | --- |
+| OpenViking MCP, Codex, Claude Code | `find` or `search` | `read` |
+| OpenCode | `openviking_find` or `openviking_search` | `openviking_read` |
+| OpenClaw | `ov_search` | `ov_read` or `ov_multi_read` |
+
+The host may display MCP names with a namespace such as
+`mcp__openviking__find`. Use the exact registered name and schema shown by the
+runtime. Prefer `find` for a fast task-start lookup and `search` when session
+context or deeper intent analysis is useful.
+
+## Retrieval Workflow
+
+1. Decide whether the request is an executable task. Retrieve Experience for
+   planning, tool use, environment changes, multi-step workflows, or recovery
+   from a failed attempt. Skip retrieval for casual conversation and simple
+   knowledge answers.
+2. Build one concise query containing the task goal, domain object, intended
+   operation, and important constraints. After a failure, include the failed
+   operation and stable error signature.
+3. Search only the current user's Experience root:
+
+   ```text
+   viking://user/memories/experiences
+   ```
+
+   For tools using MCP-style parameters, set `target_uri` to this root. For
+   OpenClaw `ov_search`, set `uri` to this root. Never hardcode `default`,
+   `test`, or another user ID.
+4. Start with `limit=5` and the tool's normal score threshold. Judge results by
+   task, environment, preconditions, and likely effect; title similarity alone
+   is insufficient. If no result is relevant, continue without Experience and
+   do not broaden the search to unrelated memory directories.
+5. Select only the one to three Experience files likely to change execution.
+   Require an exact file URI without a query or fragment. Ignore directories,
+   unrelated memory types, and sidecars such as `.abstract.md`, `.overview.md`,
+   and `.relations.json`.
+6. Read every selected canonical `viking://.../memories/experiences/...` URI
+   with the runtime's OpenViking read tool. Search abstracts help selection but
+   are not a substitute for reading the Experience body.
+7. Apply relevant steps and checks while executing the task. Do not repeat the
+   Experience verbatim to the user unless its content is directly needed in the
+   answer.
+8. If execution fails for a materially new reason, perform at most one focused
+   follow-up search using the failure evidence, then read only newly relevant
+   Experience files.
+
+## Applying Retrieved Experience
+
+- Treat Experience as reusable procedure, not as a user profile, user intent,
+  security policy, or proof that an action succeeded.
+- Follow priority in this order: system and developer instructions, current
+  user request, current environment and tool evidence, then Experience.
+- Ignore stale, incompatible, unsafe, or conflicting guidance. Verify commands,
+  paths, APIs, versions, and destructive actions against the current task.
+- Preserve confirmation requirements and permission boundaries. Prior success
+  never authorizes a destructive or external action in the current session.
+- When multiple Experience files conflict, prefer the one whose preconditions
+  match the current environment; otherwise proceed conservatively and surface
+  the ambiguity when it affects the user.
+
+## Session Evidence
+
+Use real Agent tool calls so the committed OpenViking session retains their
+ToolParts:
+
+- A completed generic OpenViking `find`, `search`, or `list` result containing
+  an Experience URI records recall for that Experience.
+- A completed generic OpenViking `read` or `multi_read` of an Experience URI
+  records injection and can associate the resulting trajectory with that
+  Experience.
+- Failed, cancelled, or incomplete calls do not count.
+
+Do not edit, summarize away, or synthesize these ToolParts before the session
+is committed.
+
+## Example
+
+For a request to fix a deployment failure:
+
+1. Search the Experience root with a query such as
+   `Kubernetes deployment image pull failure private registry`.
+2. Read the most relevant exact Experience URI.
+3. Check that its registry, credential, and rollout assumptions match the
+   current cluster.
+4. Apply the compatible diagnostic steps, verify the live result, and continue
+   the user's task.