@openviking/openclaw-plugin 2026.6.2 → 2026.6.17-dev.2

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

@@ -0,0 +1,233 @@
+import { Type } from "@sinclair/typebox";
+function toTraceResult(item, resultType, deps) {
+    return {
+        uri: item.uri,
+        resourceType: deps.inferRecallResourceType(item.uri),
+        category: item.category,
+        score: item.score,
+        level: item.level,
+        abstractPreview: deps.previewText(item.abstract || item.overview, deps.cfg.traceRecallPreviewChars),
+        resultType,
+    };
+}
+export function registerOpenVikingMemoryRecallTools(deps) {
+    deps.registerTool((ctx) => ({
+        name: "memory_recall",
+        label: "Memory Recall (OpenViking)",
+        description: "Search long-term memories from OpenViking. Use when you need past user preferences, facts, or decisions.",
+        parameters: Type.Object({
+            query: Type.String({ description: "Search query" }),
+            limit: Type.Optional(Type.Number({ description: "Max results (default: plugin config)" })),
+            scoreThreshold: Type.Optional(Type.Number({ description: "Minimum score (0-1, default: plugin config)" })),
+            targetUri: Type.Optional(Type.String({ description: "Search scope URI (default: plugin config)" })),
+            resourceTypes: Type.Optional(Type.Array(Type.String({ description: "resource, user, or agent; used when targetUri is omitted" }))),
+        }),
+        async execute(_toolCallId, params) {
+            if (deps.isBypassedSession(ctx)) {
+                return deps.makeBypassedToolResult("memory_recall");
+            }
+            const session = deps.resolvePluginSessionRouting(ctx);
+            const { query } = params;
+            const queryConfig = await deps.queryConfigStore.getEffective(deps.toQueryConfigContext(session), {
+                recallLimit: typeof params.limit === "number" ? params.limit : undefined,
+                scoreThreshold: typeof params.scoreThreshold === "number" ? params.scoreThreshold : undefined,
+                targetUri: typeof params.targetUri === "string" ? params.targetUri : undefined,
+                resourceTypes: Object.prototype.hasOwnProperty.call(params, "resourceTypes")
+                    ? params.resourceTypes
+                    : undefined,
+            });
+            const limit = queryConfig.recallLimit;
+            const scoreThreshold = queryConfig.scoreThreshold;
+            const targetUri = typeof params.targetUri === "string"
+                ? params.targetUri
+                : queryConfig.targetUri;
+            const requestedResourceTypes = Object.prototype.hasOwnProperty.call(params, "resourceTypes")
+                ? params.resourceTypes
+                : queryConfig.resourceTypes;
+            const requestLimit = queryConfig.candidateLimit;
+            const recallClient = await deps.getClient();
+            if (deps.cfg.logFindRequests) {
+                deps.logger.info?.(`openviking: memory_recall X-OpenViking-Actor-Peer="${session.agentId}" ` +
+                    `(plugin defaultAgentId="${recallClient.getDefaultAgentId()}" is unused when session context is present)`);
+            }
+            let result;
+            let memoryRecallSearches = [];
+            if (targetUri) {
+                result = await recallClient.find(query, {
+                    targetUri,
+                    limit: requestLimit,
+                    scoreThreshold: 0,
+                    actorPeerId: session.agentId,
+                });
+                const traceResults = [
+                    ...(result.memories ?? []).map((item) => toTraceResult(item, "memory", deps)),
+                    ...(result.resources ?? []).map((item) => toTraceResult(item, "resource", deps)),
+                ].slice(0, deps.cfg.traceRecallMaxResultsPerSearch);
+                memoryRecallSearches = [{
+                        resourceType: deps.inferRecallResourceType(targetUri) ?? "resource",
+                        targetUriInput: targetUri,
+                        targetUriResolved: targetUri,
+                        limit: requestLimit,
+                        scoreThreshold,
+                        durationMs: 0,
+                        total: result.total ?? traceResults.length,
+                        results: traceResults,
+                    }];
+            }
+            else {
+                const searchPlan = deps.resolveRecallSearchPlan(requestedResourceTypes ?? deps.cfg.recallTargetTypes, {
+                    ovSessionId: session.ovSessionId,
+                    agentId: session.agentId,
+                });
+                const settled = await Promise.allSettled(searchPlan.searches.map((search) => recallClient.find(query, {
+                    targetUri: search.targetUri,
+                    limit: requestLimit,
+                    scoreThreshold: 0,
+                    contextType: search.contextType,
+                    actorPeerId: session.agentId,
+                })));
+                const allMemories = [];
+                for (let index = 0; index < settled.length; index += 1) {
+                    const s = settled[index];
+                    const search = searchPlan.searches[index];
+                    if (s.status === "fulfilled") {
+                        allMemories.push(...(s.value.memories ?? []), ...(s.value.resources ?? []));
+                        memoryRecallSearches.push({
+                            resourceType: search.resourceType,
+                            targetUriInput: search.targetUri,
+                            targetUriResolved: search.targetUri,
+                            limit: requestLimit,
+                            scoreThreshold,
+                            durationMs: 0,
+                            total: s.value.total ?? ((s.value.memories ?? []).length + (s.value.resources ?? []).length),
+                            results: [
+                                ...(s.value.memories ?? []).map((item) => toTraceResult(item, "memory", deps)),
+                                ...(s.value.resources ?? []).map((item) => toTraceResult(item, "resource", deps)),
+                            ].slice(0, deps.cfg.traceRecallMaxResultsPerSearch),
+                        });
+                    }
+                    else {
+                        memoryRecallSearches.push({
+                            resourceType: search.resourceType,
+                            targetUriInput: search.targetUri,
+                            targetUriResolved: search.targetUri,
+                            limit: requestLimit,
+                            scoreThreshold,
+                            durationMs: 0,
+                            total: 0,
+                            results: [],
+                            error: s.reason instanceof Error ? s.reason.message : 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);
+                result = {
+                    memories: leafOnly,
+                    total: leafOnly.length,
+                };
+            }
+            const leafOnly = (result.memories ?? []).filter((m) => !m.level || m.level === 2);
+            const processed = deps.postProcessMemories(leafOnly, {
+                limit: requestLimit,
+                scoreThreshold,
+            });
+            const memories = deps.pickMemoriesForInjection(processed, limit, query, scoreThreshold, {
+                weights: queryConfig.rankingWeights,
+                categoryWeights: queryConfig.categoryWeights,
+                resourceTypeWeights: queryConfig.resourceTypeWeights,
+            });
+            const candidateTraceResults = leafOnly
+                .map((item) => toTraceResult(item, deps.inferRecallResourceType(item.uri) === "resource" ? "resource" : "memory", deps))
+                .slice(0, deps.cfg.traceRecallMaxResultsPerSearch);
+            const traceResourceTypes = [...new Set((targetUri ? [deps.inferRecallResourceType(targetUri)] : memoryRecallSearches.map((search) => search.resourceType))
+                    .filter((resourceType) => Boolean(resourceType)))];
+            const recordMemoryRecallTrace = async (injectedUris) => {
+                await deps.traceRecorder?.recordAndFlush?.({
+                    schemaVersion: "1.0",
+                    traceId: deps.createTraceId("memory_recall"),
+                    ts: Date.now(),
+                    sessionId: session.sessionId,
+                    sessionKey: session.sessionKey,
+                    ovSessionId: session.ovSessionId,
+                    agentId: session.agentId,
+                    source: "memory_recall",
+                    operationType: "semantic_find",
+                    resourceTypes: traceResourceTypes.length > 0 ? traceResourceTypes : ["resource"],
+                    trigger: deps.boundTraceQuery(query, deps.cfg.traceRecallQueryMaxChars),
+                    searches: memoryRecallSearches.length > 0 ? memoryRecallSearches : [{
+                            resourceType: "resource",
+                            targetUriInput: targetUri,
+                            targetUriResolved: targetUri ?? "viking://resources",
+                            limit: requestLimit,
+                            scoreThreshold,
+                            durationMs: 0,
+                            total: result.total ?? leafOnly.length,
+                            results: candidateTraceResults,
+                        }],
+                    selected: memories.map((item) => ({
+                        uri: item.uri,
+                        resourceType: deps.inferRecallResourceType(item.uri),
+                        category: item.category,
+                        score: item.score,
+                        abstractPreview: deps.previewText(item.abstract || item.overview, deps.cfg.traceRecallPreviewChars),
+                        injected: injectedUris.has(item.uri),
+                        displayed: injectedUris.has(item.uri),
+                    })),
+                    stats: {
+                        candidateCount: leafOnly.length,
+                        selectedCount: memories.length,
+                        injectedCount: injectedUris.size,
+                    },
+                });
+            };
+            if (memories.length === 0) {
+                await recordMemoryRecallTrace(new Set());
+                return {
+                    content: [{ type: "text", text: "No relevant OpenViking memories found." }],
+                    details: { count: 0, total: result.total ?? 0, scoreThreshold },
+                };
+            }
+            const { lines: memoryLines } = await deps.buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.agentId), {
+                recallPreferAbstract: false,
+                recallMaxInjectedChars: queryConfig.maxInjectedChars,
+            });
+            if (memoryLines.length === 0) {
+                await recordMemoryRecallTrace(new Set());
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No complete OpenViking memories fit recallMaxInjectedChars=${queryConfig.maxInjectedChars}.`,
+                        },
+                    ],
+                    details: {
+                        count: 0,
+                        memories,
+                        total: result.total ?? memories.length,
+                        scoreThreshold,
+                        requestLimit,
+                        recallMaxInjectedChars: queryConfig.maxInjectedChars,
+                    },
+                };
+            }
+            await recordMemoryRecallTrace(new Set(memories.slice(0, memoryLines.length).map((item) => item.uri)));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Found ${memoryLines.length} memories:\n\n${memoryLines.join("\n")}`,
+                    },
+                ],
+                details: {
+                    count: memoryLines.length,
+                    memories,
+                    total: result.total ?? memories.length,
+                    scoreThreshold,
+                    requestLimit,
+                    recallMaxInjectedChars: queryConfig.maxInjectedChars,
+                },
+            };
+        },
+    }), { name: "memory_recall" });
+}

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

