@unblocklabs/unblock-memory 0.7.4 → 0.8.0

package/README.md

@@ -2,8 +2,9 @@
 
 Workspace-native memory for OpenClaw, powered internally by `@unblocklabs/qmd`.
 It keeps one warm QMD store per agent and exposes `memory_search` and `memory_get`.
-Ordinary recall is local vector search over semantic chunks: no query expansion,
-reranker or TypeSafe key is required.
+Recall combines BM25 and vector candidates, then independently ranks complete
+passages with TypeSafe. The agent supplies both queries; no query generation or
+"do we need memory?" gate runs for explicit search. A TypeSafe key is required.
 
 ## Start here
 
@@ -38,7 +39,7 @@ Optional installation from source:
 
 | Capability | What it does | Default / prerequisite |
 | --- | --- | --- |
-| [Search and reads](docs/retrieval.md#search-and-read) | Vector recall, then exact indexed source reads | Available with the memory plugin; files only unless more corpora are configured |
+| [Search and reads](docs/retrieval.md#search-and-read) | BM25 + vector recall with TypeSafe ranking, then exact indexed reads | Search requires TypeSafe; reads stay local; files only unless more corpora are configured |
 | [Session indexing](docs/retrieval.md#sessions) | Makes past user/assistant exchanges searchable | Opt-in corpus; channel/group by default, DMs explicitly included |
 | [Skill Whisperer](docs/retrieval.md#skill-whisperer) | Suggests one relevant skill; never invokes it | Off; explicit skills corpus; TypeSafe optional |
 | [Memory Whisperer](docs/retrieval.md#memory-whisperer) | Injects up to two useful historical excerpts; query generation via resident API | Off; approved corpora + TypeSafe + query API credential |
@@ -52,10 +53,9 @@ Optional installation from source:
 | [Session memory extraction](docs/extraction.md) | Luna proposes lasting facts; Jev verifies them; optional QMD search | Off; approved session types + TypeSafe + host LLM permission; shadow-only by default |
 | [Compaction memory flush](docs/configuration.md#compaction-memory-writes) | Supplies the host an append-only daily-memory write plan | Offered unless the host's memory-flush setting is false; separate from whisperers |
 
-**Search is not one interchangeable API:** plugin `memory_search` is vector-only;
-standalone QMD `query` is hybrid vector + BM25 with TypeSafe ranking.
-They have separate configuration/index boundaries. See
-[search modes and the xsearch migration](docs/retrieval.md#qmd-search-modes).
+**One agent search pipeline:** `memory_search` and Memory Whisperer share
+candidate discovery, passage rendering, deduplication and TypeSafe ranking.
+Whisperer additionally generates queries and applies its automatic recall/delivery policy.
 
 ## Configuration and operating guides
 
@@ -73,9 +73,9 @@ They have separate configuration/index boundaries. See
 - [Session extraction](docs/extraction.md): incremental/backfill runs, configurable
   acceptance thresholds, shadow evaluation, and publishing lasting facts to search.
 
-The shared TypeSafe integration defaults on, but its features are opt-in.
-A key activates only features already enabled. Ordinary search and People
-Whisperer's injection stay local; Skill Whisperer has a local fallback.
+The shared TypeSafe integration defaults on. Ordinary search requires a key;
+other TypeSafe features remain opt-in. People Whisperer's injection stays local;
+Skill Whisperer has a local fallback.
 [Provider gates and failure behavior](docs/configuration.md#feature-gates-and-fallbacks)
 differ by feature.
 

package/dist/src/contracts.d.ts

@@ -31,7 +31,7 @@ export type SessionSearchFilter = {
 export type MemoryRequestContext = Pick<OpenClawPluginToolContext, "sessionKey" | "sessionId" | "messageChannel" | "agentAccountId" | "nativeChannelId" | "deliveryContext">;
 export type CorpusSearchOptions = Omit<NonNullable<Parameters<MemorySearchManagerContract["search"]>[1]>, "lexicalOnly"> & {
     corpora?: readonly string[];
-    /** Internal vector-hint budget; oversized matched chunks are omitted, never sliced. */
+    /** Internal passage budget; oversized matched chunks are omitted, never sliced. */
     maxSnippetChars?: number;
     sessionFilter?: SessionSearchFilter;
     requestContext?: MemoryRequestContext;

package/dist/src/diagnostics.d.ts

@@ -1,12 +1,13 @@
 import { RetrievalTelemetry } from "./retrieval-telemetry.js";
 type Whisperer = "skill" | "memory";
-type Outcome = "missing_key" | "typesafe_disabled" | "no_candidates" | "rejected" | "cooldown" | "emitted" | "failed" | "timed_out" | "cancelled" | "unavailable" | "payload_limit" | "redundancy_unavailable" | "recall_not_needed" | "queries_generated" | "judge_candidate_failed";
+type Outcome = "missing_key" | "typesafe_disabled" | "no_candidates" | "rejected" | "cooldown" | "emitted" | "failed" | "timed_out" | "cancelled" | "unavailable" | "payload_limit" | "redundancy_unavailable" | "recall_not_needed" | "queries_generated" | "judge_candidate_failed" | "input_too_large";
 /** Process-local, content-free and bounded. Agent IDs are keys, never included in snapshots. */
 export declare class WhispererDiagnostics {
     #private;
     static shared(): WhispererDiagnostics;
     record(agentId: string, whisperer: Whisperer, outcome: Outcome): void;
     measureMemory(agentId: string, observation: Parameters<RetrievalTelemetry["record"]>[1]): void;
+    measureSearch(agentId: string, observation: Parameters<RetrievalTelemetry["record"]>[1]): void;
     snapshot(agentId: string): {
         skill: {
             cancelled?: number | undefined;
@@ -24,6 +25,7 @@ export declare class WhispererDiagnostics {
             recall_not_needed?: number | undefined;
             queries_generated?: number | undefined;
             judge_candidate_failed?: number | undefined;
+            input_too_large?: number | undefined;
         };
         memory: {
             cancelled?: number | undefined;
@@ -41,6 +43,7 @@ export declare class WhispererDiagnostics {
             recall_not_needed?: number | undefined;
             queries_generated?: number | undefined;
             judge_candidate_failed?: number | undefined;
+            input_too_large?: number | undefined;
         };
         telemetry: {
             scope: string;
@@ -50,6 +53,7 @@ export declare class WhispererDiagnostics {
                     outcomes: {
                         ok?: number | undefined;
                         cancelled?: number | undefined;
+                        partial?: number | undefined;
                         skipped?: number | undefined;
                         failed?: number | undefined;
                         empty?: number | undefined;

package/dist/src/diagnostics.js

@@ -24,6 +24,9 @@ export class WhispererDiagnostics {
     measureMemory(agentId, observation) {
         this.#entry(agentId).telemetry.record("memoryWhisperer", observation);
     }
+    measureSearch(agentId, observation) {
+        this.#entry(agentId).telemetry.record("memorySearch", observation);
+    }
     snapshot(agentId) {
         const entry = this.#agents.get(agentId);
         return { skill: { ...entry?.counts.skill }, memory: { ...entry?.counts.memory },

package/dist/src/manager.d.ts

@@ -56,6 +56,7 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
                     outcomes: {
                         ok?: number | undefined;
                         cancelled?: number | undefined;
+                        partial?: number | undefined;
                         skipped?: number | undefined;
                         failed?: number | undefined;
                         empty?: number | undefined;
@@ -219,8 +220,8 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
         };
     }): MaintenanceTask | undefined;
     search(query: string, opts?: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
-    /** Whisperer-only discovery: exact trained recipe, no query-conditioned reranker or merged cap. */
-    searchWhisperer(queries: QueryPair, opts: Pick<CorpusSearchOptions, "corpora" | "signal" | "maxSnippetChars">): Promise<CorpusMemorySearchResult[]>;
+    /** Shared discovery: exact trained recipe, scoped before either retrieval lane. */
+    searchCandidates(queries: QueryPair, opts: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
     searchSkills(query: string, minScore: number, limit: number): Promise<SkillSearchCandidate[]>;
     readFile(params: {
         relPath: string;

package/dist/src/manager.js

@@ -831,8 +831,8 @@ export class QmdMemoryManager {
         opts?.signal?.throwIfAborted();
         return this.#renderSearchHits(hits, store, opts);
     }
-    /** Whisperer-only discovery: exact trained recipe, no query-conditioned reranker or merged cap. */
-    async searchWhisperer(queries, opts) {
+    /** Shared discovery: exact trained recipe, scoped before either retrieval lane. */
+    async searchCandidates(queries, opts) {
         return this.#enqueue(async () => {
             opts.signal?.throwIfAborted();
             const collections = this.#collectionNames(opts.corpora);
@@ -840,12 +840,18 @@ export class QmdMemoryManager {
                 return [];
             if (this.#sessions && collections.includes(this.#sessions.collection))
                 await this.#refreshSessionMetadata();
+            const sessions = this.#sessions;
+            let allowedPaths = opts.sessionFilter && sessions && collections.includes(sessions.collection)
+                ? sessionAllowedPaths(this.#sessionMetadata, sessions.collection, opts.sessionFilter) : undefined;
+            if (collections.includes(EXTRACTED_COLLECTION)) {
+                allowedPaths = { ...allowedPaths, [EXTRACTED_COLLECTION]: this.#currentExtracted(undefined, opts.sessionFilter).map(extractedPath) };
+            }
             const store = await this.#getAnalysisStore();
             const hits = new Map();
             // Serialize native QMD work. Cancellation prevents further queries/collections.
             for (const lane of ["lex", "vec"]) {
                 opts.signal?.throwIfAborted();
-                for (const hit of await trainingCandidates(store, queries[lane], collections, lane, opts.signal)) {
+                for (const hit of await trainingCandidates(store, queries[lane], collections, lane, opts.signal, allowedPaths)) {
                     const key = JSON.stringify([hit.file, hit.bestChunkPos, hit.bestChunk]);
                     if (!hits.has(key))
                         hits.set(key, { file: hit.file, body: hit.body, bestChunk: hit.bestChunk,

package/dist/src/memory-search.d.ts

@@ -0,0 +1,31 @@
+import type { CorpusMemorySearchResult, CorpusSearchOptions } from "./contracts.js";
+import type { QueryConversation, QueryPair } from "./query-contract.js";
+export type MemoryCandidateManager = {
+    searchCandidates(queries: QueryPair, options: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
+};
+export declare function memoryPassageId(text: string): string;
+export type MemorySearchObservation = {
+    retrievalMs: number;
+    judgeMs: number;
+    candidates: number;
+    eligible: number;
+    requestsSucceeded: number;
+    requestsFailed: number;
+};
+/** Both entry points use the same complete passages and independent usefulness judgments. */
+export declare function searchMemory(manager: MemoryCandidateManager, queries: QueryPair, options: CorpusSearchOptions & {
+    apiKey: string;
+    timeoutMs: number;
+    conversation: QueryConversation;
+    asOf?: string;
+    minUsefulness?: number;
+    excludedPassages?: ReadonlyMap<string, number>;
+    onCandidates?: (observation: MemorySearchObservation) => void;
+    onJudgment?: (event: {
+        candidateIndex: number;
+        elapsedMs: number;
+        error?: unknown;
+    }) => void;
+}): Promise<MemorySearchObservation & {
+    results: CorpusMemorySearchResult[];
+}>;

package/dist/src/memory-search.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { MEMORY_PASSAGE_CHARS, duplicateMemoryPassage } from "./memory-passage.js";
+import { judgeMemoryPassage, memoryUsefulnessRequest } from "./typesafe.js";
+export function memoryPassageId(text) {
+    return createHash("sha256").update(text.replace(/\s+/gu, " ").trim()).digest("hex");
+}
+/** Both entry points use the same complete passages and independent usefulness judgments. */
+export async function searchMemory(manager, queries, options) {
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const asOf = options.asOf ?? new Date().toISOString();
+    const started = performance.now();
+    const hits = await manager.searchCandidates(queries, {
+        corpora: options.corpora, sessionFilter: options.sessionFilter, requestContext: options.requestContext,
+        sources: options.sources, signal, maxSnippetChars: MEMORY_PASSAGE_CHARS,
+    });
+    signal?.throwIfAborted();
+    const observation = { retrievalMs: performance.now() - started, judgeMs: 0,
+        candidates: hits.length, eligible: 0, requestsSucceeded: 0, requestsFailed: 0 };
+    const candidates = [];
+    for (const hit of hits) {
+        // Defense in depth before disclosing passages to the external judge.
+        if (options.corpora && !options.corpora.includes("all") && !options.corpora.includes(hit.corpus))
+            continue;
+        const excerpt = hit.snippet.trim();
+        if (!excerpt || excerpt.length > MEMORY_PASSAGE_CHARS || options.excludedPassages?.has(memoryPassageId(excerpt)) ||
+            duplicateMemoryPassage({ ...hit, text: excerpt }, candidates.map(candidate => ({ ...candidate, text: candidate.snippet }))))
+            continue;
+        candidates.push({ ...hit, snippet: excerpt });
+    }
+    observation.eligible = candidates.length;
+    options.onCandidates?.(observation);
+    const judgeStarted = performance.now();
+    const judged = (await Promise.all(candidates.map(async (hit, candidateIndex) => {
+        const requestStarted = performance.now();
+        try {
+            const { probability } = await judgeMemoryPassage(memoryUsefulnessRequest(options.conversation, {
+                excerpt: hit.snippet, corpus: hit.corpus, sourcePath: hit.path,
+                dates: [...new Set(hit.sessionMessages?.flatMap(message => message.timestamp ? [message.timestamp] : [])
+                        ?? (hit.messageTimestamp ? [hit.messageTimestamp] : []))],
+            }, asOf), options);
+            signal?.throwIfAborted();
+            observation.requestsSucceeded++;
+            options.onJudgment?.({ candidateIndex, elapsedMs: performance.now() - requestStarted });
+            // Discovery reciprocal ranks are not vector similarity or usefulness.
+            const { vectorScore: _vectorScore, textScore: _textScore, ...result } = hit;
+            return [{ ...result, score: probability }];
+        }
+        catch (error) {
+            if (signal?.aborted)
+                return [];
+            observation.requestsFailed++;
+            options.onJudgment?.({ candidateIndex, elapsedMs: performance.now() - requestStarted, error });
+            return [];
+        }
+    }))).flat();
+    signal?.throwIfAborted();
+    observation.judgeMs = performance.now() - judgeStarted;
+    return { ...observation, results: judged.filter(hit => hit.score >= (options.minUsefulness ?? 0.7))
+            .sort((a, b) => b.score - a.score).slice(0, options.maxResults ?? 5) };
+}

package/dist/src/memory-whisperer.d.ts

@@ -1,17 +1,13 @@
 import type { OpenClawConfig, OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
 import type { UnblockMemoryConfig } from "./config.js";
-import type { CorpusMemorySearchResult, CorpusSearchOptions } from "./contracts.js";
 import type { WhispererDiagnostics } from "./diagnostics.js";
-import type { QueryPair } from "./query-contract.js";
+import { type MemoryCandidateManager } from "./memory-search.js";
 type MemoryWhispererRuntime = {
     getMemorySearchManager(params: {
         cfg: OpenClawConfig;
         agentId: string;
     }): Promise<{
-        manager: {
-            search(query: string, opts?: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
-            searchWhisperer?(queries: QueryPair, opts: Pick<CorpusSearchOptions, "corpora" | "signal" | "maxSnippetChars">): Promise<CorpusMemorySearchResult[]>;
-        } | null;
+        manager: MemoryCandidateManager | null;
     }>;
 };
 export declare function registerMemoryWhisperer(api: OpenClawPluginApi, runtime: MemoryWhispererRuntime, config: UnblockMemoryConfig["memoryWhisperer"], typesafe: UnblockMemoryConfig["typesafe"], diagnostics?: WhispererDiagnostics): Parameters<typeof api.on<"before_prompt_build">>[1] | undefined;

package/dist/src/memory-whisperer.js

@@ -1,14 +1,9 @@
-import { createHash } from "node:crypto";
-import { judgeMemoryPassage, memoryUsefulnessRequest } from "./typesafe.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
 import { complementaryIndices, reviewMemoryRedundancy } from "./typesafe-review.js";
 import { ApiQueryGenerator, QueryApiError, queryConversation } from "./query-generator.js";
 import { judgeTrainingInput, TRAINING_GATE_THRESHOLD } from "./training-gate.js";
-import { MEMORY_PASSAGE_CHARS, duplicateMemoryPassage } from "./memory-passage.js";
-const MAX_EXCERPT_CHARS = MEMORY_PASSAGE_CHARS;
-function fingerprint(text) {
-    return createHash("sha256").update(text.replace(/\s+/gu, " ").trim()).digest("hex");
-}
+import { QueryInputBudgetError } from "./query-contract.js";
+import { searchMemory, memoryPassageId } from "./memory-search.js";
 export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnostics) {
     if (!config.enabled || !typesafe.enabled)
         return;
@@ -29,7 +24,7 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
         const started = performance.now();
         const asOf = new Date().toISOString();
         const measurement = { outcome: "skipped", elapsedMs: 0 };
-        let stage = "credentials", reason = "completed";
+        let stage = "input", reason = "completed";
         let recallProbability, queryCount;
         let requestsSucceeded = 0, requestsFailed = 0;
         const log = (level, event, fields) => api.logger[level]("unblock-memory memory_whisperer " + JSON.stringify({ event, agentId, runId, sessionId, stage, ...fields }));
@@ -56,6 +51,8 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
             signal.addEventListener("abort", onAbort, { once: true });
         });
         const run = async () => {
+            const conversation = queryConversation(event.prompt, event.messages);
+            stage = "credentials";
             const apiKey = await resolveTypeSafeApiKey(typesafe);
             if (signal.aborted)
                 return;
@@ -64,8 +61,6 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
                 diagnostics?.record(agentId, "memory", "missing_key");
                 return;
             }
-            stage = "input";
-            const conversation = queryConversation(event.prompt, event.messages);
             const gateStarted = performance.now();
             const gateSignal = AbortSignal.any([signal, AbortSignal.timeout(typesafe.timeoutMs)]);
             // Speculation is intentional: neither model generation nor QMD waits for the recall judgment.
@@ -125,81 +120,46 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
                     diagnostics?.record(agentId, "memory", "unavailable");
                     return;
                 }
-                const retrievalStarted = performance.now();
-                if (!manager.searchWhisperer)
-                    throw new Error("V2 Whisperer retrieval is unavailable");
-                const hits = await manager.searchWhisperer(queries, { corpora, signal, maxSnippetChars: MAX_EXCERPT_CHARS });
-                if (signal.aborted)
+                const search = await searchMemory(manager, queries, {
+                    corpora, signal, apiKey, timeoutMs: typesafe.timeoutMs, conversation, asOf,
+                    minUsefulness: config.minUsefulness, maxResults: 4, excludedPassages: state.recent,
+                    onCandidates: observation => {
+                        measurement.retrievalMs = observation.retrievalMs;
+                        measurement.candidates = observation.candidates;
+                        measurement.eligible = observation.eligible;
+                        measurement.outcome = "empty";
+                        stage = "judgment";
+                    },
+                    onJudgment: ({ candidateIndex, elapsedMs, error }) => {
+                        const fields = { stage: "judgment", candidateIndex, elapsedMs, timeoutMs: typesafe.timeoutMs };
+                        if (error !== undefined) {
+                            requestsFailed++;
+                            diagnostics?.record(agentId, "memory", "judge_candidate_failed");
+                            log("warn", "candidate_failed", { ...fields, ...failureFields(error) });
+                        }
+                        else {
+                            requestsSucceeded++;
+                            log("info", "candidate_completed", fields);
+                        }
+                    },
+                });
+                if (signal.aborted || sessions.get(key) !== state)
                     return;
-                measurement.retrievalMs = performance.now() - retrievalStarted;
-                measurement.candidates = hits.length;
-                const candidates = [];
-                for (const hit of hits) {
-                    // Enforce scope again before sending anything to the external judge.
-                    if (!corpora.includes(hit.corpus))
-                        continue;
-                    const excerpt = hit.snippet.trim();
-                    // Retrieval bounds context around a complete match. Never replace it
-                    // with a prefix if a manager returns an oversized result.
-                    if (excerpt.length > MAX_EXCERPT_CHARS)
-                        continue;
-                    const id = fingerprint(excerpt);
-                    if (!excerpt || state.recent.has(id) || duplicateMemoryPassage({ ...hit, text: excerpt }, candidates.map(candidate => ({ ...candidate.hit, text: candidate.excerpt }))))
-                        continue;
-                    candidates.push({ hit, excerpt, id });
-                }
-                measurement.eligible = candidates.length;
-                measurement.outcome = "empty";
-                if (!candidates.length) {
+                measurement.judgeMs = search.judgeMs;
+                if (!search.eligible) {
                     reason = "no_candidates";
                     diagnostics?.record(agentId, "memory", "no_candidates");
                     return;
                 }
-                stage = "judgment";
-                const judgeStarted = performance.now();
-                // Every eligible passage gets its own request; no request sees another candidate.
-                const judged = (await Promise.all(candidates.map(async (candidate, candidateIndex) => {
-                    const requestStarted = performance.now();
-                    const fields = { stage: "judgment", candidateIndex,
-                        timeoutMs: typesafe.timeoutMs };
-                    try {
-                        const { hit, excerpt } = candidate;
-                        const { probability } = await judgeMemoryPassage(memoryUsefulnessRequest(conversation, {
-                            excerpt, corpus: hit.corpus, sourcePath: hit.path,
-                            dates: [...new Set(hit.sessionMessages?.flatMap(message => message.timestamp ? [message.timestamp] : [])
-                                    ?? (hit.messageTimestamp ? [hit.messageTimestamp] : []))],
-                        }, asOf), { apiKey, timeoutMs: typesafe.timeoutMs, signal });
-                        if (signal.aborted)
-                            return [];
-                        requestsSucceeded++;
-                        log("info", "candidate_completed", { ...fields, elapsedMs: performance.now() - requestStarted });
-                        // Failed candidates have no score, not zero. Keep each score with its own source.
-                        return [{ ...candidate, probability }];
-                    }
-                    catch (error) {
-                        if (signal.aborted)
-                            return [];
-                        requestsFailed++;
-                        diagnostics?.record(agentId, "memory", "judge_candidate_failed");
-                        log("warn", "candidate_failed", { ...fields, ...failureFields(error), elapsedMs: performance.now() - requestStarted });
-                        return [];
-                    }
-                }))).flat();
-                if (signal.aborted || sessions.get(key) !== state)
-                    return;
-                measurement.judgeMs = performance.now() - judgeStarted;
                 if (!await gate || signal.aborted || sessions.get(key) !== state)
                     return;
-                if (!judged.length) {
+                if (!search.requestsSucceeded) {
                     reason = "all_candidates_failed";
                     measurement.outcome = "failed";
                     diagnostics?.record(agentId, "memory", "failed");
                     return;
                 }
-                const ranked = judged
-                    .filter(candidate => candidate.probability >= config.minUsefulness)
-                    .sort((a, b) => b.probability - a.probability)
-                    .slice(0, 4);
+                const ranked = search.results.map(hit => ({ hit, excerpt: hit.snippet, id: memoryPassageId(hit.snippet) }));
                 let selected = ranked.slice(0, config.maxHints);
                 if (!selected.length) {
                     reason = "rejected";
@@ -254,6 +214,12 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
                 return await Promise.race([run(), aborted]);
             }
             catch (error) {
+                if (error instanceof QueryInputBudgetError) {
+                    reason = "input_too_large";
+                    measurement.outcome = "skipped";
+                    diagnostics?.record(agentId, "memory", "input_too_large");
+                    return;
+                }
                 reason = "stage_failed";
                 measurement.outcome = "failed";
                 if (!signal.aborted) {

package/dist/src/plugin.js

@@ -17,9 +17,13 @@ import { registerResponseAudit } from "./response-runtime.js";
 import { registerInsideOut } from "./inside-out-runtime.js";
 import { registerMemoryTraining } from "./training-runtime.js";
 import { resolveTimezone } from "./session-projector.js";
+import { searchMemory } from "./memory-search.js";
+import { prepareQueryConversation, QueryInputBudgetError } from "./query-contract.js";
+import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { registerExtraction } from "./extraction-runtime.js";
 const searchParameters = Type.Object({
-    query: Type.String({ pattern: "\\S" }),
+    bm25Query: Type.String({ pattern: "\\S", description: "Distinctive names, identifiers and keywords for BM25 retrieval." }),
+    vectorQuery: Type.String({ pattern: "\\S", description: "Natural-language question describing the information needed; also the intent used to judge usefulness." }),
     corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), {
         minItems: 1, description: 'Configured corpus names; default is all non-skill corpora. Use ["all"] alone for explicit all-corpora recall.',
     })),
@@ -38,7 +42,7 @@ const searchParameters = Type.Object({
         conversationId: Type.Optional(Type.String({ pattern: "\\S" })),
     }, { additionalProperties: false, description: "Restricts session documents only; selected file corpora remain eligible. Not an audience access control." })),
     maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Maximum hits; default 5." })),
-    minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1, description: "Minimum vector similarity; default 0.3. Not confidence in factual truth." })),
+    minUsefulness: Type.Optional(Type.Number({ minimum: 0, maximum: 1, description: "Minimum TypeSafe usefulness probability; default 0.7. Not confidence in factual truth." })),
 }, { additionalProperties: false });
 const getParameters = Type.Object({
     path: Type.String({ pattern: "\\S" }),
@@ -49,45 +53,79 @@ const syncSessionsParameters = Type.Object({
     force: Type.Optional(Type.Boolean()),
 }, { additionalProperties: false });
 const syncStatusParameters = Type.Object({}, { additionalProperties: false });
-function createSearchTool(runtime, ctx) {
+function createSearchTool(runtime, ctx, typesafe, diagnostics) {
     const active = getContext(ctx);
     if (!active)
         return null;
     return {
         name: "memory_search",
         label: "Memory Search",
-        description: "Search this agent's configured memory corpora with local vector retrieval, not QMD's hybrid query. Skills are excluded. Session snippets are arrays of messages (type, name, timestamp, body; partial when incomplete); file snippets are strings. Results are evidence leads; inspect source context with memory_get. Empty results or errors do not prove absence of a fact.",
+        description: "Search this agent's configured memory corpora with BM25 and vector queries, then TypeSafe usefulness ranking. Supply keywords in bm25Query and the information needed in vectorQuery; no query generation or recall gate runs. Queries and candidate passages are sent to TypeSafe. Skills are excluded. Session snippets are message arrays; file snippets are strings. Inspect source context with memory_get. Empty results or errors do not prove absence of a fact.",
         parameters: searchParameters,
         async execute(_toolCallId, params, signal) {
-            const { query: untrimmedQuery, corpora, sessionFilter, maxResults, minScore, } = Value.Parse(searchParameters, params);
-            const query = untrimmedQuery.trim();
-            const { manager, error } = await runtime.getMemorySearchManager(active);
-            if (!manager)
-                return jsonResult({ results: [], error: error ?? "memory unavailable" });
-            const results = await manager.search(query, {
-                corpora: corpora?.map((corpus) => corpus.trim()),
-                sessionFilter,
-                maxResults,
-                minScore,
-                signal,
-                requestContext: active.requestContext,
-            });
-            // Compact only the public tool response; internal ranking and consumers keep
-            // full-precision scores and the host's source/citation compatibility fields.
-            const payload = {
-                results: results.map(({ source: _source, citation: _citation, session, sessionMessages, ...result }) => ({
-                    ...result,
-                    snippet: result.corpus === "sessions" ? sessionMessages ?? [{ body: result.snippet, partial: true }] : result.snippet,
-                    score: Number(result.score.toFixed(2)),
-                    ...(result.vectorScore !== undefined ? { vectorScore: Number(result.vectorScore.toFixed(2)) } : {}),
-                    ...(result.textScore !== undefined ? { textScore: Number(result.textScore.toFixed(2)) } : {}),
-                    ...(session ? { session: { ...session, startedAt: new Date(session.startedAt).toISOString() } } : {}),
-                })),
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(payload) }],
-                details: payload,
-            };
+            const started = performance.now();
+            const measurement = { outcome: "failed", elapsedMs: 0 };
+            try {
+                signal?.throwIfAborted();
+                const { bm25Query, vectorQuery, corpora, sessionFilter, maxResults, minUsefulness, } = Value.Parse(searchParameters, params);
+                const queries = { lex: bm25Query.trim(), vec: vectorQuery.trim() };
+                // Reject oversized explicit inputs before credential resolution or any service call.
+                prepareQueryConversation([], queries.lex);
+                const { conversation } = prepareQueryConversation([], queries.vec);
+                const apiKey = await resolveTypeSafeApiKey(typesafe);
+                if (!apiKey) {
+                    measurement.outcome = "skipped";
+                    return jsonResult({ results: [], error: "TypeSafe API key not configured or TypeSafe disabled" });
+                }
+                const { manager, error } = await runtime.getMemorySearchManager(active);
+                if (!manager)
+                    return jsonResult({ results: [], error: error ?? "memory unavailable" });
+                const search = await searchMemory(manager, queries, {
+                    corpora: corpora?.map((corpus) => corpus.trim()),
+                    sessionFilter,
+                    maxResults,
+                    minUsefulness,
+                    apiKey, timeoutMs: typesafe.timeoutMs, conversation,
+                    signal,
+                    requestContext: active.requestContext,
+                    onCandidates: ({ retrievalMs, candidates, eligible }) => {
+                        Object.assign(measurement, { retrievalMs, candidates, eligible });
+                    },
+                });
+                measurement.judgeMs = search.judgeMs;
+                measurement.results = search.results.length;
+                measurement.contextChars = search.results.reduce((sum, hit) => sum + hit.snippet.length, 0);
+                if (search.eligible && !search.requestsSucceeded)
+                    return jsonResult({ results: [], error: "All memory usefulness judgments failed" });
+                measurement.outcome = search.requestsFailed ? "partial" : search.results.length ? "ok" : "empty";
+                // Compact only the public tool response; internal ranking and consumers keep
+                // full-precision scores and the host's source/citation compatibility fields.
+                const payload = {
+                    ...(search.requestsFailed ? { warning: `${search.requestsFailed} candidate usefulness judgments failed; results are partial` } : {}),
+                    results: search.results.map(({ source: _source, citation: _citation, session, sessionMessages, ...result }) => ({
+                        ...result,
+                        snippet: result.corpus === "sessions" ? sessionMessages ?? [{ body: result.snippet, partial: true }] : result.snippet,
+                        score: Number(result.score.toFixed(2)),
+                        ...(session ? { session: { ...session, startedAt: new Date(session.startedAt).toISOString() } } : {}),
+                    })),
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(payload) }],
+                    details: payload,
+                };
+            }
+            catch (error) {
+                if (error instanceof QueryInputBudgetError)
+                    measurement.outcome = "skipped";
+                throw error;
+            }
+            finally {
+                measurement.elapsedMs = performance.now() - started;
+                if (signal?.aborted)
+                    measurement.outcome = signal.reason instanceof Error && signal.reason.name === "TimeoutError"
+                        ? "timed_out" : "cancelled";
+                diagnostics.measureSearch(active.agentId, measurement);
+            }
         },
     };
 }
@@ -455,7 +493,7 @@ export function registerUnblockMemory(api) {
         skill: registerSkillWhisperer(api, runtime, config.skillWhisperer, config.typesafe, diagnostics),
         people: peopleWhisperer,
     });
-    api.registerTool((ctx) => createSearchTool(runtime, ctx), { names: ["memory_search"] });
+    api.registerTool((ctx) => createSearchTool(runtime, ctx, config.typesafe, diagnostics), { names: ["memory_search"] });
     api.registerTool((ctx) => createGetTool(runtime, ctx), { names: ["memory_get"] });
     api.registerTool((ctx) => createSyncSessionsTool(runtime, ctx), {
         names: ["memory_sync_sessions"],

package/dist/src/response-episodes.d.ts

@@ -1,5 +1,5 @@
 import type { ResponseAuditConfig } from "./response-config.js";
-export declare const RESPONSE_EXTRACTOR_VERSION = 5;
+export declare const RESPONSE_EXTRACTOR_VERSION = 6;
 type Row = {
     seq: number;
     eventJson: string;

package/dist/src/response-episodes.js

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import { AgentTranscriptReader } from "./agent-transcript.js";
 import { messageText } from "./whisperer-context.js";
 import { responseUserText } from "./response-text.js";
-export const RESPONSE_EXTRACTOR_VERSION = 5;
+export const RESPONSE_EXTRACTOR_VERSION = 6;
 const MAX_EVENTS = 2000, MAX_SESSION_BYTES = 2_000_000, MAX_EPISODE_CHARS = 24_000;
 function record(v) {
     return v !== null && typeof v === "object" && !Array.isArray(v) ? v : undefined;

package/dist/src/response-text.js

@@ -43,6 +43,19 @@ export function responseUserText(input, senderId) {
         const marker = markers[0];
         contextLimited = meta.history_truncated === true || rest.slice(0, marker.index).includes("Chat history since last reply:");
         text = rest.slice(marker.index + marker[0].length).trim();
+        // OpenClaw appends channel metadata after the current Slack message. Only
+        // recognize its exact boundary inside an already validated envelope.
+        const contexts = [...text.matchAll(/\r?\n\r?\nContext: ⟦openclaw:ctx⟧\r?\n/g)];
+        if (contexts.length) {
+            if (contexts.length !== 1)
+                return undefined;
+            const context = contexts[0];
+            const suffix = text.slice(context.index + context[0].length);
+            if (!suffix.trim() || suffix.includes("⟦openclaw:ctx⟧") || /^Chat history since last reply:/m.test(suffix))
+                return undefined;
+            text = text.slice(0, context.index).trim();
+            contextLimited = true;
+        }
     }
     else {
         const from = /^From: [^\r\n]+ \(([^()\r\n]+)\)\r?\n/.exec(text);

package/dist/src/retrieval-telemetry.d.ts

@@ -1,5 +1,5 @@
-type RetrievalOperation = "vector" | "memoryWhisperer";
-type RetrievalOutcome = "ok" | "empty" | "failed" | "cancelled" | "timed_out" | "skipped";
+type RetrievalOperation = "vector" | "memoryWhisperer" | "memorySearch";
+type RetrievalOutcome = "ok" | "partial" | "empty" | "failed" | "cancelled" | "timed_out" | "skipped";
 declare const fields: readonly ["elapsedMs", "retrievalMs", "judgeMs", "gateMs", "generationMs", "candidates", "eligible", "results", "contextChars"];
 type Field = typeof fields[number];
 export type RetrievalObservation = {
@@ -18,6 +18,7 @@ export declare class RetrievalTelemetry {
                 outcomes: {
                     ok?: number | undefined;
                     cancelled?: number | undefined;
+                    partial?: number | undefined;
                     skipped?: number | undefined;
                     failed?: number | undefined;
                     empty?: number | undefined;

package/dist/src/review-tools.js

@@ -32,7 +32,7 @@ export function registerReviewTools(api, runtime, config, diagnostics) {
             return null;
         return {
             name: "memory_diagnostics", label: "Memory Diagnostics",
-            description: "Read content-free whisperer counters, configuration state, projection version and index readiness. Does not call TypeSafe.",
+            description: "Read content-free manual-search and whisperer telemetry, configuration state, projection version and index readiness. Does not call TypeSafe.",
             parameters: noParameters,
             async execute(_id, params) {
                 Value.Parse(noParameters, params);

package/dist/src/training-candidates.d.ts

@@ -1,7 +1,7 @@
-import type { QMDStore } from "@unblocklabs/qmd";
+import type { AllowedDocumentPaths, QMDStore } from "@unblocklabs/qmd";
 import type { QueryLane } from "./query-contract.js";
 /** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
-export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal): Promise<{
+export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal, allowedPaths?: AllowedDocumentPaths): Promise<{
     vector?: {
         score: number;
         rank: number;

package/dist/src/training-candidates.js

@@ -1,8 +1,8 @@
 /** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
-export async function trainingCandidates(qmd, query, collection, lane, signal) {
+export async function trainingCandidates(qmd, query, collection, lane, signal, allowedPaths) {
     const hits = await qmd.discoverCandidates({ query, lane, collection, limit: 10, signal,
         // Preserve keyword chunk tie-breaking against this lane's own query.
-        intent: query });
+        intent: query, allowedPaths });
     return hits.map(({ method, rank, score, file, body, bestChunk, bestChunkPos }) => {
         const retrieval = {
             [method]: { score, rank: rank + 1 },

package/docs/configuration.md

@@ -11,7 +11,8 @@ settings; a rotated credential file is reread without a restart.
 
 | Feature | Required settings/dependencies | TypeSafe disabled / no key | Provider or unreadable-key failure |
 | --- | --- | --- | --- |
-| Ordinary search/get | Installed/enabled memory slot; configured corpora | Unchanged local retrieval | Unchanged; its own indexing/embedding errors still matter |
+| `memory_search` | Installed/enabled memory slot; configured corpora; TypeSafe key | Explicit unavailable error | Successful judged siblings returned with a partial warning; total failure is an error; no vector fallback |
+| `memory_get` | Installed/enabled memory slot; configured corpora | Unchanged local indexed reads | Unchanged; its own indexing errors still matter |
 | Skill Whisperer | `skillWhisperer.enabled`, skills corpus, host hooks | Best local vector candidate meeting `minScore` | Exclude failed candidates; successful siblings may qualify; no vector fallback |
 | Memory Whisperer | `memoryWhisperer.enabled`, explicit approved corpora, host hooks | No hints | Exclude failed candidates; recall/deadline failures still suppress the turn |
 | Complementary hints | Enabled Memory Whisperer + `complementaryHints` | No additional judgment; base hints also require a key | Keep baseline hints unless the total deadline expires |
@@ -202,7 +203,7 @@ contract; these tables explain their effects.
 | `corpora[].kind` | Required for explicit entries | `files`, `sessions`, or `skills` |
 | `corpora[].paths` | Required for files/skills | Nonempty exact-file/directory/glob list; workspace-relative, absolute or `~/`; directory means recursive Markdown; does not grant host write trust |
 | `corpora[sessions].chatTypes` | `['channel','group']` | Nonempty subset of channel/group/direct; DMs require `direct` |
-| `corpora[sessions].maxExpandedTokens` | `500` | 1–10,000; ordinary search uses full turn/message when it fits, otherwise preserves the matched chunk. Whisperer instead shares a fixed 1,200-character renderer with training. |
+| `corpora[sessions].maxExpandedTokens` | `500` | 1–10,000; internal host vector retrieval expands a full turn/message when it fits. Public search and Whisperer share the fixed 1,200-character complete-passage renderer with training. |
 | `corpora[sessions].syncIntervalMinutes` | `60` | 0–1,440; zero manual-only; first scheduled sync after one interval; requires running Gateway |
 | `keepEmbeddingModelWarm` | `true` | Retain embedding model/context after first use; false allows five-minute idle disposal |
 | `analysis.executable` | Unset | Optional absolute local worker path; enables ability to recluster, not automatic scheduling |

package/docs/retrieval.md

@@ -6,26 +6,31 @@
 
 `memory_search` searches every configured **non-skill** corpus for this agent by
 default. Select named corpora, or use `["all"]` alone. An empty list or unknown
-name is an error. Default: **5 results**, vector `minScore: 0.3`; configurable
-`maxResults` is 1–20 and `minScore` is 0–1. No TypeSafe, BM25, query expansion
-or reranker runs in this tool.
+name is an error. Supply `bm25Query` (distinctive keywords/names) and
+`vectorQuery` (a natural-language question describing the information needed).
+Each lane retrieves ten candidates; complete passages are deduplicated and
+independently judged by TypeSafe against `vectorQuery`. No query generation or
+recall gate runs. Default: **5 results**, `minUsefulness: 0.7`;
+`maxResults` is 1–20 and `minUsefulness` is 0–1. The old `query` and vector
+`minScore` parameters are removed, not silently reinterpreted.
 
 Example tool input (the `memory` corpus exists by default):
 
 ```json
-{ "query": "Who approved the staging rollout?", "corpora": ["memory"], "maxResults": 5 }
+{ "bm25Query": "staging rollout approval", "vectorQuery": "Who approved the staging rollout?", "corpora": ["memory"], "maxResults": 5 }
 ```
 
 Results use compact JSON and carry `path`, `startLine`, `endLine`, `snippet`,
-`corpus`, and `score`/`vectorScore` rounded to hundredths. Ranking and threshold
+`corpus`, and a usefulness `score` rounded to hundredths. Ranking and threshold
 filtering still use full precision. The constant `source` and top-level `provider`
 fields are omitted; `path` plus line numbers replace the redundant `citation`.
 Session hits also carry session metadata and, when available,
 `messageTimestamp`: the original timestamp text (including timezone) of the message
 containing the matched chunk. It stays tied to that message even when the excerpt
 expands to the surrounding turn. Missing timestamps are omitted, not replaced by
-session start time. Vector similarity is a retrieval signal, not confidence in
-the truth of a claim.
+session start time. Usefulness is not confidence in the truth of a claim.
+Passages retain complete evidence within 1,200 characters; oversized matches
+are omitted, never trimmed into a misleading prefix.
 
 Session `snippet` values are arrays of messages, in source order:
 
@@ -61,56 +66,40 @@ Search snippets are leads. Inspect attribution, qualifications, dates and adjace
 context before relying on a factual claim. An old plan is not proof it happened,
 and memory does not grant permission to act. No results may mean the wrong corpus,
 a high threshold, an unsynced session or an unavailable index—not absence of the fact.
+Search requires enabled TypeSafe and a configured key. It sends the semantic
+query, candidate excerpts, dates, corpus and source paths to TypeSafe. Missing
+credentials and total judging failure include an `error` alongside empty `results`;
+partial judging failure includes a `warning` and only successfully judged results.
+Oversized queries are rejected before credentials, retrieval or provider calls.
 Search initialization errors include an `error` alongside empty `results`;
 other failures may surface as tool errors. Investigate them instead of reporting
 “nothing is remembered.”
+`memory_diagnostics` exposes content-free manual-search measurements under
+`whisperers.telemetry.operations.memorySearch`: end-to-end latency, retrieval and
+judging time, candidate/result counts and outcomes (including partial failures).
+These counters are separate from automatic `memoryWhisperer` and internal `vector`
+retrieval; no query or evidence text is recorded.
 
 Corpora and session filters select evidence; they are not audience ACLs. Normal
 tools can access this agent's configured non-skill corpora, not just its current
 chat. Only index material suitable for the agent's tool callers. Per-feature
 TypeSafe allowlists do not restrict ordinary retrieval.
 
-## QMD search modes
-
-The following describes QMD's TypeSafe-ranked `query` API (2.10+). Use the exact
-dependency in the installed plugin's package metadata when diagnosing an older
-installation.
-
-| Surface | Retrieval/ranking | Score / useful distinction |
-| --- | --- | --- |
-| Plugin `memory_search` | Direct vector search, expansion off | Vector similarity; ordinary agent recall |
-| QMD CLI `search` / SDK `searchLex` | Local BM25 | Normalized lexical relevance; useful for names, identifiers and exact phrases |
-| QMD CLI/SDK `vsearch` | Local vectors; standalone default includes local query expansion | Vector similarity; `--no-expand` / `expand:false` selects literal retrieval |
-| QMD CLI/MCP `query` / SDK `search` | Literal vectors + BM25, deduplicated source excerpts, independent TypeSafe usefulness ranking | Usefulness divided by 3, not cosine similarity; default limit 10/minScore 0 |
-| QMD `query --no-rerank` / SDK/MCP `rerank:false` | Local retrieval, best reciprocal retrieval-rank ordering | 1 / rank; explicitly skips remote scoring |
-
-Plain `query` takes `ceil(1.5 × limit)` candidates per backend, without local
-expansion or local reranking. Explicit `lex`/`vec`/`hyde` variants share the
-TypeSafe ranking policy by default. A supplied hypothetical `hyde` passage is
-a retrieval input, not evidence. Scores across modes are not interchangeable.
-
-**Migration:** Memory 0.3.22 removed the temporary `memory_xsearch` tool. QMD's
-`query` provides that hybrid retrieval/ranking functionality; there is no plugin
-`memory_query`, and `memory_search` did not become hybrid.
-
-Standalone QMD is a separate entry point. Its project/named/global index is not
-automatically this agent's `unblock-memory/index.sqlite`. Plugin corpus names
-also are not QMD collection IDs: each configured path maps to a `source-<hash>`
-collection, and a corpus can contain several. Establish the intended index,
-collection scope and installed QMD version before using CLI/MCP as an alternative.
-Do not run standalone collection/update/embed maintenance against a live
-plugin-managed index as a casual search fallback.
-
-QMD CLI/MCP read `TYPESAFE_API_KEY` or `TYPESAFE_API_KEY_FILE` from their own
-process; SDK callers can supply credentials. Plugin `typesafe.apiKeyFile` does
-not export a key to those processes. Ranked query sends the query, intent,
-selected excerpts, source paths and evaluation time to TypeSafe. Missing keys or
-scoring failures return errors, not vector fallback or a successful empty answer.
-Use an explicitly local mode when appropriate.
-
-See the [QMD guide](https://github.com/unblocklabs-ai/qmd#readme) for CLI/MCP syntax.
-Private skill frontmatter retrieval and response-audit lexical investigations are
-internal workflows, not extra public plugin search modes.
+## QMD entry points
+
+`memory_search` is the agent-facing ranked search. The QMD CLI `query`,
+`search` and `deep-search` alias, MCP `query` tool, and HTTP `/query` and
+`/search` routes are removed in the companion QMD change. Existing installations
+retain those commands until that QMD change is released and installed.
+
+QMD remains the local indexing/retrieval backend. Its BM25/vector SDK primitives,
+vector-only `vsearch`, indexed reads, collection maintenance and benchmark APIs
+remain available. Private skill retrieval and response-audit lexical investigations
+are internal workflows, not extra public plugin search tools.
+
+Standalone QMD and the plugin need not use the same index. Do not run standalone
+collection/update/embed maintenance against a live plugin-managed index as a
+casual search fallback.
 
 ## Sessions
 
@@ -127,7 +116,8 @@ corpora searchable. Supported fields are `startedFrom` and `startedTo`
 
 ```json
 {
-  "query": "deployment decision",
+  "bm25Query": "deployment decision",
+  "vectorQuery": "What deployment decision was made?",
   "sessionFilter": {
     "startedFrom": "2026-08-01T00:00:00Z",
     "provider": "slack",
@@ -300,7 +290,9 @@ through BM25 and vectors respectively, retrieving ten candidates per backend acr
 the complete approved collection scope (not ten per collection). The lexical adapter
 uses literal OR keywords; quotation marks do not enable exact-phrase matching.
 API or generated-output failures skip the hint; there is no direct-vector fallback.
-TypeSafe evaluates one independent
+After query generation Whisperer uses the same discovery, deduplication and
+ranking core as `memory_search`, but judges against the bounded conversation
+rather than the explicit tool's semantic query alone. TypeSafe evaluates one independent
 Noul question per candidate in its own concurrent HTTP request: would a careful
 assistant use a specific factual detail from the excerpt when answering the current
 request? Partial answers and concrete leads count; repeated facts, topic/name matches
@@ -315,16 +307,18 @@ Explicit configured thresholds are preserved. Evaluate it on your own conversati
 **Privacy and budgets:** training and runtime prepare the same visible conversation:
 at most 8,192 pinned-LFM tokens and 24,000 UTF-8 bytes after serialization. The whole
 current request and most recent whole messages are retained; an oversized current
-request skips automatic memory. The judge receives that conversation plus one complete
-1,200-character excerpt, its corpus/source path, all represented message timestamps,
+request skips automatic memory before query generation or the TypeSafe recall gate.
+Diagnostics count `input_too_large`; completed logs report `outcome: "skipped"` and
+`reason: "input_too_large"`, without recording the input. The judge receives that
+conversation plus one complete 1,200-character excerpt, its corpus/source path, all represented message timestamps,
 and the request's evaluation time per HTTP request. A v2 query pair can therefore
 produce up to twenty passage requests before deduplication and eligibility filtering.
 Dates record when source messages were said, without inferring event dates.
 Session excerpts retain a complete turn or message when it fits,
 otherwise the complete matched chunk. Chunks exceeding the excerpt budget are
-skipped, never sliced. This shared Whisperer renderer uses the fixed 1,200-character
-budget independently of `sessions.maxExpandedTokens`; that setting still controls
-ordinary `memory_search` expansion, which is unchanged.
+skipped, never sliced. Public `memory_search` and Whisperer use the same fixed
+1,200-character renderer, independently of `sessions.maxExpandedTokens`.
+That setting controls only internal host-vector retrieval expansion.
 It does not fetch a complete historical transcript; the host may
 already have compacted the available context. System messages, thinking blocks,
 images, and tool-result messages are omitted;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": true },
@@ -64,7 +64,7 @@
     },
     "typesafe.enabled": {
       "label": "TypeSafe Judgments",
-      "help": "Shared provider gate for opted-in whisperers, people primer/save review, evidence/quality reviews and response audits. Does not enable features or approve corpora by itself. Ordinary search and People Whisperer injection stay local."
+      "help": "Shared provider gate for opted-in whisperers, people primer/save review, evidence/quality reviews and response audits. Does not enable features or approve corpora by itself. Memory search discovers locally and uses TypeSafe to rank usefulness; People Whisperer injection stays local."
     },
     "typesafe.apiKey": { "label": "TypeSafe API Key", "sensitive": true },
     "typesafe.timeoutMs": { "label": "TypeSafe Request Timeout", "help": "Per-request timeout, not the whole operation. People primer/dossier review use peoplePrimer.timeoutMs instead; Memory Whisperer has its own total deadline, and Skill Whisperer has a fixed 3-second total budget." },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@huggingface/tokenizers": "0.2.0",
-    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.11.1/unblocklabs-qmd-2.11.1.tgz",
+    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v3.0.0/unblocklabs-qmd-3.0.0.tgz",
     "chokidar": "5.0.0",
     "js-tiktoken": "1.0.21",
     "picomatch": "^4.0.5",