@openviking/openclaw-plugin 2026.9.1 → 2026.9.4-1

package/client.ts

@@ -12,6 +12,11 @@ import {
   defaultResourcePackager,
   type ResourcePackager,
 } from "./adapters/resource-packager.js";
+import {
+  buildContextSearchBody,
+  contextRequestTimeoutMs,
+  normalizeContextEntry,
+} from "./shared/recall-core.mjs";
 
 export type FindResultItem = {
   uri: string;
@@ -30,6 +35,36 @@ export type FindResult = {
   total?: number;
 };
 
+export type SearchContextEntry = {
+  uri: string;
+  category?: string;
+  score?: number;
+  detail?: string;
+  text?: string;
+  origin?: string;
+};
+
+export type SearchContextResult = {
+  entries?: SearchContextEntry[];
+  rendered?: string;
+  digest?: string;
+  stats?: Record<string, unknown>;
+};
+
+export type SearchContextOptions = {
+  sessionId?: string;
+  limit?: number;
+  scoreThreshold?: number;
+  contextType?: string | string[];
+  queryExpansion?: "off" | "auto";
+  maxTokens?: number;
+  detail?: "abstract" | "overview" | "full";
+  dedupTurns?: number;
+  peerScope?: "actor" | "all";
+  actorPeerId?: string;
+  requestTimeoutMs?: number;
+};
+
 export type FsListEntry = string | Record<string, unknown>;
 
 export type FsListResult = FsListEntry[];
@@ -488,6 +523,66 @@ export class OpenVikingClient {
     }, undefined, actorPeerId);
   }
 
