@openviking/openclaw-plugin 2026.7.11 → 2026.7.15

package/plugin/openviking-archive-tools.ts

@@ -26,7 +26,7 @@ export type OpenVikingArchiveClient = {
   grepSessionArchives: (
     sessionId: string,
     pattern: string,
-    options: { archiveId?: string; caseInsensitive: boolean; agentId?: string },
+    options: { archiveId?: string; caseInsensitive: boolean },
   ) => Promise<{
     count?: number;
     matches?: OpenVikingArchiveMatch[];
@@ -34,7 +34,6 @@ export type OpenVikingArchiveClient = {
   getSessionArchive: (
     sessionId: string,
     archiveId: string,
-    agentId?: string,
   ) => Promise<{
     archive_id: string;
     abstract?: string;
@@ -128,7 +127,6 @@ export function registerOpenVikingArchiveTools(deps: OpenVikingArchiveToolsDeps)
           const result = await client.grepSessionArchives(ovSessionId, escapedQuery, {
             archiveId,
             caseInsensitive: true,
-            agentId,
           });
           const traceResults: RecallTraceResult[] = (result.matches ?? []).slice(0, deps.traceRecallMaxResultsPerSearch).map((match) => ({
             uri: match.uri,
@@ -263,7 +261,6 @@ export function registerOpenVikingArchiveTools(deps: OpenVikingArchiveToolsDeps)
         const detail = await client.getSessionArchive(
           session.ovSessionId,
           archiveId,
-          session.agentId,
         );
 
         const header = [

package/plugin/openviking-command-definitions.ts

@@ -6,6 +6,7 @@ export type OpenVikingCommandSession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OpenVikingCommandToolResult = {
@@ -217,7 +218,7 @@ export function createOpenVikingCommandDefinitions(
           }
           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)}` };
         }
@@ -234,7 +235,7 @@ export function createOpenVikingCommandDefinitions(
           }
           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)}` };
         }
@@ -251,7 +252,7 @@ export function createOpenVikingCommandDefinitions(
           }
           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/plugin/openviking-import-tools.ts

@@ -12,6 +12,7 @@ export type OpenVikingImportToolContext = {
   sessionId?: string;
   agentId?: string;
   senderId?: string;
+  requesterSenderId?: string;
 };
 
 export type OpenVikingImportSession = {
@@ -19,6 +20,7 @@ export type OpenVikingImportSession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OpenVikingImportClient = {
@@ -80,7 +82,7 @@ export function registerOpenVikingImportTools(deps: OpenVikingImportToolsDeps):
             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" as const, text: formatResourceImportText(result) }],
             details: {
@@ -118,7 +120,7 @@ export function registerOpenVikingImportTools(deps: OpenVikingImportToolsDeps):
           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" as const, text: formatSkillImportText(result) }],
           details: {

package/plugin/openviking-memory-recall-tools.ts

@@ -15,6 +15,7 @@ export type OpenVikingMemoryRecallToolContext = {
   sessionId?: string;
   agentId?: string;
   senderId?: string;
+  requesterSenderId?: string;
 };
 
 export type OpenVikingMemoryRecallSession = {
@@ -22,6 +23,7 @@ export type OpenVikingMemoryRecallSession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OpenVikingMemoryRecallClient = {
@@ -163,7 +165,7 @@ export function registerOpenVikingMemoryRecallTools(
         const recallClient = await deps.getClient();
         if (deps.cfg.logFindRequests) {
           deps.logger.info?.(
-            `openviking: memory_recall X-OpenViking-Actor-Peer="${session.agentId}" ` +
+            `openviking: memory_recall X-OpenViking-Actor-Peer="${session.actorPeerId ?? "none"}" ` +
               `(plugin defaultAgentId="${recallClient.getDefaultAgentId()}" is unused when session context is present)`,
           );
         }
@@ -177,7 +179,7 @@ export function registerOpenVikingMemoryRecallTools(
             targetUri,
             limit: requestLimit,
             scoreThreshold: 0,
-            actorPeerId: session.agentId,
+            actorPeerId: session.actorPeerId,
           },
         );
           const traceResults = [
@@ -207,7 +209,7 @@ export function registerOpenVikingMemoryRecallTools(
                 limit: requestLimit,
                 scoreThreshold: 0,
                 contextType: search.contextType,
-                actorPeerId: session.agentId,
+                actorPeerId: session.actorPeerId,
               },
             ),
           ));
@@ -319,7 +321,7 @@ export function registerOpenVikingMemoryRecallTools(
         }
         const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(
           memories,
-          (uri) => recallClient.read(uri, session.agentId),
+          (uri) => recallClient.read(uri, session.actorPeerId),
           {
             recallPreferAbstract: false,
             recallMaxInjectedChars: queryConfig.maxInjectedChars,

package/plugin/openviking-memory-tools.ts

@@ -2,6 +2,10 @@ import { Type } from "@sinclair/typebox";
 
 import type { CommitSessionResult, FindResultItem } from "../client.js";
 import { clampScore, postProcessMemories } from "../memory-ranking.js";
+import {
+  resolveOpenVikingMessagePeerId,
+  type OpenVikingPeerRole,
+} from "../routing/identity-routing.js";
 import { isMemoryUri } from "../routing/memory-uri.js";
 
 export type OpenVikingMemoryToolContext = {
@@ -17,6 +21,7 @@ export type OpenVikingMemorySession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OpenVikingMemoryClient = {
@@ -30,7 +35,7 @@ export type OpenVikingMemoryClient = {
   ) => Promise<void>;
   commitSession: (
     sessionId: string,
-    options: { wait: true; agentId: string; keepRecentCount: number },
+    options: { wait: true; agentId?: string; keepRecentCount: number },
   ) => Promise<CommitSessionResult>;
   deleteUri: (uri: string, agentId?: string) => Promise<void>;
   find: (
@@ -45,8 +50,7 @@ export type OpenVikingMemoryToolsDeps = {
   getClient: () => Promise<OpenVikingMemoryClient>;
   normalizeSessionId: (sessionId: string) => string;
   createTempSessionId: () => string;
-  extractSenderId: (ctx?: OpenVikingMemoryToolContext) => string | undefined;
-  toRoleId: (senderId?: string) => string | undefined;
+  peerRole: OpenVikingPeerRole;
   resolvePluginSessionRouting: (ctx?: OpenVikingMemoryToolContext) => OpenVikingMemorySession;
   isBypassedSession: (ctx?: OpenVikingMemoryToolContext) => boolean;
   makeBypassedToolResult: (toolName: string) => unknown;
@@ -107,18 +111,22 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
             sessionId = deps.createTempSessionId();
             usedTempSession = true;
           }
-          const roleId = role === "user" ? deps.toRoleId(deps.extractSenderId(ctx)) : undefined;
+          const peerId = resolveOpenVikingMessagePeerId({
+            peerRole: deps.peerRole,
+            role,
+            personPeerId: session.actorPeerId,
+            assistantPeerId: session.actorPeerId,
+          });
           await client.addSessionMessage(
             sessionId,
             role,
             [{ type: "text", text }],
-            session.agentId,
             undefined,
-            roleId,
+            undefined,
+            peerId,
           );
           const commitResult = await client.commitSession(sessionId, {
             wait: true,
-            agentId: session.agentId,
             keepRecentCount: 0,
           });
           const memoriesCount = totalCommitMemories(commitResult);
@@ -216,7 +224,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
               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 },
@@ -252,7 +260,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
             limit: requestLimit,
             scoreThreshold: 0,
           },
-          session.agentId,
+          session.actorPeerId,
         );
         const candidates = postProcessMemories(result.memories ?? [], {
           limit: requestLimit,
@@ -272,7 +280,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
         }
         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/plugin/openviking-query-runtime.ts

@@ -445,7 +445,7 @@ export function createOpenVikingQueryRuntime<TQueryConfigContext>(deps: OpenViki
       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 is RecallResourceType => resourceType !== "archive"))],

package/plugin/openviking-query-tools.ts

@@ -5,6 +5,7 @@ export type OpenVikingQueryToolContext = {
   sessionId?: string;
   agentId?: string;
   senderId?: string;
+  requesterSenderId?: string;
 };
 
 export type OpenVikingQuerySession = {
@@ -12,6 +13,7 @@ export type OpenVikingQuerySession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OVSearchInput = {
@@ -74,7 +76,7 @@ export function registerOpenVikingQueryTools(deps: OpenVikingQueryToolsDeps): vo
           query: String((params as { query?: unknown }).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" },
@@ -99,7 +101,7 @@ export function registerOpenVikingQueryTools(deps: OpenVikingQueryToolsDeps): vo
         const session = deps.resolvePluginSessionRouting(ctx);
         return deps.readOpenVikingContent({
           uri: String((params as { uri?: unknown }).uri ?? ""),
-        }, session.agentId);
+        }, session.actorPeerId);
       },
     }),
     { name: "ov_read" },
@@ -125,7 +127,7 @@ export function registerOpenVikingQueryTools(deps: OpenVikingQueryToolsDeps): vo
         const uris = Array.isArray((params as { uris?: unknown }).uris)
           ? (params as { uris: unknown[] }).uris.map((uri) => String(uri))
           : [];
-        return deps.multiReadOpenVikingContent({ uris }, session.agentId);
+        return deps.multiReadOpenVikingContent({ uris }, session.actorPeerId);
       },
     }),
     { name: "ov_multi_read" },
@@ -153,7 +155,7 @@ export function registerOpenVikingQueryTools(deps: OpenVikingQueryToolsDeps): vo
           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/plugin/openviking-recall-trace-runtime.ts

@@ -26,6 +26,7 @@ export type OpenVikingRecallTraceSession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type OpenVikingRecallTraceQueryResult = {
@@ -248,11 +249,11 @@ export function createOpenVikingRecallTraceRuntime(deps: OpenVikingRecallTraceRu
       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?: RecallTraceRouteRequest) => {
@@ -298,7 +299,7 @@ export function createOpenVikingRecallTraceRuntime(deps: OpenVikingRecallTraceRu
     }
     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/plugin/openviking-recall-trace-tools.ts

@@ -11,6 +11,7 @@ export type OpenVikingRecallTraceToolContext = {
   sessionId?: string;
   agentId?: string;
   senderId?: string;
+  requesterSenderId?: string;
 };
 
 export type OpenVikingRecallTraceSession = {
@@ -18,6 +19,7 @@ export type OpenVikingRecallTraceSession = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export type RecallTraceToolInput = {

package/plugin/openviking-session-routing-runtime.ts

@@ -2,6 +2,9 @@ import type { QueryConfigContext } from "../query-config.js";
 import {
   createSessionAgentResolver,
   openClawSessionToOvStorageId,
+  resolveOpenVikingActorPeerId,
+  sanitizeOpenVikingPeerId,
+  type OpenVikingPeerRole,
 } from "../routing/identity-routing.js";
 
 type Logger = {
@@ -10,6 +13,8 @@ type Logger = {
 
 export type SessionAgentLookup = {
   agentId?: string;
+  senderId?: string;
+  requesterSenderId?: string;
   sessionId?: string;
   sessionKey?: string;
   ovSessionId?: string;
@@ -20,13 +25,16 @@ export type PluginSessionRouting = {
   sessionKey?: string;
   ovSessionId?: string;
   agentId: string;
+  actorPeerId?: string;
 };
 
 export function createOpenVikingSessionRoutingRuntime(options: {
+  peerRole?: OpenVikingPeerRole;
   peerPrefix: string;
   logFindRequests: boolean;
   logger: Logger;
 }) {
+  const peerRole = options.peerRole ?? "assistant";
   const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);
 
   const rememberSessionAgentId = (ctx: SessionAgentLookup) => {
@@ -81,11 +89,17 @@ export function createOpenVikingSessionRoutingRuntime(options: {
     };
     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,
+      }),
     };
   };
 

package/plugin/openviking-tool-result-tools.ts

@@ -27,7 +27,6 @@ export type OpenVikingToolResultClient = {
     sessionId: string,
     toolResultId: string,
     options: { offset: number; limit: number; includeMetadata: boolean },
-    agentId?: string,
   ) => Promise<{
     content: string;
     offset: number;
@@ -42,7 +41,6 @@ export type OpenVikingToolResultClient = {
     toolResultId: string,
     query: string,
     options: { limit: number; contextChars: number },
-    agentId?: string,
   ) => Promise<{
     tool_result_id: string;
     matches?: Array<{ offset: number; snippet: string }>;
@@ -50,7 +48,6 @@ export type OpenVikingToolResultClient = {
   listToolResults: (
     sessionId: string,
     options: { toolName?: string; limit: number },
-    agentId?: string,
   ) => Promise<{
     tool_results?: Array<{
       storage_uri?: string;
@@ -180,7 +177,6 @@ export function registerOpenVikingToolResultTools({
             session.ovSessionId,
             parsed.toolResultId,
             { offset, limit, includeMetadata: true },
-            session.agentId,
           );
           const returnedChars = result.content.length;
           const nextOffset = result.offset + returnedChars;
@@ -281,7 +277,6 @@ export function registerOpenVikingToolResultTools({
             parsed.toolResultId,
             query,
             { limit, contextChars },
-            session.agentId,
           );
           const matches = result.matches ?? [];
           const text = matches.length
@@ -354,7 +349,6 @@ export function registerOpenVikingToolResultTools({
           const result = await client.listToolResults(
             session.ovSessionId,
             { toolName, limit },
-            session.agentId,
           );
           const items = result.tool_results ?? [];
           const text = items.length

package/routing/identity-routing.ts

@@ -15,6 +15,47 @@ export type SessionAgentLookup = {
   ovSessionId?: string;
 };
 
+export type OpenVikingPeerRole = "none" | "assistant" | "person";
+
+export function sanitizeOpenVikingPeerId(raw?: string): string | undefined {
+  const normalized = raw
+    ?.trim()
+    .replace(/[^a-zA-Z0-9_-]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .replace(/_+/g, "_");
+  return normalized || undefined;
+}
+
+export function resolveOpenVikingMessagePeerId(params: {
+  peerRole: OpenVikingPeerRole;
+  role?: string;
+  personPeerId?: string;
+  assistantPeerId?: string;
+}): string | undefined {
+  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: {
+  peerRole: OpenVikingPeerRole;
+  personPeerId?: string;
+  assistantPeerId?: string;
+}): string | undefined {
+  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;
+}
+
 export type SessionAgentResolveBranch =
   | "session_resolved"
   | "config_only_fallback"

package/routing/memory-uri.ts

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

package/services/context-lifecycle-service.ts

@@ -3,7 +3,13 @@ import { DEFAULT_PHASE2_POLL_TIMEOUT_MS, type OpenVikingClient, type OVMessage }
 import type { EffectiveQueryConfig } from "../query-config.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,
+  type OpenVikingPeerRole,
+} from "../routing/identity-routing.js";
 import { extractNewTurnMessages } from "../text-utils.js";
 import { estimateAgentMessageTokens, estimateTextTokens } from "../token-estimator.js";
 import {
@@ -26,7 +32,6 @@ export type CommitOpenVikingSessionParams = {
   sessionKey?: string;
   getClient: () => Promise<Pick<OpenVikingClient, "commitSession">>;
   logger: ContextEngineLifecycleLogger;
-  resolveAgentId: (sessionId: string, sessionKey?: string, ovSessionId?: string) => string;
   rememberSessionAgentId?: (ctx: {
     agentId?: string;
     sessionId?: string;
@@ -131,6 +136,7 @@ export type AfterTurnOpenVikingSessionParams = {
     commitTokenThresholdRatio: number;
     commitKeepRecentCount: number;
     logFindRequests: boolean;
+    peer_role?: OpenVikingPeerRole;
   };
   getClient: () => Promise<AfterTurnClient>;
   logger: ContextEngineLifecycleLogger;
@@ -177,7 +183,6 @@ function sleep(ms: number): Promise<void> {
 async function pollPhase2ExtractionOutcome(
   client: AfterTurnClient,
   taskId: string,
-  agentId: string,
   logger: ContextEngineLifecycleLogger,
   sessionLabel: string,
 ): Promise<void> {
@@ -185,7 +190,7 @@ async function pollPhase2ExtractionOutcome(
   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;
       });
@@ -340,7 +345,6 @@ export async function commitOpenVikingSession({
   sessionKey,
   getClient,
   logger,
-  resolveAgentId,
   rememberSessionAgentId,
   isBypassedSession,
 }: CommitOpenVikingSessionParams): Promise<boolean> {
@@ -358,10 +362,8 @@ export async function commitOpenVikingSession({
       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);
@@ -492,6 +494,11 @@ export async function assembleOpenVikingSession({
       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,
@@ -503,6 +510,7 @@ export async function assembleOpenVikingSession({
         queryConfig,
         client,
         agentId,
+        actorPeerId,
         queryText: recallQuery.query,
         logger,
         verbose: (message) => logger.info(message),
@@ -553,9 +561,7 @@ export async function assembleOpenVikingSession({
 
   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;
@@ -899,14 +905,19 @@ export async function afterTurnOpenVikingSession({
           ovSessionId,
           msg.role,
           ovParts,
-          agentId,
+          undefined,
           createdAt,
-          msg.role === "user" ? senderRoleId : undefined,
+          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);
@@ -926,7 +937,6 @@ export async function afterTurnOpenVikingSession({
 
     const commitResult = await client.commitSession(ovSessionId, {
       wait: false,
-      agentId,
       keepRecentCount: cfg.commitKeepRecentCount,
     });
     logger.info(
@@ -952,7 +962,7 @@ export async function afterTurnOpenVikingSession({
         `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) {
     logger.warn?.(`openviking: afterTurn failed: ${String(err)}`);
@@ -1033,7 +1043,7 @@ export async function compactOpenVikingSession({
   let preCommitEstimatedTokens: number | undefined;
   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;
       }
@@ -1053,7 +1063,6 @@ export async function compactOpenVikingSession({
     );
     const commitResult = await client.commitSession(ovSessionId, {
       wait: true,
-      agentId,
       keepRecentCount: 0,
     });
     const memCount = totalExtractedMemories(commitResult.memories_extracted);
@@ -1129,7 +1138,7 @@ export async function compactOpenVikingSession({
     let contextFetchError: string | undefined;
 
     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),