@unblocklabs/unblock-memory 0.7.3 → 0.8.0

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;
@@ -48,12 +48,12 @@ export declare function responseEpisodes(session: ResponseSession, rows: readonl
     episodes: ResponseEpisode[];
     coverage: ResponseCoverage;
 };
-/** Bounded, read-only active transcript snapshot; archived/deleted branches are excluded. */
+/** Bounded, read-only active transcript snapshot; cold history is deferred, inactive branches excluded. */
 export declare class ResponseTranscriptReader {
     #private;
     constructor(path: string, agentId: string);
     sessions(config: ResponseAuditConfig, now: number, after?: string): ResponseSession[];
-    /** null = confirmed absent/ineligible; undefined = over budget, not evidence of deletion. */
+    /** null = confirmed absent/ineligible; undefined = unavailable/over budget, never evidence of deletion. */
     read(input: ResponseSession | string, config: ResponseAuditConfig): (ReturnType<typeof responseEpisodes> & {
         revision: string;
     }) | null | undefined;

package/dist/src/response-episodes.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
-import { ACTIVE_EVENT_COUNT_SQL, ACTIVE_EVENT_ROWS_SQL, assertAgentTranscriptSchema } from "./agent-transcript.js";
+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;
@@ -176,14 +176,15 @@ export function responseEpisodes(session, rows, config) {
     }
     return { episodes, coverage };
 }
