@openviking/openclaw-plugin 2026.7.11 → 2026.7.15

package/auto-recall.ts

@@ -313,6 +313,7 @@ export async function buildAutoRecallContext(params: {
   queryConfig?: EffectiveQueryConfig;
   client: OpenVikingClient;
   agentId: string;
+  actorPeerId?: string;
   queryText: string;
   logger: Logger;
   verbose?: (message: string) => void;
@@ -324,14 +325,14 @@ export async function buildAutoRecallContext(params: {
   queryTruncated?: boolean;
   resourceTypes?: RecallResourceType[];
 }): Promise<{ block?: string; memoryCount: number; estimatedTokens: number }> {
-  const { cfg, client, agentId, queryText, logger, verbose } = params;
+  const { cfg, client, agentId, actorPeerId, queryText, logger, verbose } = params;
   const queryConfig = params.queryConfig;
 
   if (!cfg.autoRecall || queryText.length < 5) {
     return { memoryCount: 0, estimatedTokens: 0 };
   }
 
-  const precheck = await quickRecallPrecheck(client, agentId);
+  const precheck = await quickRecallPrecheck(client, actorPeerId);
   if (!precheck.ok) {
     verbose?.(`openviking: skipping auto-recall because precheck failed (${precheck.reason})`);
     return { memoryCount: 0, estimatedTokens: 0 };
@@ -369,7 +370,7 @@ export async function buildAutoRecallContext(params: {
           limit: candidateLimit,
           scoreThreshold: 0,
           contextType: search.contextType,
-          actorPeerId: agentId,
+          actorPeerId,
         });
         return {
           resourceType: search.resourceType,
@@ -484,7 +485,7 @@ export async function buildAutoRecallContext(params: {
 
       const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(
         memories,
-        (uri) => client.read(uri, agentId),
+        (uri) => client.read(uri, actorPeerId),
         {
           recallPreferAbstract,
           recallMaxInjectedChars: maxInjectedChars,

package/context-engine.ts

@@ -283,7 +283,6 @@ export function createMemoryOpenVikingContextEngine(params: {
       getClient,
       logger,
       rememberSessionAgentId,
-      resolveAgentId,
       isBypassedSession,
     });
   }

package/dist/auto-recall.js

@@ -200,12 +200,12 @@ export function shouldRecallAgentExperience(input) {
     return { recall: false, score, reason: score < 0 ? "non_execution" : "below_threshold" };
 }
 export async function buildAutoRecallContext(params) {
-    const { cfg, client, agentId, queryText, logger, verbose } = params;
+    const { cfg, client, agentId, actorPeerId, queryText, logger, verbose } = params;
     const queryConfig = params.queryConfig;
     if (!cfg.autoRecall || queryText.length < 5) {
         return { memoryCount: 0, estimatedTokens: 0 };
     }
-    const precheck = await quickRecallPrecheck(client, agentId);
+    const precheck = await quickRecallPrecheck(client, actorPeerId);
     if (!precheck.ok) {
         verbose?.(`openviking: skipping auto-recall because precheck failed (${precheck.reason})`);
         return { memoryCount: 0, estimatedTokens: 0 };
@@ -236,7 +236,7 @@ export async function buildAutoRecallContext(params) {
                 limit: candidateLimit,
                 scoreThreshold: 0,
                 contextType: search.contextType,
-                actorPeerId: agentId,
+                actorPeerId,
             });
             return {
                 resourceType: search.resourceType,
@@ -343,7 +343,7 @@ export async function buildAutoRecallContext(params) {
             await recordTrace([], 0, 0);
             return { memoryCount: 0, estimatedTokens: 0 };
         }
-        const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(memories, (uri) => client.read(uri, agentId), {
+        const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(memories, (uri) => client.read(uri, actorPeerId), {
             recallPreferAbstract,
             recallMaxInjectedChars: maxInjectedChars,
             includeUri: true,

package/dist/context-engine.js

@@ -135,7 +135,6 @@ export function createMemoryOpenVikingContextEngine(params) {
             getClient,
             logger,
             rememberSessionAgentId,
-            resolveAgentId,
             isBypassedSession,
         });
     }

package/dist/index.js

@@ -25,8 +25,8 @@ import { registerOpenVikingRecallTraceTools } from "./plugin/openviking-recall-t
 import { createOpenVikingRuntimeState } from "./plugin/openviking-runtime-state.js";
 import { createOpenVikingSessionRoutingRuntime } from "./plugin/openviking-session-routing-runtime.js";
 import { registerOpenVikingToolResultTools } from "./plugin/openviking-tool-result-tools.js";
-import { boundTraceQuery, createMemoryStoreTempSessionId, createTraceId, extractToolSenderId, inferRecallResourceType, makeBypassedToolResult, previewText, } from "./plugin/openviking-runtime-utils.js";
-import { formatMessageFaithful, toRoleId } from "./services/context-message-adapter.js";
+import { boundTraceQuery, createMemoryStoreTempSessionId, createTraceId, inferRecallResourceType, makeBypassedToolResult, previewText, } from "./plugin/openviking-runtime-utils.js";
+import { formatMessageFaithful } from "./services/context-message-adapter.js";
 import { clampScore, postProcessMemories, pickMemoriesForInjection, } from "./memory-ranking.js";
 import { createMemoryOpenVikingContextEngine, } from "./context-engine.js";
 import { openClawSessionRefToOvStorageId, openClawSessionToOvStorageId, } from "./routing/identity-routing.js";
@@ -80,6 +80,7 @@ const contextEnginePlugin = {
             logger: api.logger,
         });
         const { rememberSessionAgentId, resolveAgentId, resolvePluginSessionRouting, toQueryConfigContext, } = createOpenVikingSessionRoutingRuntime({
+            peerRole: cfg.peer_role,
             peerPrefix: cfg.peer_prefix,
             logFindRequests: cfg.logFindRequests,
             logger: api.logger,
@@ -182,8 +183,7 @@ const contextEnginePlugin = {
             getClient,
             normalizeSessionId: openClawSessionRefToOvStorageId,
             createTempSessionId: createMemoryStoreTempSessionId,
-            extractSenderId: extractToolSenderId,
-            toRoleId,
+            peerRole: cfg.peer_role,
             resolvePluginSessionRouting,
             isBypassedSession,
             makeBypassedToolResult,

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

@@ -55,7 +55,6 @@ export function registerOpenVikingArchiveTools(deps) {
                 const result = await client.grepSessionArchives(ovSessionId, escapedQuery, {
                     archiveId,
                     caseInsensitive: true,
-                    agentId,
                 });
                 const traceResults = (result.matches ?? []).slice(0, deps.traceRecallMaxResultsPerSearch).map((match) => ({
                     uri: match.uri,
@@ -175,7 +174,7 @@ export function registerOpenVikingArchiveTools(deps) {
             }
             try {
                 const client = await deps.getClient();
-                const detail = await client.getSessionArchive(session.ovSessionId, archiveId, session.agentId);
+                const detail = await client.getSessionArchive(session.ovSessionId, archiveId);
                 const header = [
                     `## ${detail.archive_id}`,
                     detail.abstract ? `**Summary**: ${detail.abstract}` : "",

package/dist/plugin/openviking-command-definitions.js

@@ -124,7 +124,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseAddResourceCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.addResourceOpenViking(input, session.agentId));
+                    return toCommandResult(await deps.addResourceOpenViking(input, session.actorPeerId));
                 }
                 catch (err) {
                     return { text: `OpenViking add resource failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -142,7 +142,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseAddSkillCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.addSkillOpenViking(input, session.agentId));
+                    return toCommandResult(await deps.addSkillOpenViking(input, session.actorPeerId));
                 }
                 catch (err) {
                     return { text: `OpenViking add skill failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -160,7 +160,7 @@ export function createOpenVikingCommandDefinitions(deps) {
                     }
                     const session = deps.resolvePluginSessionRouting(ctx);
                     const input = deps.parseOVSearchCommandArgs(ctx.args ?? "");
-                    return toCommandResult(await deps.searchOpenViking(input, session.agentId, session));
+                    return toCommandResult(await deps.searchOpenViking(input, session.actorPeerId, session));
                 }
                 catch (err) {
                     return { text: `OpenViking search failed: ${err instanceof Error ? err.message : String(err)}` };

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

@@ -41,7 +41,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 +212,7 @@ const contextEnginePlugin = {
       resolvePluginSessionRouting,
       toQueryConfigContext,
     } = createOpenVikingSessionRoutingRuntime({
+      peerRole: cfg.peer_role,
       peerPrefix: cfg.peer_prefix,
       logFindRequests: cfg.logFindRequests,
       logger: api.logger,
@@ -329,8 +330,7 @@ const contextEnginePlugin = {
       getClient,
       normalizeSessionId: openClawSessionRefToOvStorageId,
       createTempSessionId: createMemoryStoreTempSessionId,
-      extractSenderId: extractToolSenderId,
-      toRoleId,
+      peerRole: cfg.peer_role,
       resolvePluginSessionRouting,
       isBypassedSession,
       makeBypassedToolResult,

package/package.json

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

package/plugin/command-registration.ts

@@ -5,6 +5,8 @@ export type PluginCommandContext = {
   sessionId?: string;
   agentId?: string;
   ovSessionId?: string;
+  senderId?: string;
+  requesterSenderId?: string;
 };
 
 export type CommandResult = {