@openviking/openclaw-plugin 2026.9.8 → 2026.9.10-1

package/dist/context-engine.js

@@ -121,6 +121,29 @@ function validTokenBudget(raw) {
     }
     return undefined;
 }
+// OpenClaw 9.1/9.2 still capture via afterTurn even when commitTurn exists.
+// 9.3 (#140024) defers admitted turns to commitTurn; standalone runners keep
+// afterTurn. The registration API's runtime.version is the HOST version.
+function usesDeferredTurnCapture(version) {
+    const match = version?.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match)
+        return undefined;
+    const parts = match.slice(1, 4).map(Number);
+    if (!parts.every(Number.isSafeInteger))
+        return undefined;
+    const [year, month, day] = parts;
+    // OpenClaw uses 0.0.0 when version metadata cannot be resolved. More generally,
+    // versions outside our supported range cannot prove who owns capture.
+    if (year < 2026 || (year === 2026 && (month < 5 || (month === 5 && day < 27)))) {
+        return undefined;
+    }
+    const boundary = year === 2026 && month === 9 && day === 3;
+    // The 9.3 prerelease train can straddle the host change. Numeric packaging
+    // revisions (-1, -2, ...) refer to the stable release; do not guess for betas.
+    if (boundary && match[4] && !/^\d+$/.test(match[4]))
+        return undefined;
+    return year > 2026 || (year === 2026 && (month > 9 || (month === 9 && day >= 3)));
+}
 export function createMemoryOpenVikingContextEngine(params) {
     const { id, name, version, cfg, logger, getClient, resolveAgentId, rememberSessionAgentId, queryConfigStore, traceRecorder, } = params;
     const diagEnabled = cfg.emitStandardDiagnostics;
@@ -161,6 +184,8 @@ export function createMemoryOpenVikingContextEngine(params) {
         };
     }
     const committedTurnKeys = new Set();