-/** Bounded, read-only active transcript snapshot; archived/deleted branches are excluded. */
+/** Bounded, read-only active transcript snapshot; cold history is deferred, inactive branches excluded. */
 export class ResponseTranscriptReader {
     #db;
+    #transcripts;
     constructor(path, agentId) {
         this.#db = new DatabaseSync(path, { readOnly: true });
         try {
             this.#db.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000");
-            assertAgentTranscriptSchema(this.#db, agentId, "Unsupported response-audit transcript schema or agent");
+            this.#transcripts = new AgentTranscriptReader(this.#db, agentId, "Unsupported response-audit transcript schema or agent");
         }
         catch (error) {
             this.#db.close();
@@ -191,17 +192,55 @@ export class ResponseTranscriptReader {
         }
     }
     sessions(config, now, after = "") {
-        return this.#db.prepare(`SELECT w.session_id sessionId, COALESCE(w.account_id,c.account_id,'') accountId,
+        // Page metadata candidates, then apply the approved-sender filter to decoded
+        // events before the audit cap. Unrelated Slack traffic must not hide previews.
+        const candidates = this.#db.prepare(`SELECT w.session_id sessionId, COALESCE(w.account_id,c.account_id,'') accountId,
       w.chat_type chatType, w.primary_conversation_id conversationId
       FROM session_windows w JOIN conversations c ON c.conversation_id=w.primary_conversation_id
       WHERE COALESCE(w.channel,c.channel)='slack' AND w.chat_type IN (${config.chatTypes.map(() => "?").join(",")})
       AND w.session_id>?
       AND EXISTS (SELECT 1 FROM transcript_events e JOIN session_transcript_active_events a
-        ON a.session_id=e.session_id AND a.event_seq=e.seq WHERE e.session_id=w.session_id AND e.created_at >= ?
-        AND json_extract(e.event_json,'$.message.role')='user'
-        AND json_extract(e.event_json,'$.message.__openclaw.senderId') IN (${config.senderIds.map(() => "?").join(",")}))
-      ORDER BY w.session_id LIMIT 101`)
-            .all(...config.chatTypes, after, now - config.lookbackDays * 86400_000, ...config.senderIds);
+        ON a.session_id=e.session_id AND a.event_seq=e.seq WHERE e.session_id=w.session_id AND e.created_at >= ?)
+      ORDER BY w.session_id LIMIT 101`);
+        const since = now - config.lookbackDays * 86400_000;
+        const sessions = [];
+        this.#db.exec("BEGIN");
+        try {
+            while (sessions.length < 101) {
+                const page = candidates.all(...config.chatTypes, after, since);
+                for (const session of page) {
+                    const snapshot = this.#transcripts.read(session.sessionId, { maxEvents: MAX_EVENTS, maxBytes: MAX_SESSION_BYTES });
+                    // Saved unavailable sessions are reconciled separately by the caller.
+                    if (snapshot.kind !== "ready")
+                        continue;
+                    const approved = snapshot.rows.some(row => {
+                        if (row.createdAt < since)
+                            return false;
+                        let event;
+                        try {
+                            event = record(JSON.parse(row.eventJson));
+                        }
+                        catch {
+                            return false;
+                        }
+                        const message = record(event?.message), sender = record(message?.__openclaw)?.senderId;
+                        return event?.type === "message" && message?.role === "user" &&
+                            typeof sender === "string" && config.senderIds.includes(sender);
+                    });
+                    if (approved)
+                        sessions.push(session);
+                    if (sessions.length === 101)
+                        break;
+                }
+                if (page.length < 101)
+                    break;
+                after = page.at(-1).sessionId;
+            }
+            return sessions;
+        }
+        finally {
+            this.#db.exec("COMMIT");
+        }
     }
     read(input, config, previousRevision) {
         this.#db.exec("BEGIN");
@@ -216,10 +255,10 @@ export class ResponseTranscriptReader {
                 return null;
             const session = { sessionId, accountId: String(window.accountId),
                 conversationId: String(window.conversationId), chatType: String(window.chatType) };
-            const count = this.#db.prepare(ACTIVE_EVENT_COUNT_SQL).get(session.sessionId);
-            if (Number(count.n) > MAX_EVENTS || Number(count.bytes) > MAX_SESSION_BYTES)
+            const snapshot = this.#transcripts.read(session.sessionId, { maxEvents: MAX_EVENTS, maxBytes: MAX_SESSION_BYTES });
+            if (snapshot.kind !== "ready")
                 return undefined;
-            const rows = this.#db.prepare(ACTIVE_EVENT_ROWS_SQL).all(session.sessionId);
+            const rows = snapshot.rows;
             // Exact active content catches in-place edits and branch changes even when writer
             // watermarks are absent. Raw text is never retained in the checkpoint database.
             const revision = hash([RESPONSE_EXTRACTOR_VERSION, session, config.historyMessages, [...config.senderIds].sort(), rows]);

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/session-sync.d.ts

@@ -1,6 +1,6 @@
 import type { ChatType } from "./config.js";
 import { type SessionMetadata, type SessionProjectionInput, type SessionMessageSpan } from "./session-projector.js";
-export declare const PROJECTOR_VERSION = 7;
+export declare const PROJECTOR_VERSION = 8;
 type IndexedSession = SessionMetadata & {
     sourceGeneration: string;
     maxSeq: number;

package/dist/src/session-sync.js

@@ -3,10 +3,10 @@ import { existsSync, lstatSync, readFileSync, statSync } from "node:fs";
 import { chmod, mkdir, readFile, rename, unlink, utimes, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { ACTIVE_EVENTS_FROM, agentTranscriptSchemaVersion, assertAgentTranscriptIdentity } from "./agent-transcript.js";
+import { AgentTranscriptReader, agentTranscriptSchemaVersion, assertAgentTranscriptIdentity } from "./agent-transcript.js";
 import { projectSessionDocument, sessionDocumentPath, } from "./session-projector.js";
 const MANIFEST_VERSION = 1;
-export const PROJECTOR_VERSION = 7;
+export const PROJECTOR_VERSION = 8;
 // Source lives in src/, published code in dist/src/. Read our own pinned dependency
 // metadata, not QMD internals (which may also be substituted by runtime inspectors).
 const sourcePackage = new URL("../package.json", import.meta.url);
@@ -91,6 +91,7 @@ function readSnapshot(params) {
     try {
         db.exec("PRAGMA query_only = ON; PRAGMA busy_timeout = 5000; BEGIN");
         assertSchema(db, params.agentId);
+        const transcripts = new AgentTranscriptReader(db, params.agentId);
         const placeholders = params.chatTypes.map(() => "?").join(", ");
         const windows = db.prepare(`
       SELECT
@@ -104,7 +105,8 @@ function readSnapshot(params) {
         COALESCE(window.started_at, window.created_at) AS startedAt,
         rewrite.generation AS sourceGeneration,
         MAX(active.event_seq) AS maxSeq,
-        COUNT(active.event_seq) AS activeEventCount
+        COUNT(active.event_seq) AS activeEventCount,
+        ${transcripts.coldSql("window.session_id")} AS cold
       FROM session_windows AS window
       LEFT JOIN conversations AS conversation
         ON conversation.conversation_id = window.primary_conversation_id
@@ -116,15 +118,9 @@ function readSnapshot(params) {
       GROUP BY window.session_id
       ORDER BY window.created_at, window.session_id
     `).all(...params.chatTypes);
-        const readEvents = db.prepare(`
-      SELECT a.session_id AS sessionId, e.event_json AS eventJson,
-             e.created_at AS createdAt
-      ${ACTIVE_EVENTS_FROM}
-      WHERE a.session_id = ?
-      ORDER BY a.active_position
-    `);
         const events = new Map();
         const changed = new Set();
+        const unavailable = new Set();
         for (const window of windows) {
             const metadata = {
                 sessionId: window.sessionId,
@@ -137,7 +133,7 @@ function readSnapshot(params) {
             const previous = params.previousManifest.sessions[window.sessionId];
             const documentPath = sessionDocumentPath(metadata);
             const sourceFingerprint = JSON.stringify(window);
-            const unchanged = !params.force &&
+            const unchanged = !window.cold && !params.force &&
                 (previous ? previous.sourceFingerprint === sourceFingerprint &&
                     previous.projectorVersion === PROJECTOR_VERSION &&
                     previous.documentPath === documentPath &&
@@ -145,12 +141,22 @@ function readSnapshot(params) {
                     params.previousManifest.ignoredSessions?.[window.sessionId] === sourceFingerprint);
             if (!unchanged) {
                 changed.add(window.sessionId);
-                if (!params.metadataOnly)
-                    events.set(window.sessionId, readEvents.all(window.sessionId));
+                if (!params.metadataOnly) {
+                    try {
+                        const snapshot = transcripts.read(window.sessionId);
+                        if (snapshot.kind === "ready")
+                            events.set(window.sessionId, snapshot.rows.map(row => ({ ...row, sessionId: window.sessionId })));
+                        else
+                            unavailable.add(window.sessionId);
+                    }
+                    catch {
+                        unavailable.add(window.sessionId);
+                    }
+                }
             }
         }
         db.exec("COMMIT");
-        return { windows, events, changed };
+        return { windows, events, changed, unavailable };
     }
     catch (error) {
         try {
@@ -262,6 +268,12 @@ export async function syncSessionProjections(params) {
             startedAt: window.startedAt,
         };
         const documentPath = sessionDocumentPath(metadata);
+        if (snapshot.unavailable.has(window.sessionId)) {
+            counts.failed += 1;
+            if (previous)
+                sessions[window.sessionId] = previous;
+            continue;
+        }
         if (events === undefined) {
             if (previous)
                 sessions[window.sessionId] = previous;

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/dist/src/training-input.d.ts

@@ -48,6 +48,10 @@ export declare class TrainingTranscriptReader {
         }[];
     } | {
         oversized: true;
+        unavailable?: undefined;
+    } | {
+        unavailable: true;
+        oversized?: undefined;
     } | null;
     close(): void;
 }