@openviking/openclaw-plugin 2026.8.7 → 2026.8.12

package/README.md

@@ -46,8 +46,6 @@ Once installed, the plugin provides these agent tools:
 | `ov_read` | Read the full original content of one exact OpenViking URI |
 | `ov_multi_read` | Read the full original content of multiple OpenViking URIs |
 | `ov_list` | List OpenViking directories after search to inspect sibling chunks and overview files |
-| `search_experience` | Search reusable execution experiences for the current OpenViking user |
-| `read_experience` | Read one exact Experience returned by `search_experience` |
 | `openviking_tool_result_read` | Restore the full original content of an externalized tool result |
 | `openviking_tool_result_search` | Search inside an externalized tool result by keyword |
 | `openviking_tool_result_list` | List externalized tool results in the current session |
@@ -250,8 +248,6 @@ Beyond automatic behavior, the plugin exposes these tools directly:
 - `ov_read`: read one exact `viking://` URI returned by `ov_search` or `ov_list`
 - `ov_multi_read`: read multiple exact `viking://` URIs, useful for an overview plus sibling chunks
 - `ov_list`: list a hit's parent directory after `ov_search` to recover sibling chunks, `.overview.md`, and related split-document context
-- `search_experience`: search reusable execution experiences for the current OpenViking user
-- `read_experience`: read one exact Experience returned by `search_experience`
 
 They serve different roles:
 
@@ -265,7 +261,6 @@ They serve different roles:
 - `ov_read` turns a ranked hit into original evidence before answering precise documentation, codebase, configuration, or procedural questions
 - `ov_multi_read` reads overview and sibling chunks together when a split document needs more context than a single hit
 - `ov_list` complements `ov_search` when a ranked hit is only one chunk of a larger procedure or document
-- `search_experience` and `read_experience` provide the exact tool-call contract used by the bundled Experience Memory skill and usage reporting
 
 `ov_archive_expand` is especially important because `assemble()` normally returns archive summaries and indexes, not the full raw transcript.
 

package/config.ts

@@ -170,8 +170,6 @@ export const OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES = [
   "ov_read",
   "ov_multi_read",
   "ov_list",
-  "search_experience",
-  "read_experience",
   "memory_recall",
   "ov_recall_trace",
   "memory_store",
@@ -192,7 +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"],
-  experience: ["search_experience", "read_experience"],
   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, 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/config.js

@@ -35,8 +35,6 @@ export const OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES = [
     "ov_read",
     "ov_multi_read",
     "ov_list",
-    "search_experience",
-    "read_experience",
     "memory_recall",
     "ov_recall_trace",
     "memory_store",
@@ -56,7 +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"],
-    experience: ["search_experience", "read_experience"],
     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, 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/index.js

@@ -15,7 +15,6 @@ import { registerOpenVikingCommands } from "./plugin/command-registration.js";
 import { registerRecallTraceRoutes as registerRecallTraceRouteAdapters } from "./plugin/recall-trace-routes.js";
 import { createOpenVikingService } from "./plugin/openviking-services.js";
 import { registerOpenVikingArchiveTools } from "./plugin/openviking-archive-tools.js";
-import { registerOpenVikingExperienceTools } from "./plugin/openviking-experience-tools.js";
 import { createOpenVikingImportRuntime } from "./plugin/openviking-import-runtime.js";
 import { registerOpenVikingImportTools } from "./plugin/openviking-import-tools.js";
 import { registerOpenVikingLifecycleHooks } from "./plugin/openviking-lifecycle-hooks.js";
@@ -137,14 +136,6 @@ const contextEnginePlugin = {
             isBypassedSession,
             makeBypassedToolResult,
         });
-        registerOpenVikingExperienceTools({
-            registerTool: registerOpenVikingTool,
-            getClient,
-            resolvePluginSessionRouting,
-            isBypassedSession,
-            makeBypassedToolResult,
-            userId: cfg.userId,
-        });
         registerOpenVikingMemoryRecallTools({
             registerTool: registerOpenVikingTool,
             getClient,

package/dist/text-utils.js

@@ -346,7 +346,7 @@ export function extractNewTurnMessages(messages, startIndex) {
                             toolName,
                             toolInput,
                             toolOutput: output,
-                            toolStatus: "completed",
+                            toolStatus: msg.isError === true ? "error" : "completed",
                         }],
                 });
             }

