@openviking/openclaw-plugin 2026.7.11 → 2026.8.6-1

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

@@ -0,0 +1,105 @@
+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/dist/plugin/openviking-import-tools.js

@@ -40,7 +40,7 @@ export function registerOpenVikingImportTools(deps) {
                     instruction: typeof params.instruction === "string" ? params.instruction : undefined,
                     wait: typeof params.wait === "boolean" ? params.wait : undefined,
                     timeout: typeof params.timeout === "number" ? params.timeout : undefined,
-                }, session.agentId);
+                }, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: formatResourceImportText(result) }],
                     details: {
@@ -73,7 +73,7 @@ export function registerOpenVikingImportTools(deps) {
                 data: params.data,
                 wait: typeof params.wait === "boolean" ? params.wait : undefined,
                 timeout: typeof params.timeout === "number" ? params.timeout : undefined,
-            }, session.agentId);
+            }, session.actorPeerId);
             return {
                 content: [{ type: "text", text: formatSkillImportText(result) }],
                 details: {

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

@@ -47,7 +47,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
             const requestLimit = queryConfig.candidateLimit;
             const recallClient = await deps.getClient();
             if (deps.cfg.logFindRequests) {
-                deps.logger.info?.(`openviking: memory_recall X-OpenViking-Actor-Peer="${session.agentId}" ` +
+                deps.logger.info?.(`openviking: memory_recall X-OpenViking-Actor-Peer="${session.actorPeerId ?? "none"}" ` +
                     `(plugin defaultAgentId="${recallClient.getDefaultAgentId()}" is unused when session context is present)`);
             }
             let result;
@@ -57,7 +57,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     targetUri,
                     limit: requestLimit,
                     scoreThreshold: 0,
-                    actorPeerId: session.agentId,
+                    actorPeerId: session.actorPeerId,
                 });
                 const traceResults = [
                     ...(result.memories ?? []).map((item) => toTraceResult(item, "memory", deps)),
@@ -84,7 +84,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     limit: requestLimit,
                     scoreThreshold: 0,
                     contextType: search.contextType,
-                    actorPeerId: session.agentId,
+                    actorPeerId: session.actorPeerId,
                 })));
                 const allMemories = [];
                 for (let index = 0; index < settled.length; index += 1) {
@@ -188,7 +188,7 @@ export function registerOpenVikingMemoryRecallTools(deps) {
                     details: { count: 0, total: result.total ?? 0, scoreThreshold },
                 };
             }
-            const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.agentId), {
+            const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.actorPeerId), {
                 recallPreferAbstract: false,
                 recallMaxInjectedChars: queryConfig.maxInjectedChars,
             });

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

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { clampScore, postProcessMemories } from "../memory-ranking.js";
+import { resolveOpenVikingMessagePeerId, } from "../routing/identity-routing.js";
 import { isMemoryUri } from "../routing/memory-uri.js";
 function totalCommitMemories(r) {
     const m = r.memories_extracted;
@@ -41,11 +42,15 @@ export function registerOpenVikingMemoryTools(deps) {
                     sessionId = deps.createTempSessionId();
                     usedTempSession = true;
                 }
-                const roleId = role === "user" ? deps.toRoleId(deps.extractSenderId(ctx)) : undefined;
-                await client.addSessionMessage(sessionId, role, [{ type: "text", text }], session.agentId, undefined, roleId);
+                const peerId = resolveOpenVikingMessagePeerId({
+                    peerRole: deps.peerRole,
+                    role,
+                    personPeerId: session.actorPeerId,
+                    assistantPeerId: session.actorPeerId,
+                });
+                await client.addSessionMessage(sessionId, role, [{ type: "text", text }], undefined, undefined, peerId);
                 const commitResult = await client.commitSession(sessionId, {
                     wait: true,
-                    agentId: session.agentId,
                     keepRecentCount: 0,
                 });
                 const memoriesCount = totalCommitMemories(commitResult);
@@ -130,7 +135,7 @@ export function registerOpenVikingMemoryTools(deps) {
                         details: { action: "rejected", uri },
                     };
                 }
