@openviking/openclaw-plugin 2026.9.4 → 2026.9.8-1

package/config.ts

@@ -30,7 +30,8 @@ export type OpenVikingSecretRef =
 export type MemoryOpenVikingConfig = {
   mode?: "remote";
   baseUrl?: string;
-  peer_role?: "none" | "assistant" | "person";
+  /** `person` is a legacy alias for `sender`. */
+  peer_role?: "none" | "assistant" | "sender" | "person";
   peer_prefix?: string;
   apiKey?: string | OpenVikingSecretRef;
   /** Optional HTTP headers merged into every OpenViking request. */
@@ -127,10 +128,12 @@ export type MemoryOpenVikingConfig = {
 
 /** Runtime config after memoryOpenVikingConfigSchema.parse() has applied defaults. */
 export type ParsedMemoryOpenVikingConfig = Required<
-  Omit<MemoryOpenVikingConfig, "agentExperience" | "recallTargetTypes" | "apiKey">
+  Omit<MemoryOpenVikingConfig, "agentExperience" | "recallTargetTypes" | "apiKey" | "peer_role">
 > & {
   /** parse() resolves SecretRef values, so the runtime shape is always a plain string. */
   apiKey: string;
+  /** Runtime uses the canonical name; legacy `person` input normalizes to `sender`. */
+  peer_role: "none" | "assistant" | "sender";
   agentExperience: Required<NonNullable<MemoryOpenVikingConfig["agentExperience"]>>;
   recallTargetTypes: Array<"resource" | "user" | "agent">;
 };
@@ -152,7 +155,7 @@ const DEFAULT_COMMIT_TOKEN_THRESHOLD_RATIO = 0.5;
 const DEFAULT_COMMIT_KEEP_RECENT_COUNT = 10;
 const DEFAULT_BYPASS_SESSION_PATTERNS: string[] = [];
 const DEFAULT_EMIT_STANDARD_DIAGNOSTICS = false;
-const DEFAULT_PEER_ROLE = "assistant" as const;
+const DEFAULT_PEER_ROLE = "none" as const;
 const DEFAULT_PEER_PREFIX = "";
 const DEFAULT_TRACE_RECALL_DIR = "~/.openclaw/openviking/recall-traces";
 const DEFAULT_TRACE_RECALL_RETENTION_DAYS = 14;
@@ -292,16 +295,23 @@ function resolveSecret(
   }
 }
 
-function resolvePeerRole(configured: unknown) {
+function resolvePeerRole(configured: unknown): "none" | "assistant" | "sender" {
   if (typeof configured === "string") {
     const role = configured.trim().toLowerCase();
-    if (role === "none" || role === "assistant" || role === "person") {
+    if (role === "none" || role === "assistant" || role === "sender") {
       return role;
     }
-    throw new Error(`openviking peer_role must be "none", "assistant", or "person"`);
+    if (role === "person") {
+      return "sender";
+    }
+    throw new Error(
+      `openviking peer_role must be "none", "assistant", or "sender" (legacy alias: "person")`,
+    );
   }
   if (configured !== undefined) {
-    throw new Error(`openviking peer_role must be "none", "assistant", or "person"`);
+    throw new Error(
+      `openviking peer_role must be "none", "assistant", or "sender" (legacy alias: "person")`,
+    );
   }
   return DEFAULT_PEER_ROLE;
 }
@@ -776,14 +786,17 @@ export const memoryOpenVikingConfigSchema = {
       help: "HTTP URL when mode is remote (or use ${OPENVIKING_BASE_URL})",
     },
     peer_role: {
-      label: "Peer Role",
+      label: "Memory Scope (peer_role)",
       placeholder: DEFAULT_PEER_ROLE,
-      help: 'Controls which session messages get peer_id: "none", "assistant", or "person".',
+      help:
+        'Where peer-scoped memories are stored. "none" (default): viking://user/<user_id>/memories. ' +
+        '"assistant": viking://user/<user_id>/peers/<assistant_id>/memories. ' +
+        '"sender": viking://user/<user_id>/peers/<sender_id>/memories. Legacy "person" is accepted as "sender".',
     },
     peer_prefix: {
       label: "Peer Prefix",
       placeholder: "optional-prefix",
-      help: "Optional prefix applied to assistant peer_id values derived from OpenClaw runtime agent IDs.",
+      help: 'Only used when Memory Scope is "assistant". Prefix added to the peer id derived from the OpenClaw agent id.',
     },
     apiKey: {
       label: "OpenViking API Key",
@@ -894,7 +907,7 @@ export const memoryOpenVikingConfigSchema = {
     bypassSessionPatterns: {
       label: "Bypass Session Patterns",
       placeholder: "agent:*:cron:**",
-      help: "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
+      help: "Completely bypass OpenViking for matching session keys (no capture, recall, or commit; compaction falls back to OpenClaw's native compactor). Use * within one segment and ** across segments.",
       advanced: true,
     },
     commitTokenThresholdRatio: {

package/context-engine.ts

@@ -1,5 +1,5 @@
 import type { OpenVikingClient } from "./client.js";
-import type { MemoryOpenVikingConfig } from "./config.js";
+import type { ParsedMemoryOpenVikingConfig } from "./config.js";
 import type { RuntimeQueryConfigStore } from "./query-config.js";
 import {
   AUTO_RECALL_SOURCE_MARKER,
@@ -19,6 +19,7 @@ import {
   compactOpenVikingSession,
   commitOpenVikingSession,
 } from "./services/context-lifecycle-service.js";
+import { loadRuntimeCompactionDelegate } from "./plugin/openclaw-runtime-compaction.js";
 
 type ContextEngineInfo = {
   id: string;
@@ -248,7 +249,7 @@ export function createMemoryOpenVikingContextEngine(params: {
   id: string;
   name: string;
   version?: string;
-  cfg: Required<MemoryOpenVikingConfig>;
+  cfg: ParsedMemoryOpenVikingConfig;
   logger: Logger;
   getClient: () => Promise<OpenVikingClient>;
   /** Extra args help match hook-populated routing when OpenClaw provides sessionKey / OV session id. */
@@ -437,6 +438,10 @@ export function createMemoryOpenVikingContextEngine(params: {
         logger,
         resolveAgentId,
         isBypassedSession,
+        runtimeCompact: async () => {
+          const delegate = await loadRuntimeCompactionDelegate();
+          return delegate ? delegate(compactParams) : undefined;
+        },
         diag,
       });
     },

package/dist/client.js

@@ -1,10 +1,3 @@
-import { randomUUID } from "node:crypto";
-import { once } from "node:events";
-import { createWriteStream } from "node:fs";
-import { mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { basename, dirname, join, relative } from "node:path";
-import { Zip, ZipDeflate } from "fflate";
 import { defaultHttpTransport } from "./adapters/http-transport.js";
 import { defaultResourcePackager, } from "./adapters/resource-packager.js";
 import { buildContextSearchBody, contextRequestTimeoutMs, normalizeContextEntry, } from "./shared/recall-core.mjs";
@@ -17,32 +10,12 @@ const WAIT_REQUEST_TIMEOUT_BUFFER_MS = 5_000;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const MEMORY_URI_PATTERNS = [
-    /^viking:\/\/user\/(?:[^/]+\/)?memories(?:\/|$)/,
-];
-const REMOTE_RESOURCE_PREFIXES = ["http://", "https://", "git@", "ssh://", "git://"];
-export function isMemoryUri(uri) {
-    return MEMORY_URI_PATTERNS.some((pattern) => pattern.test(uri));
-}
-function isRemoteResourceSource(source) {
-    return REMOTE_RESOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
-}
-function toBlobPart(value) {
-    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
-}
 function resolveWaitRequestTimeoutMs(defaultTimeoutMs, waitTimeoutSeconds) {
     const requestedMs = typeof waitTimeoutSeconds === "number" && Number.isFinite(waitTimeoutSeconds) && waitTimeoutSeconds > 0
         ? Math.ceil(waitTimeoutSeconds * 1000) + WAIT_REQUEST_TIMEOUT_BUFFER_MS
         : DEFAULT_WAIT_REQUEST_TIMEOUT_MS;
     return Math.max(defaultTimeoutMs, requestedMs);
 }
-async function cleanupUploadTempPath(path) {
-    if (!path) {
-        return;
-    }
-    await rm(path, { force: true }).catch(() => undefined);
-    await rm(dirname(path), { recursive: true, force: true }).catch(() => undefined);
-}
 export class OpenVikingClient {
     baseUrl;
     apiKey;
@@ -323,61 +296,6 @@ export class OpenVikingClient {
         }
         return result.temp_file_id;
     }
-    async zipDirectoryForUpload(dirPath) {
-        const rootStats = await stat(dirPath);
-        if (!rootStats.isDirectory()) {
-            throw new Error(`Not a directory: ${dirPath}`);
-        }
-        const zipDir = await mkdtemp(join(tmpdir(), "openviking-openclaw-upload-"));
-        const zipPath = join(zipDir, `${basename(dirPath).replace(/[^a-zA-Z0-9._-]/g, "_")}-${randomUUID()}.zip`);
-        const output = createWriteStream(zipPath);
-        const outputClosed = once(output, "close");
-        const outputErrored = once(output, "error").then(([err]) => Promise.reject(err));
-        const zip = new Zip((err, chunk, final) => {
-            if (err) {
-                output.destroy(err);
-                return;
-            }
-            if (chunk?.length) {
-                output.write(Buffer.from(chunk));
-            }
-            if (final) {
-                output.end();
-            }
-        });
-        const walk = async (currentDir) => {
-            const entries = await readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    await walk(fullPath);
-                    continue;
-                }
-                if (!entry.isFile()) {
-                    continue;
-                }
-                const relPath = relative(dirPath, fullPath).replace(/\\/g, "/");
-                if (!relPath || relPath.startsWith("../") || relPath.includes("/../")) {
-                    throw new Error(`Unsafe relative path while zipping: ${relPath}`);
-                }
-                const file = new ZipDeflate(relPath);
-                zip.add(file);
-                file.push(new Uint8Array(await readFile(fullPath)), true);
-            }
-        };
-        try {
-            await walk(dirPath);
-            zip.end();
-            await Promise.race([outputClosed, outputErrored]);
-        }
-        catch (err) {
-            zip.terminate();
-            output.destroy(err);
-            await cleanupUploadTempPath(zipPath);
-            throw err;
-        }
-        return zipPath;
-    }
     async addResource(input, actorPeerId) {
         const pathOrUrl = input.pathOrUrl.trim();
         if (!pathOrUrl) {

package/dist/commands/setup.js

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { getEnv } from "../runtime-utils.js";
-import { cleanOpenVikingRequestHeaders, resolveOpenVikingRequestHeaders, } from "../request-headers.js";
+import { cleanOpenVikingRequestHeaders, } from "../request-headers.js";
+import { createSetupNetworkProbes, } from "../services/setup/probe-service.js";
 const HOME = os.homedir();
 const OPENCLAW_DIR = getEnv("OPENCLAW_STATE_DIR") || path.join(HOME, ".openclaw");
 const DEFAULT_REMOTE_URL = "http://127.0.0.1:1933";
@@ -76,7 +77,7 @@ const CONFIG_KEYS_TO_PRESERVE = [
     "emitStandardDiagnostics",
     "logFindRequests",
 ];
-const DEFAULT_SETUP_PEER_ROLE = "assistant";
+const DEFAULT_SETUP_PEER_ROLE = "none";
 const ALLOWED_RECALL_TARGET_TYPES = ["resource", "user", "agent"];
 function tr(langZh, en, zh) {
     return langZh ? zh : en;
@@ -98,7 +99,9 @@ function normalizePeerRole(value) {
     if (typeof value !== "string")
         return undefined;
     const role = value.trim().toLowerCase();
-    if (role === "none" || role === "assistant" || role === "person")
+    if (role === "person")
+        return "sender";
+    if (role === "none" || role === "assistant" || role === "sender")
         return role;
     return undefined;
 }
@@ -121,7 +124,7 @@ function resolveSetupPeerRole(value) {
     const role = normalizePeerRole(value);
     if (role)
         return role;
-    throw new Error('peer_role must be "none", "assistant", or "person"');
+    throw new Error('peer_role must be "none", "assistant", or "sender" (legacy alias: "person")');
 }
 function normalizeSetupRecallTargetTypes(value) {
     if (value === undefined || value === null || value === "") {
@@ -172,12 +175,17 @@ function preserveCurrentConfig(existing) {
     return config;
 }
 async function askPeerRole(zh, q, defaultValue) {
+    console.log(`  ${tr(zh, "Memory scope — none (default): viking://user/<user_id>/memories, shared across all conversations; " +
+        "assistant: viking://user/<user_id>/peers/<assistant_id>/memories; " +
+        "sender: viking://user/<user_id>/peers/<sender_id>/memories (legacy alias: person).", "记忆归属 —— none（默认）：viking://user/<user_id>/memories，所有对话共享；" +
+        "assistant：viking://user/<user_id>/peers/<assistant_id>/memories；" +
+        "sender：viking://user/<user_id>/peers/<sender_id>/memories（兼容旧值 person）。")}`);
     while (true) {
-        const value = await q(tr(zh, "Peer Role (none/assistant/person)", "Peer Role（none/assistant/person）"), defaultValue);
+        const value = await q(tr(zh, "Memory scope (none/assistant/sender)", "记忆归属（none/assistant/sender）"), defaultValue);
         const role = normalizePeerRole(value);
         if (role)
             return role;
-        console.log(`  ✗ ${tr(zh, 'Peer Role must be "none", "assistant", or "person".', 'Peer Role 必须是 "none"、"assistant" 或 "person"。')}`);
+        console.log(`  ✗ ${tr(zh, 'Memory scope must be "none", "assistant", or "sender" (legacy "person" is also accepted).', '记忆归属必须是 "none"、"assistant" 或 "sender"（也兼容旧值 "person"）。')}`);
     }
 }
 async function askPeerPrefix(zh, q, defaultValue) {
@@ -240,118 +248,11 @@ function formatCompatRange() {
         return `<= ${COMPATIBLE_SERVER_MAX}`;
     return "any";
 }
-async function probeApiKeyType(baseUrl, apiKey, configuredHeaders) {
-    if (!apiKey)
-        return { keyType: "no_key", needsAccountId: false, needsUserId: false, detail: "No API key configured" };
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10_000);
-    const sessionsUrl = `${baseUrl.replace(/\/+$/, "")}/api/v1/sessions?limit=1`;
-    try {
-        const configuredRequestHeaders = resolveOpenVikingRequestHeaders({ headers: configuredHeaders });
-        const headers = {};
-        headers["X-API-Key"] = apiKey;
-        Object.assign(headers, configuredRequestHeaders);
-        const response = await fetch(sessionsUrl, {
-            headers,
-            signal: controller.signal,
-        });
-        if (response.ok) {
-            return { keyType: "user_key", needsAccountId: false, needsUserId: false, detail: "API key has full user context" };
-        }
-        // Server raises InvalidArgumentError (-> HTTP 400) when a ROOT key calls
-        // tenant-scoped endpoints without X-OpenViking-Account / X-OpenViking-User.
-        // 401/403 may also be returned by older versions, FastAPI validation can
-        // surface as 422. Treat all four as candidates for tenant-context errors.
-        if ([400, 401, 403, 422].includes(response.status)) {
-            let body = "";
-            try {
-                body = await response.text();
-            }
-            catch { /* ignore parse errors */ }
-            const lower = body.toLowerCase();
-            const needsAccount = /x-openviking-account|account[_ ]?id|account context|tenant/.test(lower);
-            const needsUser = /x-openviking-user|user[_ ]?id|user context|user key/.test(lower);
-            if (needsAccount || needsUser) {
-                return {
-                    keyType: "root_key",
-                    needsAccountId: needsAccount,
-                    needsUserId: needsUser,
-                    detail: body.slice(0, 200),
-                };
-            }
-            // Body did not name account/user/tenant explicitly (custom auth middleware,
-            // localized message, etc.). Re-probe with placeholder tenant headers; if
-            // the failure was due to missing tenant headers the response will change.
-            try {
-                const probeHeaders = {
-                    "X-API-Key": apiKey,
-                    "X-OpenViking-Account": "__probe__",
-                    "X-OpenViking-User": "__probe__",
-                    ...configuredRequestHeaders,
-                };
-                const probe2 = await fetch(sessionsUrl, {
-                    headers: probeHeaders,
-                    signal: controller.signal,
-                });
-                if (probe2.status !== response.status) {
-                    return {
-                        keyType: "root_key",
-                        needsAccountId: true,
-                        needsUserId: true,
-                        detail: body.slice(0, 200) || `HTTP ${response.status} -> ${probe2.status} after adding tenant headers`,
-                    };
-                }
-            }
-            catch { /* ignore probe errors, fall through to unknown */ }
-            if (response.status === 401 || response.status === 403) {
-                return { keyType: "unknown", needsAccountId: false, needsUserId: false, detail: `HTTP ${response.status} - authentication failed, verify your API key` };
-            }
-            return { keyType: "unknown", needsAccountId: false, needsUserId: false, detail: `HTTP ${response.status}${body ? ` - ${body.slice(0, 160)}` : ""}` };
-        }
-        return { keyType: "unknown", needsAccountId: false, needsUserId: false, detail: `HTTP ${response.status}` };
-    }
-    catch (err) {
-        return { keyType: "unknown", needsAccountId: false, needsUserId: false, detail: String(err instanceof Error ? err.message : err) };
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-}
-async function checkServiceHealth(baseUrl, apiKey, configuredHeaders) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 10_000);
-    try {
-        const configuredRequestHeaders = resolveOpenVikingRequestHeaders({ headers: configuredHeaders });
-        const headers = {};
-        if (apiKey) {
-            headers["X-API-Key"] = apiKey;
-        }
-        Object.assign(headers, configuredRequestHeaders);
-        const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/health`, {
-            headers,
-            signal: controller.signal,
-        });
-        if (response.ok) {
-            try {
-                const data = await response.json();
-                const result = (data.result ?? data);
-                const version = String(result.version ?? data.version ?? "");
-                const compatibility = checkVersionCompatibility(version);
-                return { ok: true, version, error: "", compatibility, pluginVersion: PLUGIN_VERSION, compatRange: formatCompatRange() };
-            }
-            catch {
-                return { ok: true, version: "", error: "", compatibility: "unknown", pluginVersion: PLUGIN_VERSION, compatRange: formatCompatRange() };
-            }
-        }
-        return { ok: false, version: "", error: `HTTP ${response.status}`, compatibility: "unknown", pluginVersion: PLUGIN_VERSION, compatRange: formatCompatRange() };
-    }
-    catch (err) {
-        return { ok: false, version: "", error: String(err instanceof Error ? err.message : err), compatibility: "unknown", pluginVersion: PLUGIN_VERSION, compatRange: formatCompatRange() };
-    }
-    finally {
-        clearTimeout(timeoutId);
-    }
-}
+const setupProbes = createSetupNetworkProbes({
+    pluginVersion: PLUGIN_VERSION,
+    compatRange: formatCompatRange(),
+    checkVersionCompatibility,
+});
 function readOpenClawConfig(configPath) {
     if (!fs.existsSync(configPath))
         return {};
@@ -473,7 +374,7 @@ export function registerSetupCli(api) {
             .option("--zh", "Chinese prompts")
             .option("--base-url <url>", "OpenViking server URL (enables non-interactive mode)")
             .option("--api-key <key>", "API key for authentication")
-            .option("--peer-role <role>", "Peer ID role: none, assistant, or person")
+            .option("--peer-role <role>", "Memory scope: none (shared), assistant (per assistant), or sender (per sender); person is a legacy alias")
             .option("--peer-prefix <prefix>", "Prefix for assistant peer_id values")
             .option("--account-id <id>", "Account ID (required for root API keys)")
             .option("--user-id <id>", "User ID (required for root API keys)")
@@ -617,7 +518,7 @@ async function runRemoteCheck(zh, existing) {
     const apiKey = existing.apiKey ? String(existing.apiKey) : undefined;
     const headers = nonEmptyOpenVikingRequestHeaders(existing.headers);
     console.log(tr(zh, `Testing connectivity to ${baseUrl}...`, `正在测试连接 ${baseUrl}...`));
-    const health = await checkServiceHealth(baseUrl, apiKey, headers);
+    const health = await setupProbes.checkServiceHealth(baseUrl, apiKey, headers);
     if (health.ok) {
         const ver = health.version ? ` (version: ${health.version})` : "";
         console.log(`  ✓ ${tr(zh, `Connected successfully${ver}`, `连接成功${ver}`)}`);
@@ -637,7 +538,7 @@ async function setupNonInteractive(configPath, params) {
             throw new Error("peer_prefix may only contain letters, digits, underscores, and hyphens, or be empty");
         }
         // Phase 1: validate connectivity and key type BEFORE writing config
-        const health = await checkServiceHealth(baseUrl, apiKey);
+        const health = await setupProbes.checkServiceHealth(baseUrl, apiKey);
         if (!health.ok && !allowOffline) {
             return {
                 success: false,
@@ -648,7 +549,7 @@ async function setupNonInteractive(configPath, params) {
                 error: `Server unreachable: ${health.error}. Use --allow-offline to save config anyway.`,
             };
         }
-        const keyProbe = health.ok ? await probeApiKeyType(baseUrl, apiKey) : undefined;
+        const keyProbe = health.ok ? await setupProbes.probeApiKeyType(baseUrl, apiKey) : undefined;
         if (keyProbe?.keyType === "root_key" && (!accountId || !userId)) {
             const missing = [];
             if (!accountId)
@@ -786,8 +687,8 @@ async function getStatus(configPath) {
     const baseUrl = String(existing.baseUrl ?? DEFAULT_REMOTE_URL);
     const apiKey = existing.apiKey ? String(existing.apiKey) : undefined;
     const headers = nonEmptyOpenVikingRequestHeaders(existing.headers);
-    const health = await checkServiceHealth(baseUrl, apiKey, headers);
-    const keyProbe = health.ok ? await probeApiKeyType(baseUrl, apiKey, headers) : undefined;
+    const health = await setupProbes.checkServiceHealth(baseUrl, apiKey, headers);
+    const keyProbe = health.ok ? await setupProbes.probeApiKeyType(baseUrl, apiKey, headers) : undefined;
     const peerPrefix = resolveExistingPeerPrefix(existing);
     return {
         configured: true,
@@ -880,7 +781,7 @@ async function setupRemote(zh, configPath, existing, q) {
     let userId = existing?.userId ? String(existing.userId) : "";
     if (apiKey) {
         console.log(tr(zh, "  Detecting API key type...", "  正在检测 API Key 类型..."));
-        const probe = await probeApiKeyType(baseUrl, apiKey, headers);
+        const probe = await setupProbes.probeApiKeyType(baseUrl, apiKey, headers);
         if (probe.keyType === "root_key") {
             console.log(tr(zh, "  ⚠ Root API key detected. accountId and userId are required.", "  ⚠ 检测到 Root API Key，需要提供 accountId 和 userId。"));
             accountId = await q(tr(zh, "Account ID (required for root key)", "Account ID（root key 必填）"), accountId);
@@ -896,7 +797,7 @@ async function setupRemote(zh, configPath, existing, q) {
         : "";
     console.log("");
     console.log(tr(zh, `Testing connectivity to ${baseUrl}...`, `正在测试连接 ${baseUrl}...`));
-    const health = await checkServiceHealth(baseUrl, apiKey || undefined, headers);
+    const health = await setupProbes.checkServiceHealth(baseUrl, apiKey || undefined, headers);
     if (health.ok) {
         const ver = health.version ? ` (version: ${health.version})` : "";
         console.log(`  ✓ ${tr(zh, `Connected successfully${ver}`, `连接成功${ver}`)}`);
@@ -952,6 +853,8 @@ async function setupRemote(zh, configPath, existing, q) {
 export const __test__ = {
     isLegacyLocalMode,
     isValidPeerPrefixInput,
+    normalizePeerRole,
+    resolveSetupPeerRole,
     normalizeSetupRecallTargetTypes,
     activateContextEngineSlot,
     isContextEngineSlotActive,
@@ -960,7 +863,6 @@ export const __test__ = {
     checkVersionCompatibility,
     parseVersionTuple,
     compareVersions,
-    probeApiKeyType,
     ensureInstallRecord,
     findPluginPackageRoot,
     readCompatRangeFromManifest,

package/dist/config.js

@@ -18,7 +18,7 @@ const DEFAULT_COMMIT_TOKEN_THRESHOLD_RATIO = 0.5;
 const DEFAULT_COMMIT_KEEP_RECENT_COUNT = 10;
 const DEFAULT_BYPASS_SESSION_PATTERNS = [];
 const DEFAULT_EMIT_STANDARD_DIAGNOSTICS = false;
-const DEFAULT_PEER_ROLE = "assistant";
+const DEFAULT_PEER_ROLE = "none";
 const DEFAULT_PEER_PREFIX = "";
 const DEFAULT_TRACE_RECALL_DIR = "~/.openclaw/openviking/recall-traces";
 const DEFAULT_TRACE_RECALL_RETENTION_DAYS = 14;
@@ -144,13 +144,16 @@ function resolveSecret(value, label) {
 function resolvePeerRole(configured) {
     if (typeof configured === "string") {
         const role = configured.trim().toLowerCase();
-        if (role === "none" || role === "assistant" || role === "person") {
+        if (role === "none" || role === "assistant" || role === "sender") {
             return role;
         }
-        throw new Error(`openviking peer_role must be "none", "assistant", or "person"`);
+        if (role === "person") {
+            return "sender";
+        }
+        throw new Error(`openviking peer_role must be "none", "assistant", or "sender" (legacy alias: "person")`);
     }
     if (configured !== undefined) {
-        throw new Error(`openviking peer_role must be "none", "assistant", or "person"`);
+        throw new Error(`openviking peer_role must be "none", "assistant", or "sender" (legacy alias: "person")`);
     }
     return DEFAULT_PEER_ROLE;
 }
@@ -481,14 +484,16 @@ export const memoryOpenVikingConfigSchema = {
             help: "HTTP URL when mode is remote (or use ${OPENVIKING_BASE_URL})",
         },
         peer_role: {
-            label: "Peer Role",
+            label: "Memory Scope (peer_role)",
             placeholder: DEFAULT_PEER_ROLE,
-            help: 'Controls which session messages get peer_id: "none", "assistant", or "person".',
+            help: 'Where peer-scoped memories are stored. "none" (default): viking://user/<user_id>/memories. ' +
+                '"assistant": viking://user/<user_id>/peers/<assistant_id>/memories. ' +
+                '"sender": viking://user/<user_id>/peers/<sender_id>/memories. Legacy "person" is accepted as "sender".',
         },
         peer_prefix: {
             label: "Peer Prefix",
             placeholder: "optional-prefix",
-            help: "Optional prefix applied to assistant peer_id values derived from OpenClaw runtime agent IDs.",
+            help: 'Only used when Memory Scope is "assistant". Prefix added to the peer id derived from the OpenClaw agent id.',
         },
         apiKey: {
             label: "OpenViking API Key",
@@ -598,7 +603,7 @@ export const memoryOpenVikingConfigSchema = {
         bypassSessionPatterns: {
             label: "Bypass Session Patterns",
             placeholder: "agent:*:cron:**",
-            help: "Completely bypass OpenViking for matching session keys. Use * within one segment and ** across segments.",
+            help: "Completely bypass OpenViking for matching session keys (no capture, recall, or commit; compaction falls back to OpenClaw's native compactor). Use * within one segment and ** across segments.",
             advanced: true,
         },
         commitTokenThresholdRatio: {

package/dist/context-engine.js

@@ -3,6 +3,7 @@ import { compileSessionPatterns, shouldBypassSession, } from "./text-utils.js";
 import { estimateAgentMessageTokens, estimateAgentMessagesTokens } from "./token-estimator.js";
 import { openClawSessionToOvStorageId } from "./routing/identity-routing.js";
 import { assembleOpenVikingSession, afterTurnOpenVikingSession, compactOpenVikingSession, commitOpenVikingSession, } from "./services/context-lifecycle-service.js";
+import { loadRuntimeCompactionDelegate } from "./plugin/openclaw-runtime-compaction.js";
 function roughEstimate(messages) {
     return estimateAgentMessagesTokens(messages);
 }
@@ -255,6 +256,10 @@ export function createMemoryOpenVikingContextEngine(params) {
                 logger,
                 resolveAgentId,
                 isBypassedSession,
+                runtimeCompact: async () => {
+                    const delegate = await loadRuntimeCompactionDelegate();
+                    return delegate ? delegate(compactParams) : undefined;
+                },
                 diag,
             });
         },

package/dist/plugin/openclaw-runtime-compaction.js

@@ -0,0 +1,20 @@
+// Bridge to OpenClaw's built-in compactor for sessions that bypass OpenViking.
+// The host exports `delegateCompactionToRuntime` from `openclaw/plugin-sdk/core`
+// (present since the earliest supported host); it is resolved lazily because the
+// plugin builds without the host SDK installed.
+const PLUGIN_SDK_CORE_SPECIFIER = "openclaw/plugin-sdk/core";
+let cached;
+export function loadRuntimeCompactionDelegate() {
+    cached ??= (async () => {
+        try {
+            const mod = (await import(PLUGIN_SDK_CORE_SPECIFIER));
+            return typeof mod?.delegateCompactionToRuntime === "function"
+                ? mod.delegateCompactionToRuntime
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    return cached;
+}

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

@@ -45,7 +45,7 @@ export function registerOpenVikingMemoryTools(deps) {
                 const peerId = resolveOpenVikingMessagePeerId({
                     peerRole: deps.peerRole,
                     role,
-                    personPeerId: session.actorPeerId,
+                    senderPeerId: session.actorPeerId,
                     assistantPeerId: session.actorPeerId,
                 });
                 await client.addSessionMessage(sessionId, role, [{ type: "text", text }], undefined, undefined, peerId);

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

@@ -1,6 +1,6 @@
 import { createSessionAgentResolver, openClawSessionToOvStorageId, resolveOpenVikingActorPeerId, sanitizeOpenVikingPeerId, } from "../routing/identity-routing.js";
 export function createOpenVikingSessionRoutingRuntime(options) {
-    const peerRole = options.peerRole ?? "assistant";
+    const peerRole = options.peerRole ?? "none";
     const sessionAgentResolver = createSessionAgentResolver(options.peerPrefix);
     const rememberSessionAgentId = (ctx) => {
         sessionAgentResolver.remember(ctx);
@@ -48,7 +48,7 @@ export function createOpenVikingSessionRoutingRuntime(options) {
             agentId,
             actorPeerId: resolveOpenVikingActorPeerId({
                 peerRole,
-                personPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
+                senderPeerId: sanitizeOpenVikingPeerId(ctx?.requesterSenderId ?? ctx?.senderId),
                 assistantPeerId: agentId,
             }),
         };

package/dist/routing/identity-routing.js

@@ -12,8 +12,8 @@ export function sanitizeOpenVikingPeerId(raw) {
     return normalized || undefined;
 }
 export function resolveOpenVikingMessagePeerId(params) {
-    if (params.peerRole === "person" && params.role === "user") {
-        return params.personPeerId;
+    if (params.peerRole === "sender" && params.role === "user") {
+        return params.senderPeerId;
     }
     if (params.peerRole === "assistant" && params.role === "assistant") {
         return params.assistantPeerId;
@@ -23,10 +23,10 @@ export function resolveOpenVikingMessagePeerId(params) {
 export function resolveOpenVikingActorPeerId(params) {
     const actorPeerId = resolveOpenVikingMessagePeerId({
         ...params,
-        role: params.peerRole === "person" ? "user" : "assistant",
+        role: params.peerRole === "sender" ? "user" : "assistant",
     });
-    if (params.peerRole === "person" && !actorPeerId) {
-        throw new Error("openviking: peer_role=person requires a sender identity");
+    if (params.peerRole === "sender" && !actorPeerId) {
+        throw new Error("openviking: peer_role=sender requires a sender identity");
     }
     return actorPeerId;
 }