@openviking/openclaw-plugin 2026.6.18 → 2026.7.15

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;
@@ -71,7 +75,7 @@ export function registerOpenVikingMemoryTools(deps: OpenVikingMemoryToolsDeps):
       name: "memory_store",
       label: "Memory Store (OpenViking)",
       description:
-        "Store text in OpenViking memory pipeline by writing to a session and running memory extraction.",
+        "Store text in OpenViking memory pipeline by writing to a session and running memory extraction. Use when the user explicitly asks to remember, save, or store an important long-term fact, preference, project, or decision; automatic capture is threshold/commit dependent.",
       parameters: Type.Object({
         text: Type.String({ description: "Information to store as memory source text" }),
         role: Type.Optional(Type.String({ description: "Session role, default user" })),
@@ -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/query-config.ts

@@ -231,7 +231,13 @@ export class RuntimeQueryConfigStore {
     const { params, warnings } = normalizeRuntimeQueryParams(patch);
     const key = this.keyForScope(scope, ctx);
     const bucket = scope === "claw" ? this.data.claws : this.data.sessions;
-    bucket[key] = { params, updatedAt: Date.now(), updatedBy: "command", peerId: ctx.peerId };
+    const previous = bucket[key];
+    bucket[key] = {
+      params: { ...(previous?.params ?? {}), ...params },
+      updatedAt: Date.now(),
+      updatedBy: "command",
+      peerId: ctx.peerId,
+    };
     this.data.updatedAt = Date.now();
     await this.persist();
     return { warnings };

package/request-headers.ts

@@ -0,0 +1,29 @@
+export type OpenVikingRequestHeaders = Record<string, string>;
+
+export type ResolveOpenVikingRequestHeadersOptions = {
+  headers?: unknown;
+};
+
+export function resolveOpenVikingRequestHeaders(
+  options: ResolveOpenVikingRequestHeadersOptions = {},
+): OpenVikingRequestHeaders {
+  return cleanOpenVikingRequestHeaders(options.headers);
+}
+
+export function cleanOpenVikingRequestHeaders(headers: unknown): OpenVikingRequestHeaders {
+  if (headers === undefined || headers === null) {
+    return {};
+  }
+  if (typeof headers !== "object" || Array.isArray(headers)) {
+    throw new Error("openviking request headers must be an object");
+  }
+
+  const out: OpenVikingRequestHeaders = {};
+  for (const [key, value] of Object.entries(headers as Record<string, unknown>)) {
+    if (typeof value !== "string") {
+      throw new Error(`openviking request header ${key} must be a string`);
+    }
+    out[key] = value;
+  }
+  return out;
+}

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;
@@ -123,12 +128,15 @@ export type AfterTurnOpenVikingSessionParams = {
   messages?: AgentMessage[];
   prePromptMessageCount?: number;
   isHeartbeat?: boolean;
+  /** Model context window in tokens; the auto-commit threshold is a fraction of this. */
+  tokenBudget: number;
   runtimeContext?: Record<string, unknown>;
   cfg: {
     autoCapture: boolean;
-    commitTokenThreshold: number;
+    commitTokenThresholdRatio: number;
     commitKeepRecentCount: number;
     logFindRequests: boolean;
+    peer_role?: OpenVikingPeerRole;
   };
   getClient: () => Promise<AfterTurnClient>;
   logger: ContextEngineLifecycleLogger;
@@ -175,7 +183,6 @@ function sleep(ms: number): Promise<void> {
 async function pollPhase2ExtractionOutcome(
   client: AfterTurnClient,
   taskId: string,
-  agentId: string,
   logger: ContextEngineLifecycleLogger,
   sessionLabel: string,
 ): Promise<void> {
@@ -183,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;
       });
@@ -338,7 +345,6 @@ export async function commitOpenVikingSession({
   sessionKey,
   getClient,
   logger,
-  resolveAgentId,
   rememberSessionAgentId,
   isBypassedSession,
 }: CommitOpenVikingSessionParams): Promise<boolean> {
@@ -356,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);
@@ -404,6 +408,11 @@ function assemblePassthrough(
   return { messages: liveMessages, estimatedTokens: originalTokens };
 }
 
+function isSessionNotFoundError(err: unknown): boolean {
+  const errorMessage = String(err);
+  return errorMessage.includes("[NOT_FOUND]") && errorMessage.includes("Session not found");
+}
+
 export async function assembleOpenVikingSession({
   sessionId,
   sessionKey,
@@ -485,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,
@@ -496,6 +510,7 @@ export async function assembleOpenVikingSession({
         queryConfig,
         client,
         agentId,
+        actorPeerId,
         queryText: recallQuery.query,
         logger,
         verbose: (message) => logger.info(message),
@@ -546,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;
@@ -625,6 +638,27 @@ export async function assembleOpenVikingSession({
       ...(instruction.text ? { systemPromptAddition: instruction.text } : {}),
     };
   } catch (err) {
+    if (isSessionNotFoundError(err)) {
+      const errorMessage = String(err);
+      logger.info(
+        `openviking: assemble skipped because OV session does not exist ` +
+          `(session=${ovSessionId}, tokenBudget=${tokenBudget}, agentId=${resolveAgentId(ovSessionId)})`,
+      );
+      return assemblePassthrough({
+        diag,
+        ovSessionId,
+        reason: "session_not_found",
+        liveMessages: messages,
+        originalTokens,
+        extra: {
+          error: errorMessage,
+          tokenBudget,
+          agentId: resolveAgentId(ovSessionId),
+          senderIdFound: sender.found,
+          senderId: sender.senderId ?? null,
+        },
+      });
+    }
     logger.warn?.(
       `openviking: assemble failed for session=${ovSessionId}, ` +
         `tokenBudget=${tokenBudget}, agentId=${resolveAgentId(ovSessionId)}: ${String(err)}`,
@@ -688,7 +722,7 @@ function extractRuntimeAgentId(runtimeContext: Record<string, unknown> | undefin
 }
 
 function isToolOnlyMessage(msg: ExtractedTurnMessage): boolean {
-  return msg.role === "user" && msg.parts.length > 0 && msg.parts.every((part) => part.type === "tool");
+  return msg.role === "assistant" && msg.parts.length > 0 && msg.parts.every((part) => part.type === "tool");
 }
 
 function coalesceConsecutiveToolMessages(messages: ExtractedTurnMessage[]): ExtractedTurnMessage[] {
@@ -705,7 +739,7 @@ function coalesceConsecutiveToolMessages(messages: ExtractedTurnMessage[]): Extr
   for (const msg of messages) {
     if (isToolOnlyMessage(msg)) {
       if (!pendingTools) {
-        pendingTools = { role: "user", parts: [] };
+        pendingTools = { role: "assistant", parts: [] };
       }
       pendingTools.parts.push(...msg.parts);
       continue;
@@ -753,6 +787,7 @@ export async function afterTurnOpenVikingSession({
   messages: rawMessages,
   prePromptMessageCount,
   isHeartbeat,
+  tokenBudget,
   runtimeContext,
   cfg,
   getClient,
@@ -870,21 +905,30 @@ 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;
 
-    if (pendingTokens < cfg.commitTokenThreshold) {
+    const commitTokenThreshold = Math.floor(tokenBudget * cfg.commitTokenThresholdRatio);
+
+    if (pendingTokens < commitTokenThreshold) {
       diag("afterTurn_skip", ovSessionId, {
         reason: "below_threshold",
         pendingTokens,
-        commitTokenThreshold: cfg.commitTokenThreshold,
+        commitTokenThreshold,
+        commitTokenThresholdRatio: cfg.commitTokenThresholdRatio,
+        tokenBudget,
         senderIdFound: sender.found,
         senderId: sender.senderId ?? null,
       });
@@ -893,7 +937,6 @@ export async function afterTurnOpenVikingSession({
 
     const commitResult = await client.commitSession(ovSessionId, {
       wait: false,
-      agentId,
       keepRecentCount: cfg.commitKeepRecentCount,
     });
     logger.info(
@@ -904,7 +947,9 @@ export async function afterTurnOpenVikingSession({
 
     diag("afterTurn_commit", ovSessionId, {
       pendingTokens,
-      commitTokenThreshold: cfg.commitTokenThreshold,
+      commitTokenThreshold,
+      commitTokenThresholdRatio: cfg.commitTokenThresholdRatio,
+      tokenBudget,
       status: commitResult.status,
       archived: commitResult.archived ?? false,
       taskId: commitResult.task_id ?? null,
@@ -917,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)}`);
@@ -998,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;
       }
@@ -1018,7 +1063,6 @@ export async function compactOpenVikingSession({
     );
     const commitResult = await client.commitSession(ovSessionId, {
       wait: true,
-      agentId,
       keepRecentCount: 0,
     });
     const memCount = totalExtractedMemories(commitResult.memories_extracted);
@@ -1094,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),
@@ -1183,7 +1227,7 @@ export async function compactOpenVikingSession({
     };
   } catch (err) {
     const errorMessage = String(err);
-    if (errorMessage.includes("[NOT_FOUND]") && errorMessage.includes("Session not found")) {
+    if (isSessionNotFoundError(err)) {
       logger.info(
         `openviking: compact skipped because OV session does not exist ` +
           `(session=${ovSessionId}, agentId=${agentId})`,