-                await client.deleteUri(uri, session.agentId);
+                await client.deleteUri(uri, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: `Forgotten: ${uri}` }],
                     details: { action: "deleted", uri },
@@ -157,7 +162,7 @@ export function registerOpenVikingMemoryTools(deps) {
                 targetUri,
                 limit: requestLimit,
                 scoreThreshold: 0,
-            }, session.agentId);
+            }, session.actorPeerId);
             const candidates = postProcessMemories(result.memories ?? [], {
                 limit: requestLimit,
                 scoreThreshold,
@@ -176,7 +181,7 @@ export function registerOpenVikingMemoryTools(deps) {
             }
             const top = candidates[0];
             if (candidates.length === 1 && clampScore(top.score) >= 0.85) {
-                await client.deleteUri(top.uri, session.agentId);
+                await client.deleteUri(top.uri, session.actorPeerId);
                 return {
                     content: [{ type: "text", text: `Forgotten: ${top.uri}` }],
                     details: { action: "deleted", uri: top.uri, score: top.score ?? 0 },

package/dist/plugin/openviking-query-runtime.js

@@ -337,7 +337,7 @@ export function createOpenVikingQueryRuntime(deps) {
             sessionId: traceCtx?.sessionId,
             sessionKey: traceCtx?.sessionKey,
             ovSessionId: traceCtx?.ovSessionId,
-            agentId,
+            agentId: traceCtx?.agentId,
             source: "ov_search",
             operationType: "semantic_find",
             resourceTypes: [...new Set(searches.map((search) => search.resourceType).filter((resourceType) => resourceType !== "archive"))],

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

@@ -21,7 +21,7 @@ export function registerOpenVikingQueryTools(deps) {
                 query: String(params.query ?? ""),
                 uri: typeof params.uri === "string" ? params.uri : undefined,
                 limit: typeof params.limit === "number" ? params.limit : undefined,
-            }, session.agentId, session);
+            }, session.actorPeerId, session);
         },
     }), { name: "ov_search" });
     deps.registerTool((ctx) => ({
@@ -41,7 +41,7 @@ export function registerOpenVikingQueryTools(deps) {
             const session = deps.resolvePluginSessionRouting(ctx);
             return deps.readOpenVikingContent({
                 uri: String(params.uri ?? ""),
-            }, session.agentId);
+            }, session.actorPeerId);
         },
     }), { name: "ov_read" });
     deps.registerTool((ctx) => ({
@@ -62,7 +62,7 @@ export function registerOpenVikingQueryTools(deps) {
             const uris = Array.isArray(params.uris)
                 ? params.uris.map((uri) => String(uri))
                 : [];
-            return deps.multiReadOpenVikingContent({ uris }, session.agentId);
+            return deps.multiReadOpenVikingContent({ uris }, session.actorPeerId);
         },
     }), { name: "ov_multi_read" });
     deps.registerTool((ctx) => ({
@@ -85,7 +85,7 @@ export function registerOpenVikingQueryTools(deps) {
                 recursive: typeof params.recursive === "boolean" ? params.recursive : undefined,
                 simple: typeof params.simple === "boolean" ? params.simple : undefined,
                 limit: typeof params.limit === "number" ? params.limit : undefined,
-            }, session.agentId);
+            }, session.actorPeerId);
         },
     }), { name: "ov_list" });
 }

package/dist/plugin/openviking-recall-trace-runtime.js

@@ -157,11 +157,11 @@ export function createOpenVikingRecallTraceRuntime(deps) {
             for (const fallbackQuery of fallbackIdentities) {
                 const fallback = await deps.traceRecorder.queryWithFallback(fallbackQuery);
                 if (fallback.entries.length > 0) {
-                    return enrichTraceEntriesWithContent(fallback, shouldIncludeTraceContent(input), session.agentId);
+                    return enrichTraceEntriesWithContent(fallback, shouldIncludeTraceContent(input), session.actorPeerId);
                 }
             }
         }
