@openviking/openclaw-plugin 2026.9.1 → 2026.9.2

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");
 }

package/dist/client.js

@@ -7,6 +7,7 @@ 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";
 function userSessionUri(sessionId) {
     return `viking://~/sessions/${encodeURIComponent(sessionId)}`;
 }
@@ -215,6 +216,59 @@ export class OpenVikingClient {
             body: JSON.stringify(body),
         }, undefined, actorPeerId);
     }
+    async searchContext(query, options = {}) {
+        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("/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, actorPeerId) {
         return this.request(`/api/v1/content/read?uri=${encodeURIComponent(uri)}`, {}, undefined, actorPeerId);
     }

package/dist/config.js

@@ -6,7 +6,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;
@@ -547,7 +549,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",
@@ -574,7 +576,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",
@@ -585,7 +587,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/dist/shared/recall-compress-core.mjs

@@ -0,0 +1,188 @@
+// GENERATED FROM examples/memory-plugin-shared/lib. DO NOT EDIT.
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export const NO_RELEVANT_MEMORY = "NO_RELEVANT_MEMORY";
+export const DIGEST_HEADER = "OpenViking memory digest:";
+const COMPRESS_OK = "ok";
+const COMPRESS_EMPTY = "empty";
+const COMPRESS_FAILED = "failed";
+// Medium-constraint prompt: state the goal and two structural floors, but no hard
+// bullet-length contract. Hard per-bullet limits pin the digest to headline
+// density; leaving it unconstrained lets small models rewrite long URIs into dead
+// links, which the URI repair below cleans up.
+export function buildRecallCompressionPrompt({ query, rendered, maxBullets = 6 }) {
+    return `You are a memory relevance compressor utility.
+Do not use any tools. Do not investigate. Only transform the given text.
+
+User query:
+${query}
+
+Retrieved OpenViking context fragments:
+${rendered}
+
+Write a memory digest for a coding agent about to answer that query. Keep the
+concrete facts (paths, identifiers, decisions, constraints); drop pleasantries
+and conversational filler.
+
+Format rules:
+- Group related facts by topic, one bullet per topic, at most ${maxBullets} bullets.
+- Start every bullet with "- ".
+- End every bullet with its source, copied verbatim from the fragments above:
+  "来源：viking://..." or "source: viking://...". Never edit, shorten, or invent a URI.
+- Output the digest body only. No preamble, no closing remark.
+
+If nothing above is relevant to the query, output exactly: ${NO_RELEVANT_MEMORY}`;
+}
+function editDistance(a, b) {
+    if (a === b)
+        return 0;
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    let prev = Array.from({ length: cols }, (_, i) => i);
+    for (let i = 1; i < rows; i += 1) {
+        const cur = [i];
+        for (let j = 1; j < cols; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            cur[j] = Math.min(cur[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+        }
+        prev = cur;
+    }
+    return prev[cols - 1];
+}
+function nearestUri(candidate, validUris) {
+    let best = "";
+    let bestDistance = Infinity;
+    for (const uri of validUris) {
+        const distance = editDistance(candidate, uri);
+        if (distance < bestDistance) {
+            best = uri;
+            bestDistance = distance;
+        }
+    }
+    // Only repair near-misses; an unrelated hallucination is dropped instead.
+    const tolerance = Math.max(4, Math.floor(candidate.length * 0.25));
+    return bestDistance <= tolerance ? best : "";
+}
+/**
+ * Small models occasionally mangle long URIs. Snap every cited URI back onto the
+ * set the server actually returned, and drop bullets whose citation cannot be
+ * recovered so the digest never carries a dead link.
+ */
+export function repairDigestUris(digest, validUris = []) {
+    const text = String(digest || "");
+    if (!text)
+        return "";
+    const valid = validUris.map((uri) => String(uri || "").trim()).filter(Boolean);
+    if (!valid.length)
+        return text;
+    const validSet = new Set(valid);
+    const lines = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim().startsWith("- ")) {
+            lines.push(line);
+            continue;
+        }
+        let dropped = false;
+        const repaired = line.replace(/viking:\/\/[^\s<>"')\]]+/g, (uri) => {
+            if (validSet.has(uri))
+                return uri;
+            const nearest = nearestUri(uri, valid);
+            if (nearest)
+                return nearest;
+            dropped = true;
+            return uri;
+        });
+        if (!dropped)
+            lines.push(repaired);
+    }
+    return lines.join("\n").trim();
+}
+export function normalizeCompressedContext(raw, maxChars = 4000, maxBullets = 6) {
+    const text = String(raw || "").trim();
+    if (!text)
+        return null;
+    if (text.toUpperCase() === NO_RELEVANT_MEMORY)
+        return "";
+    const bullets = text.split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^[-*]\s+/.test(line) && line.includes("viking://"))
+        .slice(0, Math.max(1, maxBullets))
+        .map((line) => `- ${line.replace(/^[-*]\s+/, "").slice(0, 500).trim()}`);
+    if (!bullets.length)
+        return null;
+    return (`${DIGEST_HEADER}\n${bullets.join("\n")}`).slice(0, Math.max(100, maxChars));
+}
+export function recallDigestCacheKey({ query = "", rendered = "", entries = [], maxInputChars = 18000, maxBullets = 6, } = {}) {
+    const uris = entries.map((entry) => String(entry?.uri || "").trim()).filter(Boolean).sort();
+    const source = JSON.stringify({
+        version: 2,
+        query: String(query),
+        rendered: String(rendered).slice(0, maxInputChars),
+        uris,
+        maxInputChars,
+        maxBullets,
+    });
+    return createHash("sha256").update(source).digest("hex");
+}
+async function readCache(path) {
+    if (!path)
+        return null;
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(path, value) {
+    if (!path)
+        return;
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        const tmp = `${path}.tmp`;
+        await writeFile(tmp, JSON.stringify(value));
+        await rename(tmp, path);
+    }
+    catch { /* best effort */ }
+}
+export async function compressRecallContext({ query, 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 };
+    const maxInputChars = Math.max(1000, Number(cfg.recallCompressMaxInputChars || 18000));
+    const maxBullets = Math.max(1, Number(cfg.recallCompressMaxBullets || 6));
+    const key = recallDigestCacheKey({
+        query,
+        rendered: input,
+        entries,
+        maxInputChars,
+        maxBullets,
+    });
+    const cached = await readCache(cachePath);
+    if (cached?.key === key && typeof cached.digest === "string") {
+        return { status: COMPRESS_OK, context: cached.digest };
+    }
+    const prompt = buildRecallCompressionPrompt({
+        query,
+        rendered: input.slice(0, maxInputChars),
+        maxBullets,
+    });
+    const raw = await runCompressor(prompt);
+    const normalized = normalizeCompressedContext(raw, 4000, maxBullets);
+    if (normalized === null)
+        return { status: COMPRESS_FAILED, context: "" };
+    if (!normalized)
+        return { status: COMPRESS_EMPTY, context: "" };
+    const validUris = entries.map((entry) => entry?.uri).filter(Boolean);
+    const digest = repairDigestUris(normalized, validUris.length
+        ? validUris
+        : (input.match(/viking:\/\/[^\s<>"']+/g) || []));
+    if (!digest)
+        return { status: COMPRESS_FAILED, context: "" };
+    await writeCache(cachePath, { key, digest, updatedAt: now || 0 });
+    return { status: COMPRESS_OK, context: digest };
+}