+  async searchContext(
+    query: string,
+    options: SearchContextOptions = {},
+  ): Promise<SearchContextResult> {
+    const contractConfig = {
+      recallLimit: options.limit,
+      recallLimitConfigured: options.limit !== undefined,
+      recallMaxTokens: options.maxTokens,
+      recallMaxTokensConfigured: options.maxTokens !== undefined,
+      scoreThreshold: options.scoreThreshold,
+      recallQueryExpansion: options.queryExpansion,
+      recallQueryExpansionConfigured: options.queryExpansion !== undefined,
+      recallDedupTurns: options.dedupTurns,
+      recallPeerScope: options.peerScope,
+      recallContextTimeoutMs: options.requestTimeoutMs,
+      timeoutMs: this.timeoutMs,
+    };
+    const body = {
+      ...buildContextSearchBody(contractConfig, { sessionId: options.sessionId }),
+      query,
+      ...(options.contextType !== undefined ? { context_type: options.contextType } : {}),
+      ...(options.detail !== undefined ? { detail: options.detail } : {}),
+    };
+    const requestTimeoutMs = contextRequestTimeoutMs(contractConfig, body);
+    const actorPeerId = this.resolveActorPeerHeader(options.actorPeerId);
+    const tenantHeaders = this.resolveTenantHeaders();
+    this.routingDebugLog?.(
+      `openviking: context search POST ${this.baseUrl}/api/v1/search/search ` +
+        JSON.stringify({
+          X_OpenViking_Account: tenantHeaders.accountId ?? null,
+          X_OpenViking_User: tenantHeaders.userId ?? null,
+          X_OpenViking_Actor_Peer: actorPeerId ?? null,
+          session_id: body.session_id ?? null,
+          query:
+            query.length > 4000
+              ? `${query.slice(0, 4000)}…(+${query.length - 4000} more chars)`
+              : query,
+          purpose: body.purpose,
+          quotas: body.quotas ?? null,
+          score_threshold: body.score_threshold,
+          context_type: body.context_type ?? null,
+          query_expansion: body.query_expansion ?? null,
+          max_tokens: body.max_tokens ?? null,
+          detail: body.detail ?? null,
+          dedup_turns: body.dedup_turns ?? 0,
+          peer_scope: body.peer_scope ?? null,
+        }),
+    );
+    const result = await this.request<SearchContextResult>("/api/v1/search/search", {
+      method: "POST",
+      body: JSON.stringify(body),
+    }, requestTimeoutMs, actorPeerId);
+    return {
+      ...result,
+      entries: Array.isArray(result.entries)
+        ? result.entries.map((entry) => ({ ...entry, ...normalizeContextEntry(entry) }))
+        : result.entries,
+    };
+  }
+
   async read(uri: string, actorPeerId?: string): Promise<string> {
     return this.request<string>(
       `/api/v1/content/read?uri=${encodeURIComponent(uri)}`,

package/commands/setup.ts

@@ -84,8 +84,8 @@ const CONFIG_KEYS_TO_PRESERVE = [
   "logFindRequests",
 ] as const;
 
-type PeerRole = "none" | "assistant" | "person";
-const DEFAULT_SETUP_PEER_ROLE: PeerRole = "assistant";
+type PeerRole = "none" | "assistant" | "sender";
+const DEFAULT_SETUP_PEER_ROLE: PeerRole = "none";
 type RecallTargetType = "resource" | "user" | "agent";
 const ALLOWED_RECALL_TARGET_TYPES = ["resource", "user", "agent"] as const;
 
@@ -126,7 +126,8 @@ function isValidPeerPrefixInput(value: string): boolean {
 function normalizePeerRole(value: unknown): PeerRole | undefined {
   if (typeof value !== "string") return undefined;
   const role = value.trim().toLowerCase();
-  if (role === "none" || role === "assistant" || role === "person") return role;
+  if (role === "person") return "sender";
+  if (role === "none" || role === "assistant" || role === "sender") return role;
   return undefined;
 }
 
@@ -147,7 +148,7 @@ function resolveSetupPeerRole(value: unknown): PeerRole {
   if (value === undefined) return DEFAULT_SETUP_PEER_ROLE;
   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: unknown): RecallTargetType[] | undefined {
@@ -206,9 +207,20 @@ async function askPeerRole(
   q: (prompt: string, def?: string) => Promise<string>,
   defaultValue: PeerRole,
 ): Promise<PeerRole> {
+  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）"),
+      tr(zh, "Memory scope (none/assistant/sender)", "记忆归属（none/assistant/sender）"),
       defaultValue,
     );
     const role = normalizePeerRole(value);
@@ -216,8 +228,8 @@ async function askPeerRole(
     console.log(
       `  ✗ ${tr(
         zh,
-        'Peer Role must be "none", "assistant", or "person".',
-        'Peer Role 必须是 "none"、"assistant" 或 "person"。',
+        'Memory scope must be "none", "assistant", or "sender" (legacy "person" is also accepted).',
+        '记忆归属必须是 "none"、"assistant" 或 "sender"（也兼容旧值 "person"）。',
       )}`,
     );
   }
@@ -605,7 +617,7 @@ export function registerSetupCli(api: any): void {
         .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)")
@@ -1182,6 +1194,8 @@ async function setupRemote(
 export const __test__ = {
   isLegacyLocalMode,
   isValidPeerPrefixInput,
+  normalizePeerRole,
+  resolveSetupPeerRole,
   normalizeSetupRecallTargetTypes,
   activateContextEngineSlot,
   isContextEngineSlotActive,

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. */
@@ -45,13 +46,13 @@ export type MemoryOpenVikingConfig = {
   captureMode?: "semantic" | "keyword";
   captureMaxLength?: number;
   autoRecall?: boolean;
-  /** Outer time budget for the whole auto-recall flow, including search, ranking, and reads. */
+  /** Outer time budget for the whole server-assembled auto-recall flow. */
   autoRecallTimeoutMs?: number;
   /** Include resources in auto-recall and default memory_recall search. Default false. */
   recallResources?: boolean;
   recallLimit?: number;
   recallScoreThreshold?: number;
-  /** Maximum total characters injected by auto-recall. */
+  /** Legacy character budget, converted to the server context token budget. */
   recallMaxInjectedChars?: number;
   /** @deprecated Auto-recall no longer truncates individual memories. */
   recallMaxContentChars?: number;
@@ -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">;
 };
@@ -140,7 +143,9 @@ const DEFAULT_TARGET_URI = "viking://~/memories";
 const DEFAULT_TIMEOUT_MS = 15000;
 const DEFAULT_CAPTURE_MODE = "semantic";
 const DEFAULT_CAPTURE_MAX_LENGTH = 24000;
-const DEFAULT_AUTO_RECALL_TIMEOUT_MS = 5000;
+// Session-aware context search may spend up to 5 seconds on query expansion
+// before returning its server-side fallback, so leave headroom for retrieval.
+const DEFAULT_AUTO_RECALL_TIMEOUT_MS = 15000;
 const DEFAULT_RECALL_LIMIT = 6;
 const DEFAULT_RECALL_SCORE_THRESHOLD = 0.15;
 const DEFAULT_RECALL_MAX_CONTENT_CHARS = 5000;
@@ -150,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;
@@ -290,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;
 }
@@ -774,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",
@@ -843,7 +858,7 @@ export const memoryOpenVikingConfigSchema = {
       label: "Auto-Recall Timeout (ms)",
       placeholder: String(DEFAULT_AUTO_RECALL_TIMEOUT_MS),
       advanced: true,
-      help: "Outer time budget for the whole auto-recall flow, including search, ranking, and memory reads.",
+      help: "Outer time budget for the server-assembled context search, including session-aware query expansion.",
     },
     recallResources: {
       label: "Recall Resources",
@@ -870,7 +885,7 @@ export const memoryOpenVikingConfigSchema = {
       label: "Recall Max Injected Chars",
       placeholder: String(DEFAULT_RECALL_MAX_INJECTED_CHARS),
       advanced: true,
-      help: "Maximum total characters for auto-recall memory injection. Complete memories that do not fit are skipped, not truncated.",
+      help: "Legacy auto-recall character budget. It is converted to the server context token budget at four characters per token.",
     },
     recallMaxContentChars: {
       label: "Deprecated Recall Max Content Chars",
@@ -881,7 +896,7 @@ export const memoryOpenVikingConfigSchema = {
     recallPreferAbstract: {
       label: "Recall Prefer Abstract",
       advanced: true,
-      help: "Use memory abstract instead of fetching full content when abstract is available. Reduces token usage.",
+      help: "Pin server-assembled auto-recall entries to abstract detail. When disabled, the server chooses each category's default detail tier.",
     },
     recallTokenBudget: {
       label: "Deprecated Recall Token Budget",

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,
@@ -248,7 +248,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. */

package/dist/auto-recall.js

@@ -1,9 +1,11 @@
-import { pickMemoriesForInjection, postProcessMemories, summarizeInjectionMemories, toJsonLog, } from "./memory-ranking.js";
+import { toJsonLog } from "./memory-ranking.js";
 import { quickRecallPrecheck, withTimeout } from "./process-manager.js";
 import { resolveRecallSearchPlan, } from "./registries/recall-resource-types.js";
 import { sanitizeUserTextForCapture } from "./text-utils.js";
 import { estimateTextTokens } from "./token-estimator.js";
 const RECALL_QUERY_MAX_CHARS = 4_000;
+const AUTO_RECALL_DEDUP_TURNS = 5;
+const LEGACY_CHARS_PER_TOKEN = 4;
 export const AUTO_RECALL_SOURCE_MARKER = "Source: openviking-auto-recall";
 const WRITE_OR_EFFECT_RE = /\b(write|edit|modify|delete|remove|migrate|deploy|release|publish|configure|patch)\b|写|改|修改|删除|迁移|部署|发布|配置|打补丁/i;
 const EXECUTION_RE = /\b(fix|debug|test|build|run|implement|refactor|integrate|repair|troubleshoot)\b|修复|调试|测试|构建|运行|实现|重构|对接|排查/i;
@@ -135,16 +137,25 @@ function preview(value, maxChars) {
         return undefined;
     return trimmed.length > maxChars ? trimmed.slice(0, maxChars) : trimmed;
 }
-function toTraceResults(items, resourceType) {
-    return items.map((item) => ({
-        uri: item.uri,
+function traceResourceType(entry) {
+    if (entry.category === "resources" || entry.uri.startsWith("viking://resources")) {
+        return "resource";
+    }
+    if (entry.origin === "actor_peer") {
+        return "agent";
+    }
+    return "user";
+}
+function toTraceResult(entry) {
+    const resourceType = traceResourceType(entry);
+    return {
+        uri: entry.uri,
         resourceType,
-        category: item.category,
-        score: item.score,
-        level: item.level,
-        abstractPreview: preview(item.abstract ?? item.overview, 240),
+        category: entry.category,
+        score: entry.score,
+        abstractPreview: preview(entry.text, 240),
         resultType: resourceType === "resource" ? "resource" : "memory",
-    }));
+    };
 }
 function boundTraceQuery(query, maxChars) {
     if (query.length <= maxChars) {
@@ -211,7 +222,6 @@ export async function buildAutoRecallContext(params) {
         return { memoryCount: 0, estimatedTokens: 0 };
     }
     return withTimeout((async () => {
-        const candidateLimit = queryConfig?.candidateLimit ?? Math.max(cfg.recallLimit * 4, 20);
         const scoreThreshold = queryConfig?.scoreThreshold ?? cfg.recallScoreThreshold;
         const recallLimit = queryConfig?.recallLimit ?? cfg.recallLimit;
         const maxInjectedChars = queryConfig?.maxInjectedChars ?? cfg.recallMaxInjectedChars;
@@ -220,89 +230,75 @@ export async function buildAutoRecallContext(params) {
             ovSessionId: params.ovSessionId,
             agentId,
         });
-        const traceSearches = searchPlan.skipped.map((skipped) => ({
-            resourceType: skipped.resourceType,
-            limit: candidateLimit,
-            scoreThreshold: 0,
-            durationMs: 0,
-            total: 0,
-            results: [],
-            error: skipped.reason,
-        }));
-        const autoRecallPromises = searchPlan.searches.map(async (search) => {
-            const start = Date.now();
-            const result = await client.find(queryText, {
-                targetUri: search.targetUri,
-                limit: candidateLimit,
-                scoreThreshold: 0,
-                contextType: search.contextType,
+        const contextTypes = [...new Set(searchPlan.searches.map((search) => search.contextType))];
+        const maxTokens = Math.min(32_000, Math.max(64, Math.round(maxInjectedChars / LEGACY_CHARS_PER_TOKEN)));
+        const startedAt = Date.now();
+        let contextResult;
+        let requestError;
+        try {
+            contextResult = await client.searchContext(queryText, {
+                sessionId: params.ovSessionId,
+                limit: recallLimit,
+                scoreThreshold,
+                contextType: contextTypes.length === 1 ? contextTypes[0] : contextTypes,
+                queryExpansion: "auto",
+                maxTokens,
+                detail: recallPreferAbstract ? "abstract" : undefined,
+                dedupTurns: params.ovSessionId ? AUTO_RECALL_DEDUP_TURNS : undefined,
+                peerScope: "actor",
                 actorPeerId,
+                requestTimeoutMs: cfg.autoRecallTimeoutMs,
             });
-            return {
-                resourceType: search.resourceType,
-                targetUri: search.targetUri,
-                result,
-                durationMs: Date.now() - start,
-            };
-        });
-        const autoRecallSettled = await Promise.allSettled(autoRecallPromises);
-        const allMemories = [];
-        for (const s of autoRecallSettled) {
-            if (s.status === "fulfilled") {
-                const result = s.value.result ?? {};
-                const memories = result.memories ?? [];
-                const resources = result.resources ?? [];
-                allMemories.push(...memories, ...resources);
-                traceSearches.push({
-                    resourceType: s.value.resourceType,
-                    targetUriInput: s.value.targetUri,
-                    limit: candidateLimit,
-                    scoreThreshold: 0,
-                    durationMs: s.value.durationMs,
-                    total: result.total ?? memories.length + resources.length + (result.skills?.length ?? 0),
-                    results: [
-                        ...toTraceResults(memories, s.value.resourceType),
-                        ...toTraceResults(resources, "resource"),
-                        ...(result.skills ?? []).map((item) => ({
-                            uri: item.uri,
-                            resourceType: s.value.resourceType,
-                            category: item.category,
-                            score: item.score,
-                            level: item.level,
-                            abstractPreview: preview(item.abstract ?? item.overview, 240),
-                            resultType: "skill",
-                        })),
-                    ].slice(0, cfg.traceRecallMaxResultsPerSearch),
-                });
-            }
-            else {
-                logger.warn?.(`openviking: auto-recall search failed: ${String(s.reason)}`);
-                const failedIndex = traceSearches.length;
-                const search = searchPlan.searches[failedIndex - searchPlan.skipped.length];
-                traceSearches.push({
-                    resourceType: search?.resourceType ?? "user",
-                    targetUriInput: search?.targetUri,
-                    limit: candidateLimit,
-                    scoreThreshold: 0,
-                    durationMs: 0,
-                    total: 0,
-                    results: [],
-                    error: String(s.reason),
-                });
-            }
         }
-        const uniqueMemories = allMemories.filter((memory, index, self) => index === self.findIndex((m) => m.uri === memory.uri));
-        const leafOnly = uniqueMemories.filter((m) => !m.level || m.level === 2);
-        const processed = postProcessMemories(leafOnly, {
-            limit: candidateLimit,
-            scoreThreshold,
-        });
-        const memories = pickMemoriesForInjection(processed, recallLimit, queryText, scoreThreshold, queryConfig ? {
-            weights: queryConfig.rankingWeights,
-            categoryWeights: queryConfig.categoryWeights,
-            resourceTypeWeights: queryConfig.resourceTypeWeights,
-        } : undefined);
-        const recordTrace = async (injectedMemories, injectedCount, estimatedTokens) => {
+        catch (error) {
+            requestError = error;
+        }
+        const durationMs = Date.now() - startedAt;
+        const entries = (contextResult?.entries ?? []).filter((entry) => Boolean(entry.uri));
+        const rawRetrievalErrors = contextResult?.stats?.retrieval_errors;
+        const retrievalErrors = Array.isArray(rawRetrievalErrors)
+            ? rawRetrievalErrors.map((error) => String(error))
+            : [];
+        const searchError = requestError
+            ? String(requestError)
+            : retrievalErrors.length > 0
+                ? retrievalErrors.join("; ")
+                : undefined;
+        if (searchError) {
+            logger.warn?.(`openviking: auto-recall context search failed: ${searchError}`);
+        }
+        const traceSearches = [
+            ...searchPlan.skipped.map((skipped) => ({
+                resourceType: skipped.resourceType,
+                limit: recallLimit,
+                scoreThreshold,
+                durationMs: 0,
+                total: 0,
+                results: [],
+                error: skipped.reason,
+            })),
+            ...searchPlan.searches.map((search) => {
+                const matchingEntries = entries.filter((entry) => search.contextType === "resource"
+                    ? traceResourceType(entry) === "resource"
+                    : traceResourceType(entry) !== "resource");
+                return {
+                    resourceType: search.resourceType,
+                    contextType: search.contextType,
+                    limit: recallLimit,
+                    scoreThreshold,
+                    durationMs,
+                    total: matchingEntries.length,
+                    results: matchingEntries
+                        .map(toTraceResult)
+                        .slice(0, cfg.traceRecallMaxResultsPerSearch),
+                    error: searchError,
+                };
+            }),
+        ];
+        const candidateCount = typeof contextResult?.stats?.candidates === "number"
+            ? contextResult.stats.candidates
+            : entries.length;
+        const recordTrace = async (injectedEntries, injectedCount, estimatedTokens) => {
             const entry = {
                 schemaVersion: "1.0",
                 traceId: newTraceId(),
@@ -321,17 +317,17 @@ export async function buildAutoRecallContext(params) {
                     queryTruncated: params.queryTruncated || queryText.length > cfg.traceRecallQueryMaxChars,
                 },
                 searches: traceSearches,
-                selected: injectedMemories.map((memory) => ({
-                    uri: memory.uri,
-                    resourceType: memory.uri.startsWith("viking://resources") ? "resource" : undefined,
-                    category: memory.category,
-                    score: memory.score,
-                    abstractPreview: preview(memory.abstract ?? memory.overview, cfg.traceRecallPreviewChars),
+                selected: injectedEntries.map((contextEntry) => ({
+                    uri: contextEntry.uri,
+                    resourceType: traceResourceType(contextEntry),
+                    category: contextEntry.category,
+                    score: contextEntry.score,
+                    abstractPreview: preview(contextEntry.text, cfg.traceRecallPreviewChars),
                     injected: true,
                 })),
                 stats: {
-                    candidateCount: allMemories.length,
-                    selectedCount: injectedMemories.length,
+                    candidateCount,
+                    selectedCount: injectedEntries.length,
                     injectedCount,
                     estimatedTokens,
                 },
@@ -339,24 +335,27 @@ export async function buildAutoRecallContext(params) {
             // Trace persistence is diagnostic best-effort; never put JSONL flush latency on the auto-recall critical path.
             params.traceRecorder?.record(entry);
         };
-        if (memories.length === 0) {
-            await recordTrace([], 0, 0);
-            return { memoryCount: 0, estimatedTokens: 0 };
-        }
-        const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(memories, (uri) => client.read(uri, actorPeerId), {
-            recallPreferAbstract,
-            recallMaxInjectedChars: maxInjectedChars,
-            includeUri: true,
-        });
-        if (memoryLines.length === 0) {
-            verbose?.(`openviking: skipping auto-recall injection; no complete memories fit maxInjectedChars=${maxInjectedChars}`);
+        const rendered = contextResult?.rendered?.trim() ?? "";
+        if (requestError || entries.length === 0 || !rendered) {
             await recordTrace([], 0, 0);
             return { memoryCount: 0, estimatedTokens: 0 };
         }
-        const block = buildRecallContextBlock(memoryLines);
-        verbose?.(`openviking: injecting ${memoryLines.length} memories (${block.length} chars, ~${estimatedTokens} tokens, maxInjectedChars=${maxInjectedChars})`);
-        verbose?.(`openviking: inject-detail ${toJsonLog({ count: memories.length, memories: summarizeInjectionMemories(memories) })}`);
-        await recordTrace(memories.slice(0, memoryLines.length), memoryLines.length, estimatedTokens);
-        return { block, memoryCount: memoryLines.length, estimatedTokens };
+        const usedTokens = contextResult?.stats?.used_tokens;
+        const estimatedTokens = typeof usedTokens === "number" && Number.isFinite(usedTokens)
+            ? Math.max(0, Math.ceil(usedTokens))
+            : estimateTokenCount(rendered);
+        const block = buildRecallContextBlock([rendered]);
+        verbose?.(`openviking: injecting ${entries.length} memories (${block.length} chars, ~${estimatedTokens} tokens, serverMaxTokens=${maxTokens})`);
+        verbose?.(`openviking: inject-detail ${toJsonLog({
+            count: entries.length,
+            entries: entries.map((contextEntry) => ({
+                uri: contextEntry.uri,
+                category: contextEntry.category,
+                score: contextEntry.score,
+                detail: contextEntry.detail,
+            })),
+        })}`);
+        await recordTrace(entries, entries.length, estimatedTokens);
+        return { block, memoryCount: entries.length, estimatedTokens };
     })(), cfg.autoRecallTimeoutMs, "openviking: auto-recall search timeout");
 }