+    const inFlightTurns = new Map();
+    const deferredTurnCapture = usesDeferredTurnCapture(params.hostVersion);
     return {
         info: {
             id,
@@ -189,6 +214,7 @@ export function createMemoryOpenVikingContextEngine(params) {
                 sessionId: assembleParams.sessionId,
                 sessionKey: resolveSessionKey(assembleParams),
                 messages: assembleParams.messages,
+                prompt: assembleParams.prompt,
                 tokenBudget,
                 runtimeContext: assembleParams.runtimeContext,
                 isMainAssemble,
@@ -208,20 +234,57 @@ export function createMemoryOpenVikingContextEngine(params) {
                 prependRecallToLatestUserMessage,
             });
         },
-        // Capture still happens in afterTurn (host calls it per LLM call + on finalize);
-        // commitTurn only acknowledges the accepted turn so OpenClaw drains its outbox.
-        // ponytail: in-memory key set, not durable across restarts — the host outbox is.
-        async commitTurn({ advancementKey, sessionId }) {
+        async commitTurn(commitParams) {
+            const { advancementKey, sessionId } = commitParams;
+            if (deferredTurnCapture === undefined) {
+                // ACKing with an unknown capture owner can discard the only copy in the
+                // host outbox. Reject instead; legacy afterTurn remains available.
+                throw new Error(`openviking: cannot select turn capture for OpenClaw version ${params.hostVersion ?? "(missing)"}`);
+            }
             if (committedTurnKeys.has(advancementKey)) {
                 diag("commitTurn_duplicate", sessionId, { advancementKey });
                 return { status: "duplicate" };
             }
-            committedTurnKeys.add(advancementKey);
-            if (committedTurnKeys.size > 1024) {
-                committedTurnKeys.delete(committedTurnKeys.values().next().value);
+            const pending = inFlightTurns.get(advancementKey);
+            if (pending) {
+                await pending;
+                return { status: "duplicate" };
+            }
+            // Publish the promise before capture begins so concurrent deliveries share
+            // both success and failure. Completion keys are intentionally process-local.
+            const capture = Promise.resolve().then(async () => {
+                if (deferredTurnCapture) {
+                    await afterTurnOpenVikingSession({
+                        sessionId,
+                        sessionKey: resolveSessionKey(commitParams),
+                        messages: commitParams.messages,
+                        prePromptMessageCount: 0, // Host already supplies the closed-turn range.
+                        isHeartbeat: commitParams.isHeartbeat,
+                        tokenBudget: 128_000, // Durable delivery does not carry a token budget.
+                        throwOnError: true,
+                        cfg,
+                        getClient,
+                        logger,
+                        resolveAgentId,
+                        rememberSessionAgentId,
+                        isBypassedSession,
+                        diag,
+                    });
+                }
+                committedTurnKeys.add(advancementKey);
+                if (committedTurnKeys.size > 1024) {
+                    committedTurnKeys.delete(committedTurnKeys.values().next().value);
+                }
+                diag("commitTurn", sessionId, { advancementKey, deferredTurnCapture });
+            });
+            inFlightTurns.set(advancementKey, capture);
+            try {
+                await capture;
+                return { status: "committed" };
+            }
+            finally {
+                inFlightTurns.delete(advancementKey);
             }
-            diag("commitTurn", sessionId, { advancementKey });
-            return { status: "committed" };
         },
         async afterTurn(afterTurnParams) {
             const tokenBudget = validTokenBudget(afterTurnParams.tokenBudget) ?? 128_000;

package/dist/plugin/openviking-context-engine-registration.js

@@ -8,6 +8,7 @@ export function registerOpenVikingContextEngine(deps) {
             id: deps.plugin.id,
             name: deps.plugin.name,
             version: deps.version,
+            hostVersion: deps.api.runtime?.version,
             cfg: deps.cfg,
             logger: deps.logger,
             getClient: deps.getClient,

package/dist/recall-trace.js

@@ -1,63 +1,5 @@
 import { appendFile, mkdir, readFile, readdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
-const ALLOWED_RESOURCE_TYPES = ["resource", "user", "agent"];
-const DEFAULT_RESOURCE_TYPES = ["user", "agent"];
-function toResourceTypeEntries(value) {
-    if (Array.isArray(value)) {
-        return value
-            .filter((entry) => typeof entry === "string")
-            .map((entry) => entry.trim())
-            .filter(Boolean);
-    }
-    if (typeof value === "string") {
-        return value
-            .split(/[,\n]/)
-            .map((entry) => entry.trim())
-            .filter(Boolean);
-    }
-    return [];
-}
-export function normalizeResourceTypes(value) {
-    const entries = toResourceTypeEntries(value);
-    if (entries.length === 0) {
-        return [...DEFAULT_RESOURCE_TYPES];
-    }
-    const seen = new Set();
-    const normalized = [];
-    const invalid = [];
-    for (const entry of entries) {
-        if (ALLOWED_RESOURCE_TYPES.includes(entry)) {
-            const typed = entry;
-            if (!seen.has(typed)) {
-                seen.add(typed);
-                normalized.push(typed);
-            }
-        }
-        else {
-            invalid.push(entry);
-        }
-    }
-    if (invalid.length > 0) {
-        throw new Error(`invalid resourceTypes: ${invalid.join(", ")}`);
-    }
-    return normalized.length > 0 ? normalized : [...DEFAULT_RESOURCE_TYPES];
-}
-export function resolveRecallSearchPlan(resourceTypes, _ctx) {
-    const normalized = normalizeResourceTypes(resourceTypes);
-    const searches = [];
-    const skipped = [];
-    let addedMemorySearch = false;
-    for (const resourceType of normalized) {
-        if (resourceType === "resource") {
-            searches.push({ resourceType, contextType: "resource" });
-        }
-        else if ((resourceType === "user" || resourceType === "agent") && !addedMemorySearch) {
-            searches.push({ resourceType: "user", contextType: "memory" });
-            addedMemorySearch = true;
-        }
-    }
-    return { resourceTypes: normalized, searches, skipped };
-}
 export class RecallTraceMemoryStore {
     maxEntries;
     entries = [];

package/dist/services/context-lifecycle-service.js

@@ -195,7 +195,73 @@ function isSessionNotFoundError(err) {
     const errorMessage = String(err);
     return errorMessage.includes("[NOT_FOUND]") && errorMessage.includes("Session not found");
 }
-export async function assembleOpenVikingSession({ sessionId, sessionKey, messages, tokenBudget, runtimeContext, isMainAssemble, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, queryConfigStore, traceRecorder, diag, roughEstimate, messageDigest, extractAgentMessageText, hasAutoRecallBlock, prependRecallToLatestUserMessage, }) {
+async function recallForAssemble(params, recallQuery) {
+    const { sessionId, sessionKey, cfg, getClient, resolveAgentId, queryConfigStore, logger, traceRecorder } = params;
+    const ovSessionId = openClawSessionToOvStorageId(sessionId, sessionKey);
+    const sender = extractRuntimeSenderId(params.runtimeContext);
+    const client = await getClient();
+    const routingRef = sessionId ?? sessionKey ?? ovSessionId;
+    const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
+    const actorPeerId = resolveOpenVikingActorPeerId({
+        peerRole: cfg.peer_role ?? "none",
+        senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
+        assistantPeerId: agentId,
+    });
+    const queryConfig = await queryConfigStore?.getEffective({
+        agentId,
+        sessionId,
+        sessionKey,
+        ovSessionId,
+    });
+    return buildAutoRecallContext({
+        cfg,
+        queryConfig,
+        client,
+        agentId,
+        actorPeerId,
+        queryText: recallQuery.query,
+        logger,
+        verbose: (message) => logger.info(message),
+        traceRecorder: traceRecorder,
+        sessionId,
+        sessionKey,
+        ovSessionId,
+        queryTruncated: recallQuery.truncated,
+        rawUserTextPreview: recallQuery.query,
+        // System additions are transient; the next turn must be able to recall the same URI.
+        dedupTurns: params.isMainAssemble ? 0 : undefined,
+    });
+}
+export async function assembleOpenVikingSession(params) {
+    const assembled = await assembleSessionContext(params);
+    // Current OpenClaw supplies the pending turn separately from history. Keep
+    // recalled context out of persisted messages and let the host own that turn.
+    if (!params.isMainAssemble || !params.cfg.autoRecall || !params.prompt ||
+        params.isBypassedSession(params)) {
+        return assembled;
+    }
+    const query = prepareRecallQuery(params.prompt);
+    if (query.query.length < 5)
+        return assembled;
+    try {
+        const recall = await recallForAssemble(params, query);
+        if (!recall.block)
+            return assembled;
+        const systemPromptAddition = [assembled.systemPromptAddition, recall.block].filter(Boolean).join("\n\n");
+        const estimatedTokens = assembled.estimatedTokens
+            + estimateTextTokens(systemPromptAddition)
+            - estimateTextTokens(assembled.systemPromptAddition ?? "");
+        if (estimatedTokens > params.tokenBudget)
+            return assembled;
+        return { ...assembled, systemPromptAddition, estimatedTokens };
+    }
+    catch (err) {
+        params.logger.warn?.(`openviking: auto-recall failed: ${String(err)}`);
+        return assembled;
+    }
+}
+async function assembleSessionContext(params) {
+    const { sessionId, sessionKey, messages, tokenBudget, runtimeContext, isMainAssemble, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, roughEstimate, messageDigest, extractAgentMessageText, hasAutoRecallBlock, prependRecallToLatestUserMessage, } = params;
     const latestMessage = messages.at(-1);
     const isTransformContextAssemble = !isMainAssemble;
     // Tool-loop calls do no recall work on non-user tails; avoid scanning the full history.
@@ -239,36 +305,7 @@ export async function assembleOpenVikingSession({ sessionId, sessionKey, message
                 `chars=${recallQuery.originalChars}->${recallQuery.finalChars})`);
         }
         try {
-            const client = await getClient();
-            const routingRef = sessionId ?? sessionKey ?? ovSessionId;
-            const agentId = resolveAgentId(routingRef, sessionKey, ovSessionId);
-            const actorPeerId = resolveOpenVikingActorPeerId({
-                peerRole: cfg.peer_role ?? "none",
-                senderPeerId: sanitizeOpenVikingPeerId(sender.senderId),
-                assistantPeerId: agentId,
-            });
-            const queryConfig = await queryConfigStore?.getEffective({
-                agentId,
-                sessionId,
-                sessionKey,
-                ovSessionId,
-            });
-            const recall = await buildAutoRecallContext({
-                cfg,
-                queryConfig,
-                client,
-                agentId,
-                actorPeerId,
-                queryText: recallQuery.query,
-                logger,
-                verbose: (message) => logger.info(message),
-                traceRecorder: traceRecorder,
-                sessionId,
-                sessionKey,
-                ovSessionId,
-                queryTruncated: recallQuery.truncated,
-                rawUserTextPreview: recallQuery.query,
-            });
+            const recall = await recallForAssemble(params, recallQuery);
             if (!recall.block) {
                 return assemblePassthrough({
                     diag,
@@ -501,7 +538,7 @@ function messageDigest(messages, maxCharsPerMsg = 2000) {
         };
     });
 }
-export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messages: rawMessages, prePromptMessageCount, isHeartbeat, tokenBudget, runtimeContext, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, }) {
+export async function afterTurnOpenVikingSession({ throwOnError = false, sessionId, sessionKey, messages: rawMessages, prePromptMessageCount, isHeartbeat, tokenBudget, runtimeContext, cfg, getClient, logger, resolveAgentId, rememberSessionAgentId, isBypassedSession, diag, }) {
     if (!cfg.autoCapture) {
         return;
     }
@@ -650,6 +687,9 @@ export async function afterTurnOpenVikingSession({ sessionId, sessionKey, messag
             senderIdFound: sender.found,
             senderId: sender.senderId ?? null,
         });
+        if (throwOnError) {
+            throw err;
+        }
     }
 }
 function validTokenCount(value) {

package/dist/services/setup/probe-service.js

@@ -0,0 +1,112 @@
+import { resolveOpenVikingRequestHeaders, } from "../../request-headers.js";
+export const defaultSetupNetworkTransport = (url, init) => fetch(url, init);
+export function createSetupNetworkProbes({ pluginVersion, compatRange, checkVersionCompatibility, transport = defaultSetupNetworkTransport, timeoutMs = 10_000, }) {
+    return {
+        async 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(), timeoutMs);
+            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 transport(sessionsUrl, {
+                    headers,
+                    signal: controller.signal,
+                });
+                if (response.ok) {
+                    return { keyType: "user_key", needsAccountId: false, needsUserId: false, detail: "API key has full user context" };
+                }
+                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),
+                        };
+                    }
+                    try {
+                        const probeHeaders = {
+                            "X-API-Key": apiKey,
+                            "X-OpenViking-Account": "__probe__",
+                            "X-OpenViking-User": "__probe__",
+                            ...configuredRequestHeaders,
+                        };
+                        const probe2 = await transport(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 checkServiceHealth(baseUrl, apiKey, configuredHeaders) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const configuredRequestHeaders = resolveOpenVikingRequestHeaders({ headers: configuredHeaders });
+                const headers = {};
+                if (apiKey) {
+                    headers["X-API-Key"] = apiKey;
+                }
+                Object.assign(headers, configuredRequestHeaders);
+                const response = await transport(`${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, compatRange };
+                    }
+                    catch {
+                        return { ok: true, version: "", error: "", compatibility: "unknown", pluginVersion, compatRange };
+                    }
+                }
+                return { ok: false, version: "", error: `HTTP ${response.status}`, compatibility: "unknown", pluginVersion, compatRange };
+            }
+            catch (err) {
+                return { ok: false, version: "", error: String(err instanceof Error ? err.message : err), compatibility: "unknown", pluginVersion, compatRange };
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        },
+    };
+}

package/dist/shared/recall-compress-core.mjs

@@ -83,11 +83,21 @@ export function repairDigestUris(digest, validUris = []) {
             lines.push(line);
             continue;
         }
+        let tokenized = line;
+        for (const uri of [...valid].sort((a, b) => b.length - a.length)) {
+            if (/\s/.test(uri))
+                tokenized = tokenized.split(uri).join(encodeURI(uri));
+        }
         let dropped = false;
-        const repaired = line.replace(/viking:\/\/[^\s<>"')\]]+/g, (uri) => {
-            if (validSet.has(uri))
-                return uri;
-            const nearest = nearestUri(uri, valid);
+        const repaired = tokenized.replace(/viking:\/\/[^\s<>"')\]]+/g, (uri) => {
+            let decoded = uri;
+            try {
+                decoded = decodeURI(uri);
+            }
+            catch { /* keep the original candidate */ }
+            if (validSet.has(decoded))
+                return decoded;
+            const nearest = nearestUri(decoded, valid);
             if (nearest)
                 return nearest;
             dropped = true;
@@ -146,13 +156,14 @@ async function writeCache(path, value) {
     }
     catch { /* best effort */ }
 }
-export async function compressRecallContext({ query, rendered, entries = [], cfg = {}, runCompressor, cachePath = "", now = 0, }) {
+export async function compressRecallContext({ query, rendered, shortContext = rendered, entries = [], cfg = {}, runCompressor, cachePath = "", now = 0, }) {
     const input = String(rendered || "").trim();
     if (!input)
         return { status: COMPRESS_EMPTY, context: "" };
     const minChars = Math.max(0, Number(cfg.recallCompressMinInputChars ?? 1500));
-    if (input.length < minChars)
-        return { status: COMPRESS_OK, context: input };
+    if (input.length < minChars) {
+        return { status: COMPRESS_OK, context: String(shortContext ?? input).trim() };
+    }
     const maxInputChars = Math.max(1000, Number(cfg.recallCompressMaxInputChars || 18000));
     const maxBullets = Math.max(1, Number(cfg.recallCompressMaxBullets || 6));
     const key = recallDigestCacheKey({
@@ -164,7 +175,9 @@ export async function compressRecallContext({ query, rendered, entries = [], cfg
     });
     const cached = await readCache(cachePath);
     if (cached?.key === key && typeof cached.digest === "string") {
-        return { status: COMPRESS_OK, context: cached.digest };
+        const digest = normalizeCompressedContext(cached.digest, 4000, maxBullets);
+        if (digest)
+            return { status: COMPRESS_OK, context: digest };
     }
     const prompt = buildRecallCompressionPrompt({
         query,
@@ -178,9 +191,10 @@ export async function compressRecallContext({ query, rendered, entries = [], cfg
     if (!normalized)
         return { status: COMPRESS_EMPTY, context: "" };
     const validUris = entries.map((entry) => entry?.uri).filter(Boolean);
-    const digest = repairDigestUris(normalized, validUris.length
+    const repaired = repairDigestUris(normalized, validUris.length
         ? validUris
         : (input.match(/viking:\/\/[^\s<>"']+/g) || []));
+    const digest = normalizeCompressedContext(repaired, 4000, maxBullets);
     if (!digest)
         return { status: COMPRESS_FAILED, context: "" };
     await writeCache(cachePath, { key, digest, updatedAt: now || 0 });

package/index.ts

@@ -95,6 +95,7 @@ type ToolContext = {
 };
 
 type OpenClawPluginApi = {
+  runtime?: { version?: string };
   pluginConfig?: unknown;
   openVikingTransport?: HttpTransport;
   logger: PluginLogger;

package/package.json

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

package/plugin/openviking-context-engine-registration.ts

@@ -1,4 +1,5 @@
 export type OpenVikingContextEngineRegistrationApi = {
+  runtime?: { version?: string };
   registerContextEngine?: (id: string, factory: () => unknown) => void;
 };
 
@@ -22,6 +23,7 @@ export type OpenVikingContextEngineCreateParams<
   id: string;
   name: string;
   version: string;
+  hostVersion?: string;
   cfg: TCfg;
   logger: TLogger;
   getClient: () => Promise<TClient>;
@@ -80,6 +82,7 @@ export function registerOpenVikingContextEngine<
       id: deps.plugin.id,
       name: deps.plugin.name,
       version: deps.version,
+      hostVersion: deps.api.runtime?.version,
       cfg: deps.cfg,
       logger: deps.logger,
       getClient: deps.getClient,

package/recall-trace.ts

@@ -1,7 +1,7 @@
 import { appendFile, mkdir, readFile, readdir, unlink } from "node:fs/promises";
 import { join } from "node:path";
 
-export type RecallResourceType = "resource" | "session" | "user" | "agent";
+import type { RecallResourceType } from "./registries/recall-resource-types.js";
 
 export type RecallTraceSource = "auto_recall" | "memory_recall" | "ov_search" | "ov_archive_search";
 
@@ -27,7 +27,9 @@ export type RecallTraceEntry = {
   agentId?: string;
   source: RecallTraceSource;
   operationType: RecallTraceOperationType;
-  resourceTypes: RecallResourceType[];
+  // "session" labels archive-grep traces over session history; recall targets
+  // stay in the registry's narrower union and never include it.
+  resourceTypes: Array<RecallResourceType | "session">;
   trigger: {
     rawUserTextPreview?: string;
     query: string;
@@ -92,78 +94,6 @@ export type RecallTraceFlushResult = {
   warnings: string[];
 };
 
-const ALLOWED_RESOURCE_TYPES: RecallResourceType[] = ["resource", "user", "agent"];
-const DEFAULT_RESOURCE_TYPES: RecallResourceType[] = ["user", "agent"];
-
-function toResourceTypeEntries(value: unknown): string[] {
-  if (Array.isArray(value)) {
-    return value
-      .filter((entry): entry is string => typeof entry === "string")
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  }
-  if (typeof value === "string") {
-    return value
-      .split(/[,\n]/)
-      .map((entry) => entry.trim())
-      .filter(Boolean);
-  }
-  return [];
-}
-
-export function normalizeResourceTypes(value: unknown): RecallResourceType[] {
-  const entries = toResourceTypeEntries(value);
-  if (entries.length === 0) {
-    return [...DEFAULT_RESOURCE_TYPES];
-  }
-
-  const seen = new Set<RecallResourceType>();
-  const normalized: RecallResourceType[] = [];
-  const invalid: string[] = [];
-  for (const entry of entries) {
-    if ((ALLOWED_RESOURCE_TYPES as string[]).includes(entry)) {
-      const typed = entry as RecallResourceType;
-      if (!seen.has(typed)) {
-        seen.add(typed);
-        normalized.push(typed);
-      }
-    } else {
-      invalid.push(entry);
-    }
-  }
-
-  if (invalid.length > 0) {
-    throw new Error(`invalid resourceTypes: ${invalid.join(", ")}`);
-  }
-
-  return normalized.length > 0 ? normalized : [...DEFAULT_RESOURCE_TYPES];
-}
-
-export function resolveRecallSearchPlan(
-  resourceTypes: unknown,
-  _ctx: { ovSessionId?: string; agentId?: string },
-): {
-  resourceTypes: RecallResourceType[];
-  searches: Array<{ resourceType: RecallResourceType; targetUri?: string; contextType: "memory" | "resource" }>;
-  skipped: Array<{ resourceType: RecallResourceType; reason: "missing_session" }>;
-} {
-  const normalized = normalizeResourceTypes(resourceTypes);
-  const searches: Array<{ resourceType: RecallResourceType; targetUri?: string; contextType: "memory" | "resource" }> = [];
-  const skipped: Array<{ resourceType: RecallResourceType; reason: "missing_session" }> = [];
-  let addedMemorySearch = false;
-
-  for (const resourceType of normalized) {
-    if (resourceType === "resource") {
-      searches.push({ resourceType, contextType: "resource" });
-    } else if ((resourceType === "user" || resourceType === "agent") && !addedMemorySearch) {
-      searches.push({ resourceType: "user", contextType: "memory" });
-      addedMemorySearch = true;
-    }
-  }
-
-  return { resourceTypes: normalized, searches, skipped };
-}
-
 export class RecallTraceMemoryStore {
   private readonly maxEntries: number;
   private readonly entries: RecallTraceEntry[] = [];
@@ -183,7 +113,7 @@ export class RecallTraceMemoryStore {
     const limit = Math.max(1, Math.floor(query.limit ?? 20));
     const turn = query.turn ?? "latest";
     const resourceTypes = query.resourceTypes && query.resourceTypes.length > 0
-      ? new Set(query.resourceTypes)
+      ? new Set<string>(query.resourceTypes)
       : undefined;
 
     const filtered = this.entries