@unblocklabs/unblock-memory 0.7.0 → 0.7.2

package/dist/src/training-queries.js

@@ -3,7 +3,7 @@ import { trainingHash } from "./training-input.js";
 import { TRAINING_GATE_THRESHOLD } from "./training-gate.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
 import { trainingTeacher, trainingTeacherMessage, trainingTeacherPrompt, TRAINING_TEACHER_MODEL, TRAINING_TEACHER_VERSION } from "./training-models.js";
-import { historicalTrainingSearch, HistoricalCorpusUnavailableError, TRAINING_RETRIEVAL_VERSION, TRAINING_SEARCH_OPTIONS } from "./training-retrieval.js";
+import { historicalTrainingSearch, historicalTrainingSource, HistoricalCorpusUnavailableError, TRAINING_RETRIEVAL_VERSION, TRAINING_SEARCH_OPTIONS } from "./training-retrieval.js";
 import { contextJudgeRequest, judgeTrainingPassage, CONTEXT_JUDGE_VERSION } from "./training-judge.js";
 const LANES = ["lex", "vec"];
 const SELECTION_VERSION = "independent-lanes-top3-mean-v2";
@@ -162,6 +162,7 @@ export async function evaluateTrainingQueries(source, store, config, runtime, op
     const refreshed = collectTraining(source, store, { existingOnly: true });
     const result = { ...summary(), retrievals: 0, evaluated: 0, awaitingTeacher: 0 };
     const concurrency = options.concurrency ?? TRAINING_EVALUATION_CONCURRENCY;
+    let historicalSource;
     let key, teacher;
     const apiKey = () => key ??= resolveTypeSafeApiKey(config.typesafe).then(value => {
         if (!value)
@@ -214,7 +215,9 @@ export async function evaluateTrainingQueries(source, store, config, runtime, op
         store.renew();
         let snapshot;
         try {
-            snapshot = await createSearch(source.stateDir, corpus.chatTypes, example.timestamp);
+            snapshot = createSearch === historicalTrainingSearch
+                ? await (await (historicalSource ??= historicalTrainingSource(source.stateDir, corpus.chatTypes)))(example.timestamp)
+                : await createSearch(source.stateDir, corpus.chatTypes, example.timestamp);
         }
         catch (error) {
             if (!(error instanceof HistoricalCorpusUnavailableError))

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

@@ -27,8 +27,21 @@ export declare function historicalPrefix(body: string, spans: readonly SessionMe
     body: string;
     spans: SessionMessageSpan[];
 } | undefined;
-/** Fingerprint a read-only source snapshot; build its search index only on demand.
- * No filesystem projection, live-index mutation, model re-embedding or dependency patch. */
+/** Capture source bytes once per run; each cutoff still owns its index and native model context. */
+export declare function historicalTrainingSource(stateDir: string, chatTypes: readonly ChatType[]): Promise<(cutoff: number, openStore?: typeof import("@unblocklabs/qmd")["createStore"]) => Promise<{
+    corpusHash: string;
+    report: {
+        sessions: number;
+        chunks: number;
+        excluded: number;
+        truncated: number;
+        excludedChunks: number;
+    };
+    maxDate: string;
+    search: (query: string, lane: QueryLane) => Promise<TrainingHit[]>;
+    close: () => Promise<void>;
+}>>;
+/** Standalone calls get a fresh source capture; evaluation runs reuse their own capture. */
 export declare function historicalTrainingSearch(stateDir: string, chatTypes: readonly ChatType[], cutoff: number, openStore?: typeof import("@unblocklabs/qmd")["createStore"]): Promise<{
     corpusHash: string;
     report: {

package/dist/src/training-retrieval.js

@@ -47,9 +47,8 @@ export function historicalPrefix(body, spans, cutoff) {
         return;
     return { body: body.slice(0, parsed[safe.length]?.span.start ?? body.length), spans: safe.map(s => s.span) };
 }
-/** Fingerprint a read-only source snapshot; build its search index only on demand.
- * No filesystem projection, live-index mutation, model re-embedding or dependency patch. */
-export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, openStore) {
+/** Capture source bytes once per run; each cutoff still owns its index and native model context. */
+export async function historicalTrainingSource(stateDir, chatTypes) {
     const indexPath = join(stateDir, "index.sqlite");
     try {
         statSync(indexPath);
@@ -62,22 +61,13 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
     }
     const manifest = await readSessionManifest(join(stateDir, "sessions-manifest.json"));
     const source = resolveSessionSource(join(stateDir, "sessions"), chatTypes);
-    const createStore = openStore ?? (await import("@unblocklabs/qmd")).createStore;
-    const maxDate = new Date(cutoff).toISOString();
-    const report = { sessions: 0, chunks: 0, excluded: 0, truncated: 0, excludedChunks: 0 };
-    const metadata = new Map();
-    const fingerprint = createHash("sha256").update(JSON.stringify([TRAINING_RETRIEVAL_VERSION, chatTypes.toSorted(), maxDate]));
     // Use QMD's exact binding, never mix node:sqlite with sqlite-vec.
     const requireQmd = createRequire(import.meta.resolve("@unblocklabs/qmd"));
     const Database = requireQmd("better-sqlite3");
     const sourceDb = new Database(indexPath, { readonly: true, fileMustExist: true });
-    const documents = [];
-    let sourceClosed = false, closed = false;
-    const closeSource = () => { if (!sourceClosed) {
-        sourceDb.close();
-        sourceClosed = true;
-    } documents.length = 0; };
-    let indexed;
+    const sessions = [];
+    let excluded = 0;
+    let settings;
     try {
         const extension = requireQmd("sqlite-vec");
         if (!extension || typeof extension !== "object" || !("getLoadablePath" in extension) || typeof extension.getLoadablePath !== "function") {
@@ -88,16 +78,13 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
             throw new Error("QMD sqlite-vec path unavailable");
         sourceDb.loadExtension(extensionPath);
         sourceDb.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=5000; BEGIN");
-        const settings = sourceDb.prepare("SELECT key,value FROM store_config WHERE key='embedding_chunk_strategy'").all();
-        fingerprint.update(JSON.stringify(settings));
+        settings = sourceDb.prepare("SELECT key,value FROM store_config WHERE key='embedding_chunk_strategy'").all();
         const document = sourceDb.prepare(`SELECT d.hash,c.doc FROM documents d JOIN content c ON c.hash=d.hash
         WHERE d.active=1 AND d.collection=? AND d.path=?`);
         const chunks = sourceDb.prepare(`SELECT cv.seq,cv.pos,cv.chunk_len,cv.model,cv.embed_fingerprint,v.embedding
         FROM content_vectors cv JOIN vectors_vec v ON v.hash_seq=cv.hash||'_'||cv.seq
         WHERE cv.hash=? ORDER BY cv.seq`);
-        let dimensions;
-        // Both passes use this same read transaction. Cached evaluations still
-        // verify every prefix/vector byte, but never build an index or load a model.
+        const vectors = new Map();
         let yieldAt = performance.now() + 25;
         for (const session of Object.values(manifest.sessions).sort((a, b) => a.documentPath.localeCompare(b.documentPath))) {
             if (performance.now() >= yieldAt) {
@@ -106,28 +93,67 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
             }
             // Loggie projections can retroactively annotate old text using later revisions.
             // Workspace files and meetings lack immutable historical content proof here.
-            if (!chatTypes.includes(session.chatType) || session.provider === "loggie" || session.startedAt >= cutoff) {
-                report.excluded++;
+            if (!chatTypes.includes(session.chatType) || session.provider === "loggie") {
+                excluded++;
                 continue;
             }
             const row = document.get(source.collection, session.documentPath);
             if (!row || createHash("sha256").update(row.doc).digest("hex") !== session.projectionHash) {
+                excluded++;
+                continue;
+            }
+            let captured = vectors.get(row.hash);
+            if (!captured) {
+                captured = [];
+                for (const chunk of chunks.iterate(row.hash)) {
+                    if (performance.now() >= yieldAt) {
+                        await yieldToEventLoop();
+                        yieldAt = performance.now() + 25;
+                    }
+                    captured.push({ ...chunk, embedding: Buffer.from(chunk.embedding) });
+                }
+                vectors.set(row.hash, captured);
+            }
+            sessions.push({ session, body: row.doc, chunks: captured });
+        }
+    }
+    finally {
+        sourceDb.close();
+    }
+    return async (cutoff, openStore) => {
+        const createStore = openStore ?? (await import("@unblocklabs/qmd")).createStore;
+        const maxDate = new Date(cutoff).toISOString();
+        const report = { sessions: 0, chunks: 0, excluded, truncated: 0, excludedChunks: 0 };
+        const metadata = new Map();
+        const fingerprint = createHash("sha256").update(JSON.stringify([TRAINING_RETRIEVAL_VERSION, chatTypes.toSorted(), maxDate]));
+        fingerprint.update(JSON.stringify(settings));
+        const documents = [];
+        let dimensions, closed = false;
+        let indexed;
+        let yieldAt = performance.now() + 25;
+        for (const { session, body, chunks } of sessions) {
+            if (performance.now() >= yieldAt) {
+                await yieldToEventLoop();
+                yieldAt = performance.now() + 25;
+            }
+            if (session.startedAt >= cutoff) {
                 report.excluded++;
                 continue;
             }
-            const prefix = historicalPrefix(row.doc, session.messages, cutoff);
+            const prefix = historicalPrefix(body, session.messages, cutoff);
             if (!prefix) {
                 report.excluded++;
                 continue;
             }
             const hash = createHash("sha256").update(prefix.body).digest("hex");
-            documents.push({ path: session.documentPath, sourceHash: row.hash, hash, body: prefix.body });
+            const safeChunks = [];
+            documents.push({ path: session.documentPath, hash, body: prefix.body, chunks: safeChunks });
             metadata.set(`qmd://${source.collection}/${session.documentPath}`, prefix.spans);
             fingerprint.update(JSON.stringify([session.documentPath, hash]));
             report.sessions++;
             if (prefix.spans.length < (session.messages?.length ?? 0))
                 report.truncated++;
-            for (const chunk of chunks.iterate(row.hash)) {
+            for (const chunk of chunks) {
                 if (performance.now() >= yieldAt) {
                     await yieldToEventLoop();
                     yieldAt = performance.now() + 25;
@@ -136,13 +162,14 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
                     report.excludedChunks++;
                     continue;
                 }
-                const bytes = Buffer.from(chunk.embedding);
+                const bytes = chunk.embedding;
                 if (bytes.length % 4 || !bytes.length)
                     throw new Error("Invalid historical embedding");
                 const size = bytes.length / 4;
                 dimensions ??= size;
                 if (dimensions !== size)
                     throw new Error("Mixed historical embedding dimensions");
+                safeChunks.push(chunk);
                 fingerprint.update(JSON.stringify([chunk.seq, chunk.pos, chunk.chunk_len, chunk.model, chunk.embed_fingerprint])).update(bytes);
                 report.chunks++;
             }
@@ -175,14 +202,13 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
                     }
                     qmd.internal.insertContent(document.hash, document.body, maxDate);
                     qmd.internal.insertDocument(source.collection, document.path, "Transcript", document.hash, maxDate, maxDate);
-                    for (const chunk of chunks.iterate(document.sourceHash)) {
+                    for (const chunk of document.chunks) {
                         if (performance.now() >= yieldAt) {
                             await yieldToEventLoop();
                             yieldAt = performance.now() + 25;
                         }
-                        if (!historicalChunk(chunk, document.body.length))
-                            continue;
-                        const bytes = Buffer.from(chunk.embedding), vector = new Float32Array(bytes.length / 4);
+                        const bytes = Buffer.from(chunk.embedding.buffer, chunk.embedding.byteOffset, chunk.embedding.byteLength);
+                        const vector = new Float32Array(bytes.length / 4);
                         for (let i = 0; i < vector.length; i++)
                             vector[i] = bytes.readFloatLE(i * 4);
                         qmd.internal.insertEmbedding(document.hash, chunk.seq, chunk.pos, vector, chunk.model, maxDate, 1, chunk.embed_fingerprint, chunk.chunk_len);
@@ -195,9 +221,6 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
                 await qmd?.close();
                 throw error;
             }
-            finally {
-                closeSource();
-            }
         };
         return { corpusHash, report, maxDate,
             search: async (query, lane) => {
@@ -224,14 +247,15 @@ export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, open
                         await indexed.then(qmd => qmd.close(), () => { });
                 }
                 finally {
-                    closeSource();
+                    documents.length = 0;
                 }
             } };
-    }
-    catch (error) {
-        closeSource();
-        throw error;
-    }
+    };
+}
+/** Standalone calls get a fresh source capture; evaluation runs reuse their own capture. */
+export async function historicalTrainingSearch(stateDir, chatTypes, cutoff, openStore) {
+    const source = await historicalTrainingSource(stateDir, chatTypes);
+    return source(cutoff, openStore);
 }
 function historicalChunk(chunk, length) {
     return Number.isSafeInteger(chunk.pos) && Number.isSafeInteger(chunk.chunk_len) && chunk.pos >= 0 && chunk.chunk_len > 0 &&

package/dist/src/typesafe-client.d.ts

@@ -1,5 +1,10 @@
+import { Type } from "typebox";
 import type { UnblockMemoryConfig } from "./config.js";
 export declare const TYPESAFE_MODEL = "jev-1.13.0";
+export declare const TYPESAFE_NOUL_SCHEMA: Type.TObject<{
+    type: Type.TLiteral<"noul">;
+    noul: Type.TNumber;
+}>;
 export declare class TypeSafeRequestError extends Error {
     readonly code: "timeout" | "cancelled" | "http_error" | "invalid_response" | "network_error";
     readonly status?: number | undefined;

package/dist/src/typesafe-client.js

@@ -1,6 +1,10 @@
 import { readFile } from "node:fs/promises";
 import { parseEnv } from "node:util";
+import { Type } from "typebox";
 export const TYPESAFE_MODEL = "jev-1.13.0";
+export const TYPESAFE_NOUL_SCHEMA = Type.Object({
+    type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }),
+});
 export class TypeSafeRequestError extends Error {
     code;
     status;

package/dist/src/typesafe-review.js

@@ -1,7 +1,7 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { backgroundWordCount, PEOPLE_BACKGROUND_MAX_WORDS } from "./people-background.js";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA } from "./typesafe-client.js";
 export { TYPESAFE_MODEL as TYPESAFE_REVIEW_MODEL } from "./typesafe-client.js";
 const relationSchema = Type.Object({ answers: Type.Object({ relation: Type.Object({
             type: Type.Literal("choice"),
@@ -61,8 +61,8 @@ export async function reviewTypeSafeClaim(params) {
     let background;
     if (params.personBackground) {
         const schema = Type.Object({ answers: Type.Object({
-                backgroundOnly: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }),
-                explicitSupport: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }),
+                backgroundOnly: TYPESAFE_NOUL_SCHEMA,
+                explicitSupport: TYPESAFE_NOUL_SCHEMA,
             }) });
         if (!Value.Check(schema, payload))
             throw new Error("TypeSafe returned an invalid background review");
@@ -73,9 +73,7 @@ export async function reviewTypeSafeClaim(params) {
         needsReview: answer.choice !== "supports" || answer.confidence < 0.9 ||
             (background !== undefined && (background.backgroundOnly < 0.9 || background.explicitSupport < 0.9)) };
 }
-const nouls = Type.Object({ answers: Type.Record(Type.String(), Type.Object({
-        type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }),
-    })) });
+const nouls = Type.Object({ answers: Type.Record(Type.String(), TYPESAFE_NOUL_SCHEMA) });
 /** Directional coverage, not topic similarity. Bounded at six comparisons of four ranked candidates. */
 export async function reviewMemoryRedundancy(params) {
     if (params.excerpts.length > 4)

package/dist/src/typesafe.d.ts

@@ -3,6 +3,7 @@ import type { QueryConversation } from "./query-contract.js";
 export declare function selectTypeSafeSkill(params: {
     apiKey: string;
     timeoutMs: number;
+    signal?: AbortSignal;
     currentRequest: string;
     history: readonly {
         role: "user" | "assistant";
@@ -82,12 +83,3 @@ export declare function judgeMemoryPassage(request: ReturnType<typeof memoryUsef
         output_tokens: number;
     } | null;
 }>;
-/** One HTTP request per candidate; result order matches input order. */
-export declare function judgeTypeSafeMemories(params: {
-    apiKey: string;
-    timeoutMs: number;
-    signal: AbortSignal;
-    conversation: QueryConversation;
-    asOf: string;
-    candidates: readonly MemoryPassage[];
-}): Promise<number[]>;

package/dist/src/typesafe.js

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe, TypeSafeRequestError, TYPESAFE_MODEL } from "./typesafe-client.js";
+import { requestTypeSafe, TypeSafeRequestError, TYPESAFE_MODEL, TYPESAFE_NOUL_SCHEMA } from "./typesafe-client.js";
 import { MEMORY_PASSAGE_CHARS } from "./memory-passage.js";
 const SKILL_MIN_USEFULNESS = 0.7;
 /** Select from trusted candidates; never accept a provider-generated path or skill name. */
@@ -26,7 +26,7 @@ export async function selectTypeSafeSkill(params) {
 /** One skill per request; rank the comparable usefulness probabilities in code. */
 async function judgeTypeSafeSkill(params) {
     let payload;
-    payload = await requestTypeSafe({ apiKey: params.apiKey, timeoutMs: params.timeoutMs }, { currentRequest: params.currentRequest, history: params.history,
+    payload = await requestTypeSafe(params, { currentRequest: params.currentRequest, history: params.history,
         candidate: { name: params.candidate.name, description: params.candidate.description } }, { useful: {
             type: "noul",
             instructions: {
@@ -51,9 +51,7 @@ async function judgeTypeSafeSkill(params) {
     return payload.answers.useful.noul;
 }
 const memoryAnswersSchema = Type.Object({
-    answers: Type.Record(Type.String(), Type.Object({
-        type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }),
-    })),
+    answers: Type.Record(Type.String(), TYPESAFE_NOUL_SCHEMA),
 });
 export const QUALITY_JUDGE_VERSION = "jev-1.13.0:quality-v3-isolated";
 /** These are indicators for review, never authorization to delete or rewrite. */
@@ -137,7 +135,7 @@ export function memoryUsefulnessRequest(conversation, candidate, asOf) {
 }
 const memoryJudgmentSchema = Type.Object({
     model: Type.Literal(TYPESAFE_MODEL),
-    answers: Type.Object({ memory_0: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }) }, { additionalProperties: false }),
+    answers: Type.Object({ memory_0: TYPESAFE_NOUL_SCHEMA }, { additionalProperties: false }),
     usage: Type.Optional(Type.Object({ input_tokens: Type.Integer({ minimum: 0 }), output_tokens: Type.Integer({ minimum: 0 }) })),
 });
 function parseMemoryJudgment(payload) {
@@ -150,7 +148,3 @@ function parseMemoryJudgment(payload) {
 export async function judgeMemoryPassage(request, params) {
     return parseMemoryJudgment(await requestTypeSafe(params, request.state, request.questions));
 }
-/** One HTTP request per candidate; result order matches input order. */
-export async function judgeTypeSafeMemories(params) {
-    return Promise.all(params.candidates.map(async (candidate) => (await judgeMemoryPassage(memoryUsefulnessRequest(params.conversation, candidate, params.asOf), params)).probability));
-}

package/docs/configuration.md

@@ -86,7 +86,8 @@ The plugin reads only `TYPESAFE_API_KEY` from the environment. Standalone QMD al
 supports `TYPESAFE_API_KEY_FILE`; these are separate credential resolvers.
 `typesafe.timeoutMs` is not a universal total deadline: People Primer and dossier
 save review use `peoplePrimer.timeoutMs` per request; Memory Whisperer has its
-own overall budget.
+own overall budget. Skill Whisperer's fixed three-second total budget includes
+credential resolution, retrieval and judging, even when its provider timeout is longer.
 
 ## Example profiles
 
@@ -214,7 +215,7 @@ contract; these tables explain their effects.
 | `typesafe.apiKey` | Unset | Explicit inline key; mutually exclusive with key file; prefer file |
 | `typesafe.apiKeyFile` | Unset | Absolute raw-key or dotenv file, reread at credential resolution; explicit missing file never falls back to a different key |
 | `typesafe.timeoutMs` | `1500` | 1–10,000 per request for Skill/Memory Whisperer, quality/claim/cluster review and response audit; **primer and dossier save use `peoplePrimer.timeoutMs` instead** |
-| `skillWhisperer.enabled` | `false` | Requires explicit skills corpus and appropriate host hook access |
+| `skillWhisperer.enabled` | `false` | Requires explicit skills corpus and appropriate host hook access; fixed 3-second total deadline |
 | `skillWhisperer.historyMessages` | `5` | Nonnegative integer; prior visible messages used for routing |
 | `skillWhisperer.minScore` | `0.5` | 0–1, **local vector fallback only**, ignored for TypeSafe shortlist admission |
 | `skillWhisperer.cooldownTurns` | `10` | Nonnegative user-turn count; no fallback to weaker cooling-down alternatives |

package/docs/retrieval.md

@@ -380,6 +380,12 @@ for the trusted LAN/loopback only; use TLS or a private tunnel across untrusted
 Visible conversation text is sent to this endpoint, never tool outputs/thinking.
 Approve only corpora suitable for every audience of the agent.
 
+The packaged `src/mlx-query-worker.py` is a standalone JSON-lines worker for
+separately managed model-serving integrations, not a Gateway subprocess or HTTP
+server. It is retained with `query_contract.py` and the pinned tokenizer assets;
+the latter also define the training-data contract. A host service owns any adapter
+between that private worker protocol and the HTTP API below.
+
 `POST /generate` accepts `{id, conversation: {history, currentRequest}}` and returns
 `{response: {id, text}}`, where `text` is JSON with exactly two nonempty strings,
 `lex` and `vec`. The request ID must match. Redirects, malformed/oversized responses,
@@ -464,6 +470,13 @@ successful siblings can still qualify. If all fail, no hint is emitted. It does
 not switch to vector-only selection. There are no automatic HTTP retries. Other
 credential-file read errors likewise produce a warning and no hint.
 
+The complete skill contribution has a fixed three-second deadline, including
+credential resolution, retrieval and provider calls. A slow skill lookup cannot
+hold up ready memory or people hints beyond that budget. Session teardown,
+superseding turns and Gateway shutdown cancel its wait and provider requests;
+shared indexing/embedding work can finish for other callers, but cannot trigger
+late Jev calls or hints for the cancelled run.
+
 **Privacy:** enabled TypeSafe selection sends up to 12,000 characters of current
 prompt/recent user-assistant text, plus the shortlisted names/descriptions, to
 `api.typesafe.ai`. Source-path fields, full skill procedures, tool-result messages,
@@ -476,7 +489,8 @@ The defaults use five prior messages, a vector-only score threshold of `0.5`,
 and a ten-turn cooldown. A skill is cooling down after either a suggestion or a
 successful direct `read` of its indexed `SKILL.md`. When the selected
 skill is cooling down, no hint is emitted; Skill Whisperer does not fall through
-to a weaker match. Cooldown state is per session and intentionally resets with
+to a weaker match. When every shortlisted skill is cooling down, Jev is skipped.
+Cooldown state is per session and intentionally resets with
 the Gateway. Shell-command reads are not tracked.
 
 The `skills` corpus shares the existing QMD store and warm embedding model but

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": true },
@@ -67,7 +67,7 @@
       "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."
     },
     "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 also has its own total deadline." },
+    "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." },
     "typesafe.apiKeyFile": {
       "label": "TypeSafe Key File",
       "help": "Absolute path to a plaintext API key or a dotenv file containing TYPESAFE_API_KEY. Prefer this over storing a key in config."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "@huggingface/tokenizers": "0.2.0",
-    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.10.3/unblocklabs-qmd-2.10.3.tgz",
+    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.11.0/unblocklabs-qmd-2.11.0.tgz",
     "chokidar": "5.0.0",
     "js-tiktoken": "1.0.21",
     "picomatch": "^4.0.5",