-        return enrichTraceEntriesWithContent(base, shouldIncludeTraceContent(input), session.agentId);
+        return enrichTraceEntriesWithContent(base, shouldIncludeTraceContent(input), session.actorPeerId);
     };
     const handleUriDetail = async (request) => {
         const query = toQueryObject(request);
@@ -206,7 +206,7 @@ export function createOpenVikingRecallTraceRuntime(deps) {
         }
         try {
             const client = await deps.getClient();
-            const content = await client.read(uri, toString(query.agentId) ?? session.agentId);
+            const content = await client.read(uri, session.actorPeerId);
             const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
             const chars = Array.from(text);
             const slice = chars.slice(offset, offset + contentLimit).join("");

package/dist/plugin/openviking-session-routing-runtime.js

@@ -1,5 +1,6 @@
-import { createSessionAgentResolver, openClawSessionToOvStorageId, } from "../routing/identity-routing.js";
+import { createSessionAgentResolver, openClawSessionToOvStorageId, resolveOpenVikingActorPeerId, sanitizeOpenVikingPeerId, } from "../routing/identity-routing.js";
 export function createOpenVikingSessionRoutingRuntime(options) {
+    const peerRole = options.peerRole ?? "assistant";
     const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);
     const rememberSessionAgentId = (ctx) => {
         sessionAgentResolver.remember(ctx);
@@ -39,11 +40,17 @@ export function createOpenVikingSessionRoutingRuntime(options) {
             ovSessionId: ovSessionId || undefined,
         };
         rememberSessionAgentId(session);
+        const agentId = resolveAgentId(session.sessionId, session.sessionKey, session.ovSessionId);
         return {
             sessionId: session.sessionId,
             sessionKey: session.sessionKey,
             ovSessionId: session.ovSessionId,
-            agentId: resolveAgentId(session.sessionId, session.sessionKey, session.ovSessionId),
+            agentId,
+            actorPeerId: resolveOpenVikingActorPeerId({
+                peerRole,
+                personPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
+                assistantPeerId: agentId,
+            }),
         };
     };
     const toQueryConfigContext = (session) => ({

package/dist/plugin/openviking-tool-result-tools.js

@@ -83,7 +83,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             }
             try {
                 const client = await getClient();
-                const result = await client.readToolResult(session.ovSessionId, parsed.toolResultId, { offset, limit, includeMetadata: true }, session.agentId);
+                const result = await client.readToolResult(session.ovSessionId, parsed.toolResultId, { offset, limit, includeMetadata: true });
                 const returnedChars = result.content.length;
                 const nextOffset = result.offset + returnedChars;
                 const text = result.content || "(empty tool result chunk)";
@@ -167,7 +167,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             const contextChars = Math.max(0, getOptionalInteger(params.context_chars ?? params.contextChars, 300));
             try {
                 const client = await getClient();
-                const result = await client.searchToolResult(session.ovSessionId, parsed.toolResultId, query, { limit, contextChars }, session.agentId);
+                const result = await client.searchToolResult(session.ovSessionId, parsed.toolResultId, query, { limit, contextChars });
                 const matches = result.matches ?? [];
                 const text = matches.length
                     ? [
@@ -227,7 +227,7 @@ export function registerOpenVikingToolResultTools({ registerTool, getClient, res
             const limit = getPositiveInteger(params.limit, 50);
             try {
                 const client = await getClient();
-                const result = await client.listToolResults(session.ovSessionId, { toolName, limit }, session.agentId);
+                const result = await client.listToolResults(session.ovSessionId, { toolName, limit });
                 const items = result.tool_results ?? [];
                 const text = items.length
                     ? [

package/dist/routing/identity-routing.js

@@ -3,6 +3,33 @@ const DEFAULT_OPENCLAW_AGENT_ID = "main";
 /** OpenClaw session UUID (path-safe on Windows). */
 const OPENVIKING_OV_SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const WINDOWS_BAD_SESSION_SEGMENT = /[:<>"\\/|?\u0000-\u001f]/;
+export function sanitizeOpenVikingPeerId(raw) {
+    const normalized = raw
+        ?.trim()
+        .replace(/[^a-zA-Z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .replace(/_+/g, "_");
+    return normalized || undefined;
+}
+export function resolveOpenVikingMessagePeerId(params) {
+    if (params.peerRole === "person" && params.role === "user") {
+        return params.personPeerId;
+    }
+    if (params.peerRole === "assistant" && params.role === "assistant") {
+        return params.assistantPeerId;
+    }
+    return undefined;
+}
+export function resolveOpenVikingActorPeerId(params) {
+    const actorPeerId = resolveOpenVikingMessagePeerId({
+        ...params,
+        role: params.peerRole === "person" ? "user" : "assistant",
+    });
+    if (params.peerRole === "person" && !actorPeerId) {
+        throw new Error("openviking: peer_role=person requires a sender identity");
+    }
+    return actorPeerId;
+}
 /**
  * Map OpenClaw session identity to an OpenViking session_id that is safe as a single
  * AGFS path segment on Windows (no `:` etc.). Prefer UUID sessionId when present;

package/dist/routing/memory-uri.js

@@ -1,5 +1,6 @@
 const MEMORY_URI_PATTERNS = [
     /^viking:\/\/user\/(?:[^/]+(?:\/agent\/[^/]+)?\/)?memories(?:\/|$)/,
+    /^viking:\/\/user\/[^/]+\/peers\/[^/]+\/memories(?:\/|$)/,
     /^viking:\/\/agent\/(?:[^/]+(?:\/user\/[^/]+)?\/)?memories(?:\/|$)/,
 ];
 export function isMemoryUri(uri) {

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

@@ -2,7 +2,7 @@
 import { DEFAULT_PHASE2_POLL_TIMEOUT_MS } from "../client.js";
 import { buildAutoRecallContext, prepareRecallQuery } from "../auto-recall.js";
 import { toJsonLog } from "../memory-ranking.js";
-import { openClawSessionToOvStorageId } from "../routing/identity-routing.js";
+import { openClawSessionToOvStorageId, resolveOpenVikingActorPeerId, resolveOpenVikingMessagePeerId, sanitizeOpenVikingPeerId, } from "../routing/identity-routing.js";
 import { extractNewTurnMessages } from "../text-utils.js";
 import { estimateAgentMessageTokens, estimateTextTokens } from "../token-estimator.js";
 import { convertToAgentMessages, mergeConsecutiveAssistants, sanitizeAgentMessagesForProvider, toRoleId, } from "./context-message-adapter.js";
@@ -26,12 +26,12 @@ function sleep(ms) {
  * After wait=false commit, Phase2 runs on the server. Poll task until completed/failed/timeout
  * so logs show memories_extracted (otherwise it looks like "nothing was saved").
  */
-async function pollPhase2ExtractionOutcome(client, taskId, agentId, logger, sessionLabel) {
+async function pollPhase2ExtractionOutcome(client, taskId, logger, sessionLabel) {
     const deadline = Date.now() + PHASE2_POLL_MAX_MS;
     try {
         while (Date.now() < deadline) {
             await sleep(PHASE2_POLL_INTERVAL_MS);
-            const task = await client.getTask(taskId, agentId).catch((e) => {
+            const task = await client.getTask(taskId).catch((e) => {
                 logger.warn?.(`openviking: phase2 getTask failed task_id=${taskId}: ${String(e)}`);
                 return null;
             });
@@ -141,7 +141,7 @@ function buildAssembledContext(overview, preAbstracts, ovMessages, tokenBudget,
     const sanitized = sanitizeAgentMessagesForProvider(assembled);
     return { sanitized, archive, session, budgets, instruction };
 }
-export async function commitOpenVikingSession({ sessionId, sessionKey, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, }) {
+export async function commitOpenVikingSession({ sessionId, sessionKey, getClient, logger, rememberSessionAgentId, isBypassedSession, }) {
     const ovId = openClawSessionToOvStorageId(sessionId, sessionKey);
     if (isBypassedSession({ sessionId, sessionKey })) {
         logger.warn?.(`openviking: commit skipped because session is bypassed (sessionId=${sessionId}, sessionKey=${sessionKey ?? "none"})`);
@@ -154,10 +154,8 @@ export async function commitOpenVikingSession({ sessionId, sessionKey, getClient
             sessionKey,
             ovSessionId: ovId,
         });
-        const agentId = resolveAgentId(sessionId, sessionKey, ovId);
         const commitResult = await client.commitSession(ovId, {
             wait: true,
-            agentId,
             keepRecentCount: 0,
         });
         const memCount = totalExtractedMemories(commitResult.memories_extracted);
@@ -248,6 +246,11 @@ export async function assembleOpenVikingSession({ sessionId, sessionKey, message
             const client = await getClient();
             const routingRef = sessionId ?? sessionKey ?? ovSessionId;
             const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
+            const actorPeerId = resolveOpenVikingActorPeerId({
+                peerRole: cfg.peer_role ?? "assistant",
+                personPeerId: sanitizeOpenVikingPeerId(sender.senderId),
+                assistantPeerId: agentId,
+            });
             const queryConfig = await queryConfigStore?.getEffective({
                 agentId,
                 sessionId,
@@ -259,6 +262,7 @@ export async function assembleOpenVikingSession({ sessionId, sessionKey, message
                 queryConfig,
                 client,
                 agentId,
+                actorPeerId,
                 queryText: recallQuery.query,
                 logger,
                 verbose: (message) => logger.info(message),
@@ -307,9 +311,7 @@ export async function assembleOpenVikingSession({ sessionId, sessionKey, message
     }
     try {
         const client = await getClient();
-        const routingRef = sessionId ?? sessionKey ?? ovSessionId;
-        const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
-        const ctx = await client.getSessionContext(ovSessionId, tokenBudget, agentId);
+        const ctx = await client.getSessionContext(ovSessionId, tokenBudget);
         const preAbstracts = ctx?.pre_archive_abstracts ?? [];
         const hasArchives = !!ctx?.latest_archive_overview || preAbstracts.length > 0;
         const activeCount = ctx?.messages?.length ?? 0;
@@ -596,10 +598,15 @@ export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messag
                 };
             });
             if (ovParts.length > 0) {
-                await client.addSessionMessage(ovSessionId, msg.role, ovParts, agentId, createdAt, msg.role === "user" ? senderRoleId : undefined);
+                await client.addSessionMessage(ovSessionId, msg.role, ovParts, undefined, createdAt, resolveOpenVikingMessagePeerId({
+                    peerRole: cfg.peer_role ?? "assistant",
+                    role: msg.role,
+                    personPeerId: senderRoleId,
+                    assistantPeerId: agentId,
+                }));
             }
         }
-        const session = await client.getSession(ovSessionId, agentId);
+        const session = await client.getSession(ovSessionId);
         const pendingTokens = session.pending_tokens ?? 0;
         const commitTokenThreshold = Math.floor(tokenBudget * cfg.commitTokenThresholdRatio);
         if (pendingTokens < commitTokenThreshold) {
@@ -616,7 +623,6 @@ export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messag
         }
         const commitResult = await client.commitSession(ovSessionId, {
             wait: false,
-            agentId,
             keepRecentCount: cfg.commitKeepRecentCount,
         });
         logger.info(`openviking: committed session=${ovSessionId}, ` +
@@ -637,7 +643,7 @@ export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messag
         if (commitResult.task_id && cfg.logFindRequests) {
             logger.info(`openviking: Phase2 memory extraction runs asynchronously on the server (task_id=${commitResult.task_id}). ` +
                 "memories_extracted appears only after that task completes — not in this immediate response.");
-            void pollPhase2ExtractionOutcome(client, commitResult.task_id, agentId, logger, ovSessionId);
+            void pollPhase2ExtractionOutcome(client, commitResult.task_id, logger, ovSessionId);
         }
     }
     catch (err) {
@@ -697,7 +703,7 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
     let preCommitEstimatedTokens;
     if (typeof tokensBeforeOriginal !== "number") {
         try {
-            const preCtx = await client.getSessionContext(ovSessionId, tokenBudget, agentId);
+            const preCtx = await client.getSessionContext(ovSessionId, tokenBudget);
             if (typeof preCtx.estimatedTokens === "number" && Number.isFinite(preCtx.estimatedTokens)) {
                 preCommitEstimatedTokens = preCtx.estimatedTokens;
             }
@@ -712,7 +718,6 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
         logger.info(`openviking: compact committing session=${ovSessionId} (wait=true, tokenBudget=${tokenBudget})`);
         const commitResult = await client.commitSession(ovSessionId, {
             wait: true,
-            agentId,
             keepRecentCount: 0,
         });
         const memCount = totalExtractedMemories(commitResult.memories_extracted);
@@ -774,7 +779,7 @@ export async function compactOpenVikingSession({ sessionId, sessionKey, tokenBud
         let tokensAfter;
         let contextFetchError;
         try {
-            const ctx = await client.getSessionContext(ovSessionId, tokenBudget, agentId);
+            const ctx = await client.getSessionContext(ovSessionId, tokenBudget);
             logger.info(`openviking: compact getSessionContext raw result for ${ovSessionId}: ` +
                 JSON.stringify(ctx, null, 2));
             if (typeof ctx.latest_archive_overview === "string") {

package/dist/services/context-message-adapter.js

@@ -1,14 +1,7 @@
+import { sanitizeOpenVikingPeerId } from "../routing/identity-routing.js";
 import { sanitizeToolUseResultPairing } from "../session-transcript-repair.js";
 export function toRoleId(senderId) {
-    if (!senderId) {
-        return undefined;
-    }
-    const normalized = senderId
-        .trim()
-        .replace(/[^a-zA-Z0-9_-]+/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .replace(/_+/g, "_");
-    return normalized || undefined;
+    return sanitizeOpenVikingPeerId(senderId);
 }
 /**
  * Convert an OpenViking stored message (parts-based format) into one or more

package/index.ts

@@ -19,6 +19,7 @@ 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";
@@ -41,7 +42,7 @@ import {
 import type { CommandDefinition } from "./plugin/command-registration.js";
 
 import type { HttpTransport } from "./adapters/http-transport.js";
-import { formatMessageFaithful, toRoleId } from "./services/context-message-adapter.js";
+import { formatMessageFaithful } from "./services/context-message-adapter.js";
 import {
   clampScore,
   postProcessMemories,
@@ -212,6 +213,7 @@ const contextEnginePlugin = {
       resolvePluginSessionRouting,
       toQueryConfigContext,
     } = createOpenVikingSessionRoutingRuntime({
+      peerRole: cfg.peer_role,
       peerPrefix: cfg.peer_prefix,
       logFindRequests: cfg.logFindRequests,
       logger: api.logger,
@@ -279,6 +281,15 @@ const contextEnginePlugin = {
       makeBypassedToolResult,
     });
 
+    registerOpenVikingExperienceTools({
+      registerTool: registerOpenVikingTool,
+      getClient,
+      resolvePluginSessionRouting,
+      isBypassedSession,
+      makeBypassedToolResult,
+      userId: cfg.userId,
+    });
+
     registerOpenVikingMemoryRecallTools({
       registerTool: registerOpenVikingTool,
       getClient,
@@ -329,8 +340,7 @@ const contextEnginePlugin = {
       getClient,
       normalizeSessionId: openClawSessionRefToOvStorageId,
       createTempSessionId: createMemoryStoreTempSessionId,
-      extractSenderId: extractToolSenderId,
-      toRoleId,
+      peerRole: cfg.peer_role,
       resolvePluginSessionRouting,
       isBypassedSession,
       makeBypassedToolResult,

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"
     ]
   },