package/index.ts

@@ -19,7 +19,6 @@ import { registerOpenVikingCommands } from "./plugin/command-registration.js";
 import { registerRecallTraceRoutes as registerRecallTraceRouteAdapters } from "./plugin/recall-trace-routes.js";
 import { createOpenVikingService } from "./plugin/openviking-services.js";
 import { registerOpenVikingArchiveTools } from "./plugin/openviking-archive-tools.js";
-import { registerOpenVikingExperienceTools } from "./plugin/openviking-experience-tools.js";
 import { createOpenVikingImportRuntime } from "./plugin/openviking-import-runtime.js";
 import { registerOpenVikingImportTools } from "./plugin/openviking-import-tools.js";
 import { registerOpenVikingLifecycleHooks } from "./plugin/openviking-lifecycle-hooks.js";
@@ -281,15 +280,6 @@ const contextEnginePlugin = {
       makeBypassedToolResult,
     });
 
-    registerOpenVikingExperienceTools({
-      registerTool: registerOpenVikingTool,
-      getClient,
-      resolvePluginSessionRouting,
-      isBypassedSession,
-      makeBypassedToolResult,
-      userId: cfg.userId,
-    });
-
     registerOpenVikingMemoryRecallTools({
       registerTool: registerOpenVikingTool,
       getClient,

package/openclaw.plugin.json

@@ -19,8 +19,6 @@
       "ov_read",
       "ov_multi_read",
       "ov_list",
-      "search_experience",
-      "read_experience",
       "memory_recall",
       "ov_recall_trace",
       "memory_store",
@@ -52,7 +50,8 @@
   },
   "skills": [
     "./skills/install-openviking-memory",
-    "./skills/openviking-context-database"
+    "./skills/openviking-context-database",
+    "./skills/ov-experience-memory"
   ],
   "setup": {
     "providers": [
@@ -254,7 +253,7 @@
     "enabledTools": {
       "label": "Enabled Tools",
       "placeholder": "default",
-      "help": "Agent-visible tool allowlist. Accepts tool names or groups: default, all, memory, resource_query, experience, 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/package.json

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

package/registries/openviking-tools.ts

@@ -1,7 +1,6 @@
 export type OpenVikingToolGroup =
   | "memory"
   | "resource_query"
-  | "experience"
   | "import"
   | "recall_trace"
   | "archive"
@@ -14,8 +13,6 @@ export type OpenVikingToolName =
   | "ov_read"
   | "ov_multi_read"
   | "ov_list"
-  | "search_experience"
-  | "read_experience"
   | "memory_recall"
   | "ov_recall_trace"
   | "memory_store"
@@ -47,8 +44,6 @@ export const OPENVIKING_TOOL_SPECS = [
   { name: "ov_read", group: "resource_query", defaultEnabled: true },
   { name: "ov_multi_read", group: "resource_query", defaultEnabled: true },
   { name: "ov_list", group: "resource_query", defaultEnabled: true },
-  { name: "search_experience", group: "experience", defaultEnabled: true },
-  { name: "read_experience", group: "experience", defaultEnabled: true },
   { name: "memory_recall", group: "memory", defaultEnabled: true },
   { name: "ov_recall_trace", group: "recall_trace", defaultEnabled: true },
   { name: "memory_store", group: "memory", defaultEnabled: true },
@@ -69,7 +64,6 @@ export const OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES = OPENVIKING_TOOL_SPECS
 const OPENVIKING_TOOL_GROUP_ORDER: readonly OpenVikingToolGroup[] = [
   "memory",
   "resource_query",
-  "experience",
   "import",
   "recall_trace",
   "archive",
@@ -79,6 +73,8 @@ const OPENVIKING_TOOL_GROUP_ORDER: readonly OpenVikingToolGroup[] = [
 export const OPENVIKING_TOOL_GROUPS: Record<string, readonly OpenVikingToolName[]> = {
   all: OPENVIKING_ALL_TOOL_NAMES,
   default: OPENVIKING_DEFAULT_ENABLED_TOOL_NAMES,
+  // Migration alias for the removed dedicated Experience tools.
+  experience: ["ov_search", "ov_read"],
   ...Object.fromEntries(
     OPENVIKING_TOOL_GROUP_ORDER.map((group) => [
       group,

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

@@ -1,156 +1,116 @@
 ---
 name: ov-experience-memory
-description: >
-  Use OpenViking experience memories during task execution. Search relevant
-  experiences with search_experience, read selected experiences with
-  read_experience, and leave standard tool parts in the committed session so
-  OpenViking can report recall and injection usage.
-version: 2026.7.9
-tags:
-  - openviking
-  - experience-memory
-  - agent-memory
-  - usage-reporting
+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 this skill when the current user request starts or continues an executable
-task, especially tasks involving tools, files, code changes, data operations,
-workflow decisions, or multi-step actions.
-
-Do not use this skill for casual chat, pure explanation, or one-off factual Q&A
-that does not require operational guidance.
-
-## Runtime Contract
-
-The agent runtime must expose two tools with these exact names:
-
-- `search_experience`
-- `read_experience`
-
-OpenViking usage reporting recognizes only completed tool parts with these exact
-tool names. Calls to generic `find`, `search`, `read`, `ov_search`, or `ov_read`
-do not count as experience recall or injection events.
-
-## Tool: search_experience
-
-Purpose: search reusable execution experiences from the OpenViking experience
-library before assembling task context.
-
-Input schema:
-
-```json
-{
-  "query": "string",
-  "limit": 5
-}
-```
-
-Output schema:
-
-```json
-{
-  "results": [
-    {
-      "uri": "viking://user/<current_user_id>/memories/experiences/example.md",
-      "title": "example",
-      "score": 0.82,
-      "snippet": "Short summary or matched situation"
-    }
-  ]
-}
-```
-
-Implementation:
-
-The runtime tool calls OpenViking `POST /api/v1/search/find` with `target_uri`
-fixed to the current-user shorthand `viking://user/memories/experiences/`.
-Callers provide only `query` and optional `limit`; they cannot override or pass
-`target_uri`. OpenViking resolves the fixed shorthand against the authenticated
-request user. Return only canonical experience memory URIs for that user; never
-hardcode `default` or another user ID.
-
-Usage reporting:
-
-A completed `search_experience` tool part is counted as an experience recall
-event for every `results[].uri` value.
-
-## Tool: read_experience
-
-Purpose: read the full Markdown body of a selected experience and inject it into
-the agent prompt as task execution guidance.
-
-Input schema:
-
-```json
-{
-  "uri": "viking://user/<current_user_id>/memories/experiences/example.md"
-}
-```
-
-Output schema:
-
-```json
-{
-  "uri": "viking://user/<current_user_id>/memories/experiences/example.md",
-  "content": "Experience Markdown body"
-}
-```
-
-Implementation:
-
-Call OpenViking `GET /api/v1/content/read?uri=<encoded_uri>` for the selected
-experience URI. Always pass the canonical URI returned by `search_experience`;
-do not construct a URI with a hardcoded user ID. The returned content should be
-inserted into the prompt as operational guidance, not as user profile facts.
-
-Usage reporting:
-
-A completed `read_experience` tool part is counted as an experience injection
-event for `tool_input.uri` or `tool_output.uri`. In this design, reading an
-experience through `read_experience` means the experience was injected into the
-prompt.
-
-## Recommended Flow
-
-1. When a task begins, build a short query from the latest user instruction,
-   current plan, active skill name, and important tool/environment context.
-2. Call `search_experience` before final prompt assembly.
-3. Review returned titles/snippets and select only experiences likely to affect
-   execution.
-4. Call `read_experience` for selected experience URIs.
-5. Inject the returned Markdown into the prompt under an explicit experience
-   section.
-6. Continue task execution.
-7. Commit the session normally. The committed session must include the
-   `search_experience` and `read_experience` tool parts so OpenViking can report
-   usage.
-
-## Prompt Injection Format
-
-Use a compact and explicit block:
-
-```text
-<openviking-experience-memory>
-The following guidance was retrieved from prior task execution experience.
-Use it as operational guidance. Do not treat it as user identity or preference.
-
-<experience uri="viking://user/<current_user_id>/memories/experiences/example.md">
-...experience markdown...
-</experience>
-</openviking-experience-memory>
-```
-
-## Commit Requirements
-
-The session committed to OpenViking must preserve tool parts with:
-
-- `tool_name`
-- `tool_status`
-- `tool_input`
-- `tool_output`
-- `tool_id`
-
-Only `tool_status == "completed"` is counted. Failed, cancelled, or skipped tool
-parts are ignored by usage reporting.
+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.

package/text-utils.ts

@@ -411,7 +411,7 @@ export function extractNewTurnMessages(
             toolName,
             toolInput,
             toolOutput: output,
-            toolStatus: "completed",
+            toolStatus: msg.isError === true ? "error" : "completed",
           }],
         });
       }

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

@@ -1,105 +0,0 @@
-import { Type } from "@sinclair/typebox";
-const EXPERIENCE_TARGET_URI = "viking://user/memories/experiences/";
-const DEFAULT_LIMIT = 5;
-const MAX_LIMIT = 20;
-const EXPERIENCE_SIDECAR_FILENAMES = new Set([".abstract.md", ".overview.md", ".relations.json"]);
-function clampLimit(value) {
-    const parsed = Number.isFinite(Number(value)) ? Math.trunc(Number(value)) : DEFAULT_LIMIT;
-    return Math.max(1, Math.min(MAX_LIMIT, parsed));
-}
-function experienceRelativePath(uri) {
-    return uri.match(/^viking:\/\/user\/[^/]+\/memories\/experiences\/(.+)$/)?.[1] ?? "";
-}
-export function isCanonicalExperienceUri(uri, expectedUserId) {
-    const value = typeof uri === "string" ? uri.trim() : "";
-    if (!value || value.includes("?") || value.includes("#")) {
-        return false;
-    }
-    const owner = value.match(/^viking:\/\/user\/([^/]+)\//)?.[1] ?? "";
-    if (expectedUserId?.trim() && owner !== expectedUserId.trim()) {
-        return false;
-    }
-    const relative = experienceRelativePath(value);
-    const segments = relative.split("/");
-    const basename = segments.at(-1) ?? "";
-    return Boolean(relative
-        && segments.every((segment) => segment && segment !== "." && segment !== "..")
-        && !EXPERIENCE_SIDECAR_FILENAMES.has(basename));
-}
-function titleFromUri(uri) {
-    const basename = uri.split("/").at(-1) ?? uri;
-    const title = basename.replace(/\.md$/i, "");
-    try {
-        return decodeURIComponent(title);
-    }
-    catch {
-        return title;
-    }
-}
-function jsonToolResult(payload) {
-    return {
-        content: [{ type: "text", text: JSON.stringify(payload) }],
-    };
-}
-export function registerOpenVikingExperienceTools(deps) {
-    deps.registerTool((ctx) => ({
-        name: "search_experience",
-        label: "Search Experience (OpenViking)",
-        description: "Search reusable task-execution experiences for the current OpenViking user. " +
-            "Use before executing operational or multi-step tasks, then call read_experience for selected results.",
-        parameters: Type.Object({
-            query: Type.String({ description: "Current task, situation, or execution problem to search for" }),
-            limit: Type.Optional(Type.Integer({
-                description: `Maximum results to return. Default: ${DEFAULT_LIMIT}; maximum: ${MAX_LIMIT}`,
-                minimum: 1,
-                maximum: MAX_LIMIT,
-            })),
-        }, { additionalProperties: false }),
-        async execute(_toolCallId, params) {
-            if (deps.isBypassedSession(ctx)) {
-                return deps.makeBypassedToolResult("search_experience");
-            }
-            const query = typeof params.query === "string" ? params.query.trim() : "";
-            if (!query) {
-                throw new Error("query is required");
-            }
-            const session = deps.resolvePluginSessionRouting(ctx);
-            const client = await deps.getClient();
-            const result = await client.find(query, {
-                targetUri: EXPERIENCE_TARGET_URI,
-                limit: clampLimit(params.limit),
-            }, session.actorPeerId);
-            const results = (result.memories ?? [])
-                .filter((item) => isCanonicalExperienceUri(item.uri, deps.userId))
-                .map((item) => ({
-                uri: item.uri,
-                title: titleFromUri(item.uri),
-                score: typeof item.score === "number" ? item.score : 0,
-                snippet: item.abstract || item.overview || "",
-            }));
-            return jsonToolResult({ results });
-        },
-    }), { name: "search_experience" });
-    deps.registerTool((ctx) => ({
-        name: "read_experience",
-        label: "Read Experience (OpenViking)",
-        description: "Read the complete Markdown body of one Experience returned by search_experience and use it as execution guidance.",
-        parameters: Type.Object({
-            uri: Type.String({ description: "Exact canonical Experience URI returned by search_experience" }),
-        }, { additionalProperties: false }),
-        async execute(_toolCallId, params) {
-            if (deps.isBypassedSession(ctx)) {
-                return deps.makeBypassedToolResult("read_experience");
-            }
-            const uri = typeof params.uri === "string" ? params.uri.trim() : "";
-            if (!isCanonicalExperienceUri(uri, deps.userId)) {
-                throw new Error("uri must be a canonical OpenViking Experience URI returned by search_experience");
-            }
-            const session = deps.resolvePluginSessionRouting(ctx);
-            const client = await deps.getClient();
-            const content = await client.read(uri, session.actorPeerId);
-            const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-            return jsonToolResult({ uri, content: text });
-        },
-    }), { name: "read_experience" });
-}

package/plugin/openviking-experience-tools.ts

@@ -1,160 +0,0 @@
-import { Type } from "@sinclair/typebox";
-
-import type { FindResult } from "../client.js";
-
-const EXPERIENCE_TARGET_URI = "viking://user/memories/experiences/";
-const DEFAULT_LIMIT = 5;
-const MAX_LIMIT = 20;
-const EXPERIENCE_SIDECAR_FILENAMES = new Set([".abstract.md", ".overview.md", ".relations.json"]);
-
-export type OpenVikingExperienceToolContext = {
-  sessionKey?: string;
-  sessionId?: string;
-  agentId?: string;
-  senderId?: string;
-  requesterSenderId?: string;
-};
-
-export type OpenVikingExperienceSession = {
-  sessionId?: string;
-  sessionKey?: string;
-  ovSessionId?: string;
-  agentId: string;
-  actorPeerId?: string;
-};
-
-type OpenVikingExperienceClient = {
-  find: (
-    query: string,
-    options: { targetUri: string; limit: number; scoreThreshold?: number },
-    actorPeerId?: string,
-  ) => Promise<FindResult>;
-  read: (uri: string, actorPeerId?: string) => Promise<unknown>;
-};
-
-export type OpenVikingExperienceToolsDeps = {
-  registerTool: (toolOrFactory: unknown, opts: { name: string }) => void;
-  getClient: () => Promise<OpenVikingExperienceClient>;
-  resolvePluginSessionRouting: (ctx?: OpenVikingExperienceToolContext) => OpenVikingExperienceSession;
-  isBypassedSession: (ctx?: OpenVikingExperienceToolContext) => boolean;
-  makeBypassedToolResult: (toolName: string) => unknown;
-  userId?: string;
-};
-
-function clampLimit(value: unknown): number {
-  const parsed = Number.isFinite(Number(value)) ? Math.trunc(Number(value)) : DEFAULT_LIMIT;
-  return Math.max(1, Math.min(MAX_LIMIT, parsed));
-}
-
-function experienceRelativePath(uri: string): string {
-  return uri.match(/^viking:\/\/user\/[^/]+\/memories\/experiences\/(.+)$/)?.[1] ?? "";
-}
-
-export function isCanonicalExperienceUri(uri: unknown, expectedUserId?: string): uri is string {
-  const value = typeof uri === "string" ? uri.trim() : "";
-  if (!value || value.includes("?") || value.includes("#")) {
-    return false;
-  }
-  const owner = value.match(/^viking:\/\/user\/([^/]+)\//)?.[1] ?? "";
-  if (expectedUserId?.trim() && owner !== expectedUserId.trim()) {
-    return false;
-  }
-  const relative = experienceRelativePath(value);
-  const segments = relative.split("/");
-  const basename = segments.at(-1) ?? "";
-  return Boolean(
-    relative
-    && segments.every((segment) => segment && segment !== "." && segment !== "..")
-    && !EXPERIENCE_SIDECAR_FILENAMES.has(basename)
-  );
-}
-
-function titleFromUri(uri: string): string {
-  const basename = uri.split("/").at(-1) ?? uri;
-  const title = basename.replace(/\.md$/i, "");
-  try {
-    return decodeURIComponent(title);
-  } catch {
-    return title;
-  }
-}
-
-function jsonToolResult(payload: Record<string, unknown>): {
-  content: Array<{ type: "text"; text: string }>;
-} {
-  return {
-    content: [{ type: "text", text: JSON.stringify(payload) }],
-  };
-}
-
-export function registerOpenVikingExperienceTools(deps: OpenVikingExperienceToolsDeps): void {
-  deps.registerTool(
-    (ctx: OpenVikingExperienceToolContext) => ({
-      name: "search_experience",
-      label: "Search Experience (OpenViking)",
-      description:
-        "Search reusable task-execution experiences for the current OpenViking user. " +
-        "Use before executing operational or multi-step tasks, then call read_experience for selected results.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Current task, situation, or execution problem to search for" }),
-        limit: Type.Optional(Type.Integer({
-          description: `Maximum results to return. Default: ${DEFAULT_LIMIT}; maximum: ${MAX_LIMIT}`,
-          minimum: 1,
-          maximum: MAX_LIMIT,
-        })),
-      }, { additionalProperties: false }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
-        if (deps.isBypassedSession(ctx)) {
-          return deps.makeBypassedToolResult("search_experience");
-        }
-        const query = typeof params.query === "string" ? params.query.trim() : "";
-        if (!query) {
-          throw new Error("query is required");
-        }
-        const session = deps.resolvePluginSessionRouting(ctx);
-        const client = await deps.getClient();
-        const result = await client.find(query, {
-          targetUri: EXPERIENCE_TARGET_URI,
-          limit: clampLimit(params.limit),
-        }, session.actorPeerId);
-        const results = (result.memories ?? [])
-          .filter((item) => isCanonicalExperienceUri(item.uri, deps.userId))
-          .map((item) => ({
-            uri: item.uri,
-            title: titleFromUri(item.uri),
-            score: typeof item.score === "number" ? item.score : 0,
-            snippet: item.abstract || item.overview || "",
-          }));
-        return jsonToolResult({ results });
-      },
-    }),
-    { name: "search_experience" },
-  );
-
-  deps.registerTool(
-    (ctx: OpenVikingExperienceToolContext) => ({
-      name: "read_experience",
-      label: "Read Experience (OpenViking)",
-      description:
-        "Read the complete Markdown body of one Experience returned by search_experience and use it as execution guidance.",
-      parameters: Type.Object({
-        uri: Type.String({ description: "Exact canonical Experience URI returned by search_experience" }),
-      }, { additionalProperties: false }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
-        if (deps.isBypassedSession(ctx)) {
-          return deps.makeBypassedToolResult("read_experience");
-        }
-        const uri = typeof params.uri === "string" ? params.uri.trim() : "";
-        if (!isCanonicalExperienceUri(uri, deps.userId)) {
-          throw new Error("uri must be a canonical OpenViking Experience URI returned by search_experience");
-        }
-        const session = deps.resolvePluginSessionRouting(ctx);
-        const client = await deps.getClient();
-        const content = await client.read(uri, session.actorPeerId);
-        const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-        return jsonToolResult({ uri, content: text });
-      },
-    }),
-    { name: "read_experience" },
-  );
-}