@@ -0,0 +1,199 @@
+import { Type } from "@sinclair/typebox";
+import { clampScore, postProcessMemories } from "../memory-ranking.js";
+import { isMemoryUri } from "../routing/memory-uri.js";
+function totalCommitMemories(r) {
+    const m = r.memories_extracted;
+    if (!m || typeof m !== "object")
+        return 0;
+    return Object.values(m).reduce((sum, n) => sum + (n ?? 0), 0);
+}
+export function registerOpenVikingMemoryTools(deps) {
+    deps.registerTool((ctx) => ({
+        name: "memory_store",
+        label: "Memory Store (OpenViking)",
+        description: "Store text in OpenViking memory pipeline by writing to a session and running memory extraction.",
+        parameters: Type.Object({
+            text: Type.String({ description: "Information to store as memory source text" }),
+            role: Type.Optional(Type.String({ description: "Session role, default user" })),
+            sessionId: Type.Optional(Type.String({ description: "Existing OpenViking session ID" })),
+        }),
+        async execute(_toolCallId, params) {
+            if (deps.isBypassedSession(ctx)) {
+                return deps.makeBypassedToolResult("memory_store");
+            }
+            const session = deps.resolvePluginSessionRouting(ctx);
+            const { text } = params;
+            const role = typeof params.role === "string"
+                ? params.role
+                : "user";
+            const explicitSessionId = typeof params.sessionId === "string" &&
+                params.sessionId.trim()
+                ? deps.normalizeSessionId(params.sessionId)
+                : undefined;
+            if (deps.logFindRequests) {
+                deps.logger.info?.(`openviking: memory_store invoked (textLength=${text?.length ?? 0}, sessionId=${explicitSessionId ?? "auto"})`);
+            }
+            let sessionId = explicitSessionId;
+            let usedTempSession = false;
+            try {
+                const client = await deps.getClient();
+                if (!sessionId) {
+                    sessionId = deps.createTempSessionId();
+                    usedTempSession = true;
+                }
+                const roleId = role === "user" ? deps.toRoleId(deps.extractSenderId(ctx)) : undefined;
+                await client.addSessionMessage(sessionId, role, [{ type: "text", text }], session.agentId, undefined, roleId);
+                const commitResult = await client.commitSession(sessionId, {
+                    wait: true,
+                    agentId: session.agentId,
+                    keepRecentCount: 0,
+                });
+                const memoriesCount = totalCommitMemories(commitResult);
+                if (commitResult.status === "failed") {
+                    deps.logger.warn(`openviking: memory_store commit failed (sessionId=${sessionId}): ${commitResult.error ?? "unknown"}`);
+                    return {
+                        content: [{ type: "text", text: `Memory extraction failed for session ${sessionId}: ${commitResult.error ?? "unknown"}` }],
+                        details: {
+                            action: "failed",
+                            sessionId,
+                            status: "failed",
+                            error: commitResult.error,
+                            usedTempSession,
+                        },
+                    };
+                }
+                if (commitResult.status === "timeout") {
+                    deps.logger.warn(`openviking: memory_store commit timed out (sessionId=${sessionId}), task_id=${commitResult.task_id ?? "none"}. Memories may still be extracting in background.`);
+                    return {
+                        content: [{ type: "text", text: `Memory extraction timed out for session ${sessionId}. It may still complete in the background (task_id=${commitResult.task_id ?? "none"}).` }],
+                        details: {
+                            action: "timeout",
+                            sessionId,
+                            status: "timeout",
+                            taskId: commitResult.task_id,
+                            usedTempSession,
+                        },
+                    };
+                }
+                if (memoriesCount === 0) {
+                    deps.logger.warn(`openviking: memory_store committed but 0 memories extracted (sessionId=${sessionId}). ` +
+                        "Check OpenViking server logs for embedding/extract errors (e.g. 401 API key, or extraction pipeline).");
+                }
+                else {
+                    deps.logger.info?.(`openviking: memory_store committed, memories=${memoriesCount}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Stored in OpenViking session ${sessionId} and committed ${memoriesCount} memories.`,
+                        },
+                    ],
+                    details: {
+                        action: "stored",
+                        sessionId,
+                        memoriesCount,
+                        status: commitResult.status,
+                        archived: commitResult.archived ?? false,
+                        usedTempSession,
+                    },
+                };
+            }
+            catch (err) {
+                deps.logger.warn(`openviking: memory_store failed: ${String(err)}`);
+                throw err;
+            }
+        },
+    }), { name: "memory_store" });
+    deps.registerTool((ctx) => ({
+        name: "memory_forget",
+        label: "Memory Forget (OpenViking)",
+        description: "Forget memory by URI, or search then delete when a strong single match is found.",
+        parameters: Type.Object({
+            uri: Type.Optional(Type.String({ description: "Exact memory URI to delete" })),
+            query: Type.Optional(Type.String({ description: "Search query to find memory URI" })),
+            targetUri: Type.Optional(Type.String({ description: "Search scope URI (default: plugin config)" })),
+            limit: Type.Optional(Type.Number({ description: "Search limit (default: 5)" })),
+            scoreThreshold: Type.Optional(Type.Number({ description: "Minimum score (0-1, default: plugin config)" })),
+        }),
+        async execute(_toolCallId, params) {
+            if (deps.isBypassedSession(ctx)) {
+                return deps.makeBypassedToolResult("memory_forget");
+            }
+            const session = deps.resolvePluginSessionRouting(ctx);
+            const client = await deps.getClient();
+            const uri = params.uri;
+            if (uri) {
+                if (!isMemoryUri(uri)) {
+                    return {
+                        content: [{ type: "text", text: `Refusing to delete non-memory URI: ${uri}` }],
+                        details: { action: "rejected", uri },
+                    };
+                }
+                await client.deleteUri(uri, session.agentId);
+                return {
+                    content: [{ type: "text", text: `Forgotten: ${uri}` }],
+                    details: { action: "deleted", uri },
+                };
+            }
+            const query = params.query;
+            if (!query) {
+                return {
+                    content: [{ type: "text", text: "Provide uri or query." }],
+                    details: { error: "missing_param" },
+                };
+            }
+            const limit = typeof params.limit === "number"
+                ? Math.max(1, Math.floor(params.limit))
+                : 5;
+            const scoreThreshold = typeof params.scoreThreshold === "number"
+                ? Math.max(0, Math.min(1, params.scoreThreshold))
+                : deps.defaultRecallScoreThreshold;
+            const targetUri = typeof params.targetUri === "string"
+                ? params.targetUri
+                : deps.defaultTargetUri;
+            const requestLimit = Math.max(limit * 4, 20);
+            const result = await client.find(query, {
+                targetUri,
+                limit: requestLimit,
+                scoreThreshold: 0,
+            }, session.agentId);
+            const candidates = postProcessMemories(result.memories ?? [], {
+                limit: requestLimit,
+                scoreThreshold,
+                leafOnly: true,
+            }).filter((item) => isMemoryUri(item.uri));
+            if (candidates.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No matching leaf memory candidates found. Try a more specific query.",
+                        },
+                    ],
+                    details: { action: "none", scoreThreshold },
+                };
+            }
+            const top = candidates[0];
+            if (candidates.length === 1 && clampScore(top.score) >= 0.85) {
+                await client.deleteUri(top.uri, session.agentId);
+                return {
+                    content: [{ type: "text", text: `Forgotten: ${top.uri}` }],
+                    details: { action: "deleted", uri: top.uri, score: top.score ?? 0 },
+                };
+            }
+            const list = candidates
+                .map((item) => `- ${item.uri} (${(clampScore(item.score) * 100).toFixed(0)}%)`)
+                .join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Found ${candidates.length} candidates. Specify uri:\n${list}`,
+                    },
+                ],
+                details: { action: "candidates", candidates, scoreThreshold, requestLimit },
+            };
+        },
+    }), { name: "memory_forget" });
+}

package/dist/plugin/openviking-query-config-command.js

@@ -0,0 +1,203 @@
+function tokenizeCommandArgs(args) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const ch = args[i];
+        const next = args[i + 1];
+        if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === "\\") {
+            const shouldEscape = quote === '"'
+                ? next === '"' || next === "\\"
+                : !quote && Boolean(next && (/\s/.test(next) || next === '"' || next === "'"));
+            if (shouldEscape) {
+                escaping = true;
+                continue;
+            }
+            current += ch;
+            continue;
+        }
+        if ((ch === '"' || ch === "'") && (!quote || quote === ch)) {
+            quote = quote ? null : ch;
+            continue;
+        }
+        if (!quote && /\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escaping) {
+        current += "\\";
+    }
+    if (quote) {
+        throw new Error("Unterminated quoted argument");
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function parseFlagArgs(args) {
+    const tokens = tokenizeCommandArgs(args);
+    const positionals = [];
+    const flags = new Map();
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const raw = token.slice(2);
+        if (!raw) {
+            continue;
+        }
+        const eqIndex = raw.indexOf("=");
+        if (eqIndex >= 0) {
+            flags.set(raw.slice(0, eqIndex), raw.slice(eqIndex + 1));
+            continue;
+        }
+        const next = tokens[i + 1];
+        if (next && !next.startsWith("--")) {
+            flags.set(raw, next);
+            i += 1;
+        }
+        else {
+            flags.set(raw, true);
+        }
+    }
+    return { positionals, flags };
+}
+function getStringFlag(flags, name) {
+    const value = flags.get(name);
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function getNumberFlag(flags, name) {
+    const raw = getStringFlag(flags, name);
+    if (!raw) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw new Error(`--${name} must be a number`);
+    }
+    return value;
+}
+function getOptionalBoolFlag(flags, name) {
+    const value = flags.get(name);
+    if (value === undefined)
+        return undefined;
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+        return false;
+    throw new Error(`--${name} must be a boolean`);
+}
+function parseNumberMapFlag(flags, name) {
+    const raw = getStringFlag(flags, name);
+    if (!raw)
+        return undefined;
+    const result = {};
+    for (const item of raw.split(",")) {
+        const [key, rawValue, ...rest] = item.split("=");
+        const trimmedKey = key?.trim();
+        const trimmedValue = rawValue?.trim();
+        if (!trimmedKey || !trimmedValue || rest.length > 0) {
+            throw new Error(`--${name} must use key=value pairs separated by commas`);
+        }
+        const value = Number(trimmedValue);
+        if (!Number.isFinite(value)) {
+            throw new Error(`--${name} value for ${trimmedKey} must be a number`);
+        }
+        result[trimmedKey] = value;
+    }
+    return result;
+}
+function parseQueryConfigPatch(flags) {
+    const patch = {};
+    const numberFields = [
+        ["recallLimit", "recallLimit"],
+        ["candidateLimit", "candidateLimit"],
+        ["candidateMultiplier", "candidateMultiplier"],
+        ["scoreThreshold", "scoreThreshold"],
+        ["maxInjectedChars", "maxInjectedChars"],
+        ["ovSearchLimit", "ovSearchLimit"],
+    ];
+    for (const [flag, field] of numberFields) {
+        if (flags.has(flag)) {
+            patch[field] = getNumberFlag(flags, flag);
+        }
+    }
+    const resourceTypes = getStringFlag(flags, "resourceTypes");
+    if (resourceTypes)
+        patch.resourceTypes = resourceTypes;
+    const targetUri = getStringFlag(flags, "targetUri");
+    if (targetUri)
+        patch.targetUri = targetUri;
+    const recallPreferAbstract = getOptionalBoolFlag(flags, "recallPreferAbstract");
+    if (recallPreferAbstract !== undefined)
+        patch.recallPreferAbstract = recallPreferAbstract;
+    const rankingWeights = parseNumberMapFlag(flags, "weight") ?? parseNumberMapFlag(flags, "rankingWeights");
+    if (rankingWeights)
+        patch.rankingWeights = rankingWeights;
+    const categoryWeights = parseNumberMapFlag(flags, "categoryWeight") ?? parseNumberMapFlag(flags, "categoryWeights");
+    if (categoryWeights)
+        patch.categoryWeights = categoryWeights;
+    const resourceTypeWeights = parseNumberMapFlag(flags, "resourceTypeWeight") ?? parseNumberMapFlag(flags, "resourceTypeWeights");
+    if (resourceTypeWeights)
+        patch.resourceTypeWeights = resourceTypeWeights;
+    return patch;
+}
+export function createOpenVikingQueryConfigCommandHandler(deps) {
+    return async (ctx) => {
+        const parsed = parseFlagArgs(ctx.args ?? "");
+        const action = parsed.positionals[0] ?? "get";
+        const session = deps.resolvePluginSessionRouting(ctx);
+        const scope = getStringFlag(parsed.flags, "scope") === "claw" ? "claw" : "session";
+        const queryCtx = deps.toQueryConfigContext(session);
+        if (action === "get") {
+            const effective = await deps.queryConfigStore.getEffective(queryCtx);
+            return { text: JSON.stringify({ scope, effective }, null, 2), details: { scope, effective } };
+        }
+        if (action === "set") {
+            const patch = parseQueryConfigPatch(parsed.flags);
+            const { params, warnings } = deps.normalizeRuntimeQueryParams(patch);
+            if (Object.keys(params).length === 0) {
+                throw new Error("No query config parameters provided for /ov-query-config set");
+            }
+            await deps.queryConfigStore.set(scope, queryCtx, params);
+            const effective = await deps.queryConfigStore.getEffective(queryCtx);
+            return {
+                text: `Updated OpenViking query config (${scope}).${warnings.length ? ` Warnings: ${warnings.join("; ")}` : ""}`,
+                details: { scope, params, warnings, effective },
+            };
+        }
+        if (action === "unset") {
+            const fields = parsed.positionals.slice(1);
+            if (fields.length === 0)
+                throw new Error("Usage: /ov-query-config unset <field...> [--scope session|claw]");
+            await deps.queryConfigStore.unset(scope, queryCtx, fields);
+            const effective = await deps.queryConfigStore.getEffective(queryCtx);
+            return { text: `Unset OpenViking query config fields (${scope}): ${fields.join(", ")}`, details: { scope, fields, effective } };
+        }
+        if (action === "reset") {
+            await deps.queryConfigStore.reset(scope, queryCtx);
+            const effective = await deps.queryConfigStore.getEffective(queryCtx);
+            return { text: `Reset OpenViking query config (${scope}).`, details: { scope, effective } };
+        }
+        throw new Error("Usage: /ov-query-config get|set|unset|reset [--scope session|claw] [--recallLimit N] [--candidateLimit N] [--scoreThreshold N] [--resourceTypes user,agent]");
+    };
+}