@openviking/openclaw-plugin 2026.8.13 → 2026.8.19

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/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/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/openclaw.plugin.json

@@ -261,6 +261,12 @@
       "placeholder": "memory",
       "help": "Agent-visible tool blocklist applied after enabledTools. Accepts the same tool names or groups.",
       "advanced": true
+    },
+    "runtimeQueryConfigPath": {
+      "label": "Runtime Query Config Path",
+      "placeholder": "~/.openclaw/openviking/runtime-query-config.json",
+      "help": "Optional JSON file for /ov-query-config runtime overrides. Empty keeps overrides in memory only.",
+      "advanced": true
     }
   },
   "configSchema": {
@@ -515,6 +521,10 @@
           }
         ]
       },
+      "runtimeQueryConfigPath": {
+        "type": "string",
+        "description": "Optional JSON file path for runtime query config overrides. Empty means in-memory only."
+      },
       "agentExperience": {
         "type": "object",
         "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/openclaw-plugin",
-  "version": "2026.8.13",
+  "version": "2026.8.19",
   "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

@@ -62,8 +62,7 @@ context or deeper intent analysis is useful.
    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`.
+   unrelated memory types, and sidecars such as `.abstract.md` and `.overview.md`.
 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.