@unblocklabs/unblock-memory 0.7.1 → 0.7.3

package/dist/src/manager.js

@@ -74,16 +74,6 @@ function frontmatterValue(body, key) {
         .find((value) => value !== undefined);
     return raw?.replace(/^(?:"(.*)"|'(.*)')$/u, "$1$2").trim();
 }
-function embeddingText(name, description, model) {
-    return model.toLowerCase().includes("qwen3-embedding")
-        ? `${name}\n${description}`
-        : `title: ${name} | text: ${description}`;
-}
-function queryText(query, model) {
-    return model.toLowerCase().includes("qwen3-embedding")
-        ? `Instruct: Retrieve relevant documents for the given query\nQuery: ${query}`
-        : `task: search result | query: ${query}`;
-}
 function cosineSimilarity(left, right) {
     if (left.length !== right.length || left.length === 0)
         return 0;
@@ -192,22 +182,6 @@ function lineSpan(body, position, text) {
     const endLine = startLine + Math.max(0, text.split("\n").length - 1);
     return { startLine, endLine };
 }
-function lexicalResult(hit, corpus, session) {
-    const body = hit.body ?? hit.title;
-    const endLine = Math.max(1, body.split("\n").length);
-    return {
-        path: hit.filepath,
-        startLine: 1,
-        endLine,
-        score: hit.score,
-        textScore: hit.score,
-        snippet: body,
-        source: "memory",
-        corpus,
-        ...(session ? { session } : {}),
-        citation: `${hit.displayPath}#L1-L${endLine}`,
-    };
-}
 function sessionAllowedPaths(metadataByPath, collection, filter) {
     const startedFrom = filter.startedFrom === undefined ? undefined : Date.parse(filter.startedFrom);
     const startedTo = filter.startedTo === undefined ? undefined : Date.parse(filter.startedTo);
@@ -251,6 +225,7 @@ export class QmdMemoryManager {
     #watcher;
     #watchReady;
     #watchTimer;
+    #watchCollections = new Set();
     #watchError;
     #closed = false;
     #files = 0;
@@ -360,12 +335,17 @@ export class QmdMemoryManager {
                 this.#skillIndex = undefined;
             if (!matchingSources.some((source) => source.kind !== "skills"))
                 return;
+            for (const source of matchingSources)
+                if (source.kind !== "skills")
+                    this.#watchCollections.add(source.collection);
             this.#dirty = true;
             if (this.#watchTimer)
                 clearTimeout(this.#watchTimer);
             this.#watchTimer = setTimeout(() => {
                 this.#watchTimer = undefined;
-                void this.sync({ reason: "watch" }).catch(() => undefined);
+                const collections = [...this.#watchCollections];
+                this.#watchCollections.clear();
+                void this.#sync({ reason: "watch" }, collections).catch(() => undefined);
             }, WATCH_DEBOUNCE_MS);
         });
     }
@@ -489,23 +469,36 @@ export class QmdMemoryManager {
         const allowed = new Set(sessionAllowedPaths(new Map(records.map(r => [extractedPath(r), r.metadata])), EXTRACTED_COLLECTION, filter)[EXTRACTED_COLLECTION]);
         return records.filter(r => allowed.has(extractedPath(r)));
     }
-    async #updateAndEmbed(store, collection, force) {
+    async #updateAndEmbed(store, collections, force) {
         // Extracted facts are DB projections, not files: never run filesystem sync on them.
-        const update = await store.update({ collections: collection ? [collection] : this.#qmdSources().map(source => source.collection) });
-        this.#cleanupRemovedDocuments?.(update.updated + update.removed);
         const analysisStore = store;
-        const changed = update.indexed + update.updated + update.removed > 0 || update.needsEmbedding > 0;
-        if ((changed || force) && analysisStore.internal)
-            markMemoryAnalysisStale(analysisStore.internal.db);
-        const embed = await store.embed({
-            ...(collection ? { collection } : {}),
-            force,
-            chunkStrategy: "semantic",
-        });
-        this.#recordEmbedding(embed);
-        const chunksEmbedded = completedEmbeddingCount(embed);
-        if (!changed && !force && chunksEmbedded > 0 && analysisStore.internal) {
-            markMemoryAnalysisStale(analysisStore.internal.db);
+        let changedDocuments = 0;
+        try {
+            const update = await store.update({ collections: collections ? [...collections] : this.#qmdSources().map(source => source.collection) });
+            changedDocuments = update.updated + update.removed;
+            if ((update.indexed + changedDocuments > 0 || update.needsEmbedding > 0 || force) && analysisStore.internal) {
+                markMemoryAnalysisStale(analysisStore.internal.db);
+            }
+        }
+        catch (error) {
+            // QMD may commit earlier collections before a later collection fails.
+            if (analysisStore.internal)
+                markMemoryAnalysisStale(analysisStore.internal.db);
+            changedDocuments = Math.max(1, changedDocuments);
+            throw error;
+        }
+        finally {
+            // A later collection failing must not leave earlier removed plaintext behind.
+            this.#cleanupRemovedDocuments?.(changedDocuments);
+        }
+        let chunksEmbedded = 0;
+        for (const collection of collections?.length ? collections : [undefined]) {
+            const embed = await store.embed({ ...(collection ? { collection } : {}), force, chunkStrategy: "semantic" });
+            this.#recordEmbedding(embed);
+            const count = completedEmbeddingCount(embed);
+            chunksEmbedded += count;
+            if (count > 0 && analysisStore.internal)
+                markMemoryAnalysisStale(analysisStore.internal.db);
         }
         return chunksEmbedded;
     }
@@ -516,16 +509,14 @@ export class QmdMemoryManager {
         this.#dirty = status.needsEmbedding > 0;
     }
     sync(params) {
+        return this.#sync(params);
+    }
+    #sync(params, affectedCollections) {
         const run = async () => {
             const store = await this.#getStore();
             this.#dirty = true;
-            const collections = this.#qmdSources().filter((source) => source.kind !== "sessions");
-            if (collections.length === 0) {
-                await this.#updateAndEmbed(store, undefined, params?.force);
-            }
-            for (const source of collections) {
-                await this.#updateAndEmbed(store, source.collection, params?.force);
-            }
+            const collections = affectedCollections ?? this.#qmdSources().filter((source) => source.kind !== "sessions").map(source => source.collection);
+            await this.#updateAndEmbed(store, collections.length ? collections : undefined, params?.force);
             await this.#refreshIndexStatus(store);
         };
         return this.#enqueue(run);
@@ -544,7 +535,7 @@ export class QmdMemoryManager {
                 index: async () => {
                     onPhase?.("indexing");
                     const store = await this.#getStore();
-                    return this.#updateAndEmbed(store, sessions.collection);
+                    return this.#updateAndEmbed(store, [sessions.collection]);
                 },
             });
             this.#sessionMetadata = sessionMetadataByPath(synced.manifest);
@@ -699,18 +690,28 @@ export class QmdMemoryManager {
       VALUES (?, ?, ?, ?, ?, ?, ?)
     `);
         const curation = this.#getCuration();
+        const fingerprints = new Map();
         for (const annotation of curation.annotations()) {
             if (!annotation.contentFingerprint) {
                 insert.run(annotation.collection, annotation.path, null, null, annotation.eventTime, annotation.basis, 1);
                 continue;
             }
-            const rows = findChunks.all(annotation.collection, annotation.path);
-            const matched = rows.find((row) => chunkFingerprint(row.doc.slice(row.pos, row.pos + row.chunk_len)) === annotation.contentFingerprint);
-            curation.updateAnnotationLocation({
-                annotation,
-                qmdHash: matched?.hash ?? null,
-                qmdSeq: matched?.seq ?? null,
-            });
+            const key = JSON.stringify([annotation.collection, annotation.path]);
+            let chunks = fingerprints.get(key);
+            if (!chunks) {
+                chunks = new Map();
+                const rows = findChunks.all(annotation.collection, annotation.path);
+                for (const row of rows) {
+                    const fingerprint = chunkFingerprint(row.doc.slice(row.pos, row.pos + row.chunk_len));
+                    if (!chunks.has(fingerprint))
+                        chunks.set(fingerprint, row);
+                }
+                fingerprints.set(key, chunks);
+            }
+            const matched = chunks.get(annotation.contentFingerprint);
+            if (annotation.qmdHash !== (matched?.hash ?? null) || annotation.qmdSeq !== (matched?.seq ?? null)) {
+                curation.updateAnnotationLocation({ annotation, qmdHash: matched?.hash ?? null, qmdSeq: matched?.seq ?? null });
+            }
             if (matched) {
                 insert.run(annotation.collection, annotation.path, matched.hash, matched.seq, annotation.eventTime, annotation.basis, 0);
             }
@@ -779,7 +780,7 @@ export class QmdMemoryManager {
     }
     async search(query, opts) {
         const started = performance.now();
-        const operation = opts?.lexicalOnly ? "lexical" : "vector";
+        const operation = "vector";
         let results;
         try {
             results = await this.#search(query, opts);
@@ -820,25 +821,6 @@ export class QmdMemoryManager {
         if (collections.includes(EXTRACTED_COLLECTION)) {
             allowedPaths = { ...allowedPaths, [EXTRACTED_COLLECTION]: currentRecords().map(extractedPath) };
         }
-        if (opts?.lexicalOnly) {
-            const hits = await store.searchLex(query, {
-                limit: opts.maxResults ?? 5,
-                collection: collections,
-            });
-            const current = new Map(currentRecords(hits.map(hit => hit.filepath)).map(r => [`qmd://${EXTRACTED_COLLECTION}/${extractedPath(r)}`, r]));
-            return hits.flatMap((hit) => {
-                if (hit.collectionName === EXTRACTED_COLLECTION) {
-                    const record = current.get(hit.filepath);
-                    return record && hit.score >= (opts.minScore ?? 0) ? [extractedHit(record, hit.score)] : [];
-                }
-                const corpus = this.#sources.get(hit.collectionName)?.corpus;
-                const prefix = `qmd://${hit.collectionName}/`;
-                const session = corpus === "sessions" && hit.filepath.startsWith(prefix)
-                    ? this.#sessionMetadata.get(hit.filepath.slice(prefix.length))
-                    : undefined;
-                return hit.score >= (opts.minScore ?? 0) && corpus ? [lexicalResult(hit, corpus, session)] : [];
-            });
-        }
         const hits = await store.vsearch(query, {
             collection: collections,
             limit: opts?.maxResults ?? 5,
@@ -944,6 +926,7 @@ export class QmdMemoryManager {
         if (!store.internal?.llm)
             throw new Error("Skill Whisperer requires the QMD embedding model");
         const llm = store.internal.llm;
+        const { formatDocForEmbedding, formatQueryForEmbedding } = await qmdModule;
         let skillIndex = this.#skillIndex;
         if (!skillIndex) {
             const pending = (async () => {
@@ -968,7 +951,7 @@ export class QmdMemoryManager {
                     }
                 }
                 const skills = [...metadata.values()];
-                const embeddings = await llm.embedBatch(skills.map(({ candidate, description }) => embeddingText(candidate.name, description, llm.embedModelName)));
+                const embeddings = await llm.embedBatch(skills.map(({ candidate, description }) => formatDocForEmbedding(description, candidate.name, llm.embedModelName)));
                 return skills.flatMap(({ candidate }, index) => {
                     const embedding = embeddings[index]?.embedding;
                     return embedding ? [{ ...candidate, score: 0, embedding }] : [];
@@ -981,7 +964,7 @@ export class QmdMemoryManager {
             });
             this.#skillIndex = skillIndex;
         }
-        const queryEmbedding = await llm.embed(queryText(query, llm.embedModelName), { isQuery: true });
+        const queryEmbedding = await llm.embed(formatQueryForEmbedding(query, llm.embedModelName), { isQuery: true });
         if (!queryEmbedding)
             return [];
         const candidates = await skillIndex;
@@ -1008,15 +991,12 @@ export class QmdMemoryManager {
         }
         await this.#operationChain;
         const store = await this.#getStore();
-        const doc = await store.get(safe.normalized);
-        if ("error" in doc || doc.filepath !== safe.normalized) {
+        const doc = await store.get(safe.normalized, { includeBody: true });
+        if ("error" in doc || doc.filepath !== safe.normalized || doc.body === undefined) {
             return { status: "not_found", text: "", path: params.relPath };
         }
-        const content = await store.getDocumentBody(safe.normalized);
-        if (content === null)
-            return { status: "not_found", text: "", path: params.relPath };
         return buildReadResult({
-            content,
+            content: doc.body,
             path: safe.normalized,
             from: params.from,
             lines: params.lines,
@@ -1064,6 +1044,7 @@ export class QmdMemoryManager {
         if (this.#watchTimer)
             clearTimeout(this.#watchTimer);
         this.#watchTimer = undefined;
+        this.#watchCollections.clear();
         await this.#watcher?.close();
         this.#watcher = undefined;
         this.#watchReady = undefined;

package/dist/src/memory-whisperer.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { judgeTypeSafeMemories } from "./typesafe.js";
+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";
@@ -164,15 +164,11 @@ export function registerMemoryWhisperer(api, runtime, config, typesafe, diagnost
                         timeoutMs: typesafe.timeoutMs };
                     try {
                         const { hit, excerpt } = candidate;
-                        const [probability] = await judgeTypeSafeMemories({
-                            apiKey, timeoutMs: typesafe.timeoutMs, signal,
-                            conversation, asOf,
-                            candidates: [{
-                                    excerpt, corpus: hit.corpus, sourcePath: hit.path,
-                                    dates: [...new Set(hit.sessionMessages?.flatMap(message => message.timestamp ? [message.timestamp] : [])
-                                            ?? (hit.messageTimestamp ? [hit.messageTimestamp] : []))],
-                                }],
-                        });
+                        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++;

package/dist/src/people-primer-config.js

@@ -10,12 +10,9 @@ export const peoplePrimerSchema = Type.Object({
     timeoutMs: Type.Integer({ minimum: 1, maximum: 60000, default: 30000 }),
 }, { additionalProperties: false });
 export function resolvePeoplePrimer(value, corpora, peopleEnabled) {
-    if (value === undefined)
-        return { enabled: false, corpora: [], hitsPerQuestion: 30,
-            minScore: 0.35, minUsefulness: 0.8, maxEvidencePerQuestion: 3, timeoutMs: 30000 };
     let config;
     try {
-        const withDefaults = Value.Default(peoplePrimerSchema, value);
+        const withDefaults = Value.Default(peoplePrimerSchema, value === undefined ? {} : value);
         if (!Value.Check(peoplePrimerSchema, withDefaults))
             throw new Error("Invalid config");
         config = withDefaults;

package/dist/src/people-primer.js

@@ -1,13 +1,12 @@
 import { createHash } from "node:crypto";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA } from "./typesafe-client.js";
 import { TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
 import { abortable } from "./abortable.js";
 const VERSION = "people-primer-background-v4";
 const MAX_EXCERPT_CHARS = 6000;
-const noul = Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) });
-const answerSchema = Type.Object({ answers: Type.Record(Type.String(), noul) });
+const answerSchema = Type.Object({ answers: Type.Record(Type.String(), TYPESAFE_NOUL_SCHEMA) });
 function questionsFor(name, agent) {
     return [
         { id: "role", question: `Who is ${name}? What is their explicitly stated role and organization?` },
@@ -115,15 +114,14 @@ export async function primePersonDossier(params) {
                     requests++;
                     payload = await requestTypeSafe({ apiKey: params.apiKey, timeoutMs: config.timeoutMs, signal }, state, questions);
                     signal.throwIfAborted();
-                    if (!valid(payload) || !Value.Check(answerSchema, payload))
+                    if (!valid(payload))
                         throw new Error("Invalid primer judgments");
                     // Keep only validated numerical answers, never provider extras or echoes.
                     const answers = payload.answers;
-                    payload = { answers: Object.fromEntries(expectedKeys.map(k => [k, { type: "noul", noul: answers[k].noul }])) };
-                    store.cachePrimerJudgment(person.id, key, payload);
+                    store.cachePrimerJudgment(person.id, key, {
+                        answers: Object.fromEntries(expectedKeys.map(k => [k, { type: "noul", noul: answers[k].noul }])),
+                    });
                 }
-                if (!Value.Check(answerSchema, payload))
-                    throw new Error("Invalid primer cache");
                 graded.push({ ...candidate, aboutPerson: payload.answers.aboutPerson.noul,
                     explicitBackground: payload.answers.explicitBackground.noul, enduring: payload.answers.enduring.noul,
                     recognition: payload.answers.recognition.noul,

package/dist/src/people-store.js

@@ -147,12 +147,15 @@ export class PeopleStore {
     #db;
     #maxOpenTodos;
     #maxBlurbChars;
+    #primerCacheReady = false;
     constructor(path, options) {
         this.#db = openMemoryDatabase(path);
         this.#maxOpenTodos = options.maxOpenTodos;
         this.#maxBlurbChars = options.maxBlurbChars;
         try {
             this.#migrate();
+            this.#db.exec(`CREATE INDEX IF NOT EXISTS person_identities_person
+        ON person_identities(person_id, provider, account_scope, external_id)`);
         }
         catch (error) {
             this.#db.close();
@@ -165,12 +168,17 @@ export class PeopleStore {
     // Derived, bounded cache: no source text or credentials. Kept outside the
     // authoritative dossier schema so older plugin versions can still open it.
     #ensurePrimerCache() {
+        if (this.#primerCacheReady)
+            return;
         this.#db.exec(`CREATE TABLE IF NOT EXISTS person_primer_judgments (
       cache_key TEXT PRIMARY KEY,
       person_id TEXT NOT NULL REFERENCES people(id) ON DELETE CASCADE,
       judgment_json TEXT NOT NULL,
       created_at TEXT NOT NULL
-    ) STRICT`);
+    ) STRICT;
+    CREATE INDEX IF NOT EXISTS person_primer_judgments_created
+      ON person_primer_judgments(created_at DESC, cache_key)`);
+        this.#primerCacheReady = true;
     }
     getPrimerJudgment(key) {
         this.#ensurePrimerCache();

package/dist/src/people-tools.js

@@ -112,10 +112,6 @@ const syncParameters = Type.Object({
     accountId: Type.String({ pattern: "\\S", maxLength: 200 }),
     limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 200 })),
 }, { additionalProperties: false });
-function context(ctx) {
-    const cfg = ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config;
-    return cfg && ctx.agentId ? { agentId: ctx.agentId } : undefined;
-}
 function personView(stores, agentId, selector, maxChars) {
     const store = stores.get(agentId);
     const person = "personId" in selector
@@ -138,7 +134,7 @@ function personView(stores, agentId, selector, maxChars) {
     };
 }
 function createInspectTool(stores, config, ctx) {
-    const active = context(ctx);
+    const active = getContext(ctx);
     if (!active)
         return null;
     return {
@@ -265,7 +261,7 @@ function createUpdateTool(stores, config, runtime, ctx) {
     };
 }
 function createSyncTool(stores, reader, ctx) {
-    const active = context(ctx);
+    const active = getContext(ctx);
     if (!active)
         return null;
     return {

package/dist/src/plugin.js

@@ -2,7 +2,6 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { jsonResult } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveConfig } from "./config.js";
-import { resolveTypeSafeApiKey } from "./typesafe-client.js";
 import { registerPeopleHooks } from "./people-hooks.js";
 import { PeopleStores } from "./people-store.js";
 import { registerPeopleTools } from "./people-tools.js";
@@ -13,7 +12,7 @@ import { registerMemoryWhisperer } from "./memory-whisperer.js";
 import { registerWhispererPrompt } from "./whisperer-prompt.js";
 import { getContext } from "./tool-context.js";
 import { WhispererDiagnostics } from "./diagnostics.js";
-import { registerReviewTools } from "./review-tools.js";
+import { registerReviewTools, reviewRequestContext } from "./review-tools.js";
 import { registerResponseAudit } from "./response-runtime.js";
 import { registerInsideOut } from "./inside-out-runtime.js";
 import { registerMemoryTraining } from "./training-runtime.js";
@@ -263,20 +262,13 @@ function createAuditQualityTool(runtime, ctx, config) {
             const options = Value.Parse(auditQualityParameters, params);
             if (!config.qualityAudit.enabled || !config.typesafe.enabled)
                 return jsonResult({ status: "disabled" });
-            const deadline = AbortSignal.timeout(30_000);
-            const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
             try {
-                combined.throwIfAborted();
-                const apiKey = await resolveTypeSafeApiKey(config.typesafe);
-                if (!apiKey)
-                    return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                combined.throwIfAborted();
-                const { manager } = await runtime.getMemorySearchManager(active);
-                if (!manager)
-                    return jsonResult({ status: "unavailable", reason: "Memory manager unavailable" });
-                return jsonResult(await manager.auditQuality({
+                const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                if (context.status !== "ready")
+                    return jsonResult(context);
+                return jsonResult(await context.manager.auditQuality({
                     ...options, corpora: config.qualityAudit.corpora, minNoise: config.qualityAudit.minNoise,
-                    apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined,
+                    apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal,
                 }));
             }
             catch {

package/dist/src/quality-audit.js

@@ -50,7 +50,7 @@ export async function auditQualityPage(params) {
         return result("ok", true);
     const limit = Math.max(1, Math.min(20, Math.floor(params.limit ?? 10)));
     const rows = db.prepare(`SELECT d.id AS document_id, cv.seq, d.collection, d.path,
-      d.hash, cv.pos, cv.chunk_len, c.doc
+      d.hash, cv.pos, cv.chunk_len
     FROM documents d JOIN content c ON c.hash = d.hash JOIN content_vectors cv ON cv.hash = d.hash
     WHERE d.active = 1 AND d.collection IN (${[...sources].map(() => "?").join(",")})
       AND (d.id > ? OR (d.id = ? AND cv.seq > ?))
@@ -59,9 +59,18 @@ export async function auditQualityPage(params) {
     WHERE d.id = ? AND d.active = 1 AND d.collection = ? AND d.path = ? AND d.hash = ?
       AND cv.seq = ? AND cv.pos = ? AND cv.chunk_len = ?`);
     const page = rows.slice(0, limit);
+    const bodies = new Map();
+    const readBody = db.prepare("SELECT doc FROM content WHERE hash = ?");
     try {
         check();
-        const batch = page.map(row => {
+        const batch = page.map(metadata => {
+            let doc = bodies.get(metadata.hash);
+            if (doc === undefined) {
+                // Content is hash-addressed; this capture does not yield before inference.
+                doc = readBody.get(metadata.hash).doc;
+                bodies.set(metadata.hash, doc);
+            }
+            const row = { ...metadata, doc };
             const source = sources.get(row.collection);
             const text = row.doc.slice(row.pos, row.pos + row.chunk_len);
             const fingerprint = chunkFingerprint(text);

package/dist/src/query-contract.js

@@ -44,15 +44,23 @@ export function prepareQueryConversation(history, currentRequest) {
         conversation.history.unshift(message);
         bytes += added;
     }
-    let contextLimited = conversation.history.length < history.length;
-    for (;;) {
-        const serialized = serializeQueryConversation(conversation);
-        if (Buffer.byteLength(serialized) <= contract.conversationBytes && queryTokenIds(serialized).length <= contract.conversationTokens) {
-            return { conversation, contextLimited };
-        }
-        if (!conversation.history.length)
-            throw new QueryInputBudgetError();
-        conversation.history.shift();
-        contextLimited = true;
+    const fits = (start) => queryTokenIds(serializeQueryConversation({
+        history: conversation.history.slice(start), currentRequest,
+    })).length <= contract.conversationTokens;
+    if (fits(0))
+        return { conversation, contextLimited: conversation.history.length < history.length };
+    if (!fits(conversation.history.length))
+        throw new QueryInputBudgetError();
+    // Search whole-message suffixes with the exact serialized tokenizer contract;
+    // never approximate the budget by adding independently tokenized messages.
+    let tooLarge = 0, fitting = conversation.history.length;
+    while (fitting - tooLarge > 1) {
+        const middle = Math.floor((tooLarge + fitting) / 2);
+        if (fits(middle))
+            fitting = middle;
+        else
+            tooLarge = middle;
     }
+    conversation.history = conversation.history.slice(fitting);
+    return { conversation, contextLimited: true };
 }

package/dist/src/response-audit.js

@@ -142,11 +142,11 @@ export async function auditResponses(options) {
                         }
                     }
                     signal.throwIfAborted();
-                    const fresh = reader.read(session, config.responseAudit);
-                    if (!fresh?.episodes.some(candidate => candidate.id === e.id && candidate.inputHash === e.inputHash)) {
+                    const fresh = reader.read(session, config.responseAudit, snapshot.revision);
+                    if (!fresh || !("unchanged" in fresh) && !fresh.episodes.some(candidate => candidate.id === e.id && candidate.inputHash === e.inputHash)) {
                         coverage.stale++;
                         store.stale(cohort, e);
-                        if (fresh !== undefined) {
+                        if (fresh !== undefined && (!fresh || !("unchanged" in fresh))) {
                             store.observe(cohort, session, fresh?.episodes ?? []);
                             store.checkpointForget(cohort, session);
                         }

package/dist/src/response-judge.js

@@ -1,11 +1,10 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA as noul } from "./typesafe-client.js";
 import { TYPESAFE_REVIEW_MODEL } from "./typesafe-review.js";
 export const RESPONSE_RUBRIC_VERSION = `${TYPESAFE_REVIEW_MODEL}:response-v10`;
 export const RESPONSE_STAGE_VERSIONS = { quality: "quality-v9", feedback: "feedback-v9", sentiment: "sentiment-v10", retrospective: "retrospective-v9", memory: "memory-v2-isolated" };
 const probability = Type.Number({ minimum: 0, maximum: 1 });
-const noul = Type.Object({ type: Type.Literal("noul"), noul: probability });
 const score = Type.Object({ type: Type.Literal("score"), score: Type.Number({ minimum: 0, maximum: 3 }),
     confidence: probability, probabilities: Type.Object({ "0": probability, "1": probability, "2": probability, "3": probability }) });
 function choiceSchema(criteria) {

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

@@ -8,7 +8,7 @@ export declare class ResponseReviews {
     constructor(db: DatabaseSync);
     sync(cohort: string, episodeId: string, inputHash: string, result: ResponseResult, now: number): void;
     refresh(cohort: string, since: number): number;
-    reconcile(cohort: string): void;
+    reconcile(cohort: string, sessionId: string): void;
     list(cohort: string, id?: string): {
         id: string;
         episodeId: string;

package/dist/src/response-reviews.js

@@ -68,11 +68,13 @@ export class ResponseReviews {
             throw error;
         }
     }
-    reconcile(cohort) {
+    reconcile(cohort, sessionId) {
         this.db.prepare(`UPDATE response_review_evidence AS e SET active=CASE WHEN EXISTS (
       SELECT 1 FROM response_review_tasks t JOIN response_results r ON r.id=t.episode_id
       WHERE t.id=e.task_id AND r.cohort=e.cohort AND r.input_hash=e.input_hash AND r.active=1 AND r.status='ok')
-      THEN 1 ELSE 0 END WHERE cohort=? AND active>=0`).run(cohort);
+      THEN 1 ELSE 0 END WHERE cohort=? AND active>=0 AND task_id IN (
+        SELECT t.id FROM response_results r JOIN response_review_tasks t ON t.episode_id=r.id
+        WHERE r.cohort=? AND r.session_id=?)`).run(cohort, cohort, sessionId);
     }
     list(cohort, id) {
         return this.db.prepare(`SELECT t.*,e.input_hash,e.active,e.detail FROM response_review_tasks t

package/dist/src/response-store.js

@@ -22,7 +22,8 @@ export class ResponseAuditStore {
           attempts INTEGER NOT NULL DEFAULT 0, attempted_at INTEGER, assessed_at INTEGER, result TEXT,
           PRIMARY KEY(cohort,id));
         CREATE TABLE IF NOT EXISTS response_scans (cohort TEXT PRIMARY KEY, observed_at INTEGER, coverage TEXT);
-        CREATE INDEX IF NOT EXISTS response_results_time ON response_results(cohort,episode_at);`);
+        CREATE INDEX IF NOT EXISTS response_results_time ON response_results(cohort,episode_at);
+        CREATE INDEX IF NOT EXISTS response_results_session ON response_results(cohort,session_id,episode_at);`);
             this.#db.exec(`CREATE TABLE IF NOT EXISTS response_checkpoints (
         cohort TEXT NOT NULL, session_id TEXT NOT NULL, revision TEXT NOT NULL, coverage TEXT NOT NULL,
         PRIMARY KEY(cohort,session_id));
@@ -86,7 +87,7 @@ export class ResponseAuditStore {
         result=CASE WHEN input_hash=excluded.input_hash THEN result ELSE NULL END`);
             for (const e of episodes)
                 insert.run(cohort, e.id, sessionId, e.inputHash, e.timestamp);
-            this.reviews.reconcile(cohort);
+            this.reviews.reconcile(cohort, sessionId);
             this.#db.exec("COMMIT");
         }
         catch (error) {

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

@@ -1,4 +1,4 @@
-type RetrievalOperation = "vector" | "lexical" | "memoryWhisperer";
+type RetrievalOperation = "vector" | "memoryWhisperer";
 type RetrievalOutcome = "ok" | "empty" | "failed" | "cancelled" | "timed_out" | "skipped";
 declare const fields: readonly ["elapsedMs", "retrievalMs", "judgeMs", "gateMs", "generationMs", "candidates", "eligible", "results", "contextChars"];
 type Field = typeof fields[number];

package/dist/src/review-tools.d.ts

@@ -2,4 +2,28 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
 import type { UnblockMemoryConfig } from "./config.js";
 import type { QmdMemoryRuntime } from "./runtime.js";
 import type { WhispererDiagnostics } from "./diagnostics.js";
+import { getContext } from "./tool-context.js";
+/** Bound initialization as well as inference, without cancelling shared managers. */
+export declare function reviewRequestContext(runtime: QmdMemoryRuntime, active: NonNullable<ReturnType<typeof getContext>>, typesafe: UnblockMemoryConfig["typesafe"], signal?: AbortSignal): Promise<{
+    readonly status: "unavailable";
+    readonly reason: "TypeSafe API key not configured";
+    readonly manager?: undefined;
+    readonly apiKey?: undefined;
+    readonly signal?: undefined;
+    readonly timeoutMs?: undefined;
+} | {
+    readonly status: "unavailable";
+    readonly reason: "Memory manager unavailable";
+    readonly manager?: undefined;
+    readonly apiKey?: undefined;
+    readonly signal?: undefined;
+    readonly timeoutMs?: undefined;
+} | {
+    readonly status: "ready";
+    readonly manager: import("./manager.js").QmdMemoryManager;
+    readonly apiKey: string;
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    reason?: undefined;
+}>;
 export declare function registerReviewTools(api: OpenClawPluginApi, runtime: QmdMemoryRuntime, config: UnblockMemoryConfig, diagnostics: WhispererDiagnostics): void;