@unblocklabs/unblock-memory 0.7.1 → 0.7.3

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/training-store.d.ts

@@ -85,15 +85,9 @@ export declare class TrainingStore {
         error: string;
     }): void;
     retry(includeAmbiguous: boolean, ids: readonly string[]): number;
-    activeExamples(): TrainingSourceExample[];
-    queryExamples(threshold?: number): {
+    queryExamples(threshold?: number): (TrainingSourceExample & {
         recallProbability: number;
-        id: string;
-        inputHash: string;
-        inputJson: string;
-        sessionId: string;
-        timestamp: number;
-    }[];
+    })[];
     step<S extends keyof TrainingStepResults>(stage: S, parameters: Record<string, unknown>): {
         id: string;
         stage: S;

package/dist/src/training-store.js

@@ -136,20 +136,21 @@ export class TrainingStore {
             this.#db.prepare("UPDATE training_examples SET active=0 WHERE session_id=?").run(sessionId);
             const counts = { added: 0, changed: 0, unchanged: 0, retired: 0 };
             const retained = new Set();
+            const input = this.#db.prepare("INSERT OR IGNORE INTO training_inputs VALUES (?,?,?)");
+            const source = this.#db.prepare(`INSERT INTO training_examples VALUES (?,?,?,?,?,?,1)
+        ON CONFLICT(session_id,event_seq) DO UPDATE SET timestamp=excluded.timestamp,input_hash=excluded.input_hash,
+        context_limited=excluded.context_limited,active=1`);
+            const gate = this.#db.prepare(`INSERT OR IGNORE INTO training_gates
+        (id,input_hash,prompt_version,requested_model,status) VALUES (?,?,?,?,'pending')`);
             for (const example of examples) {
                 const old = previous.get(example.seq);
                 if (!old && (existingOnly || example.timestamp < since || example.timestamp >= until))
                     continue;
                 retained.add(example.seq);
-                this.#db.prepare("INSERT OR IGNORE INTO training_inputs VALUES (?,?,?)")
-                    .run(example.inputHash, TRAINING_PREPARATION, JSON.stringify(example.input));
-                this.#db.prepare(`INSERT INTO training_examples VALUES (?,?,?,?,?,?,1)
-          ON CONFLICT(session_id,event_seq) DO UPDATE SET timestamp=excluded.timestamp,input_hash=excluded.input_hash,
-          context_limited=excluded.context_limited,active=1`)
-                    .run(trainingHash([this.#nodeId, this.#agentId, sessionId, example.seq]), sessionId, example.seq, example.timestamp, example.inputHash, Number(example.contextLimited));
+                input.run(example.inputHash, TRAINING_PREPARATION, JSON.stringify(example.input));
+                source.run(trainingHash([this.#nodeId, this.#agentId, sessionId, example.seq]), sessionId, example.seq, example.timestamp, example.inputHash, Number(example.contextLimited));
                 const id = trainingHash([example.inputHash, TRAINING_GATE_VERSION, TRAINING_GATE_MODEL]);
-                this.#db.prepare(`INSERT OR IGNORE INTO training_gates (id,input_hash,prompt_version,requested_model,status) VALUES (?,?,?,?,'pending')`)
-                    .run(id, example.inputHash, TRAINING_GATE_VERSION, TRAINING_GATE_MODEL);
+                gate.run(id, example.inputHash, TRAINING_GATE_VERSION, TRAINING_GATE_MODEL);
                 if (!old)
                     counts.added++;
                 else if (old.input_hash !== example.inputHash || old.active !== 1)
@@ -211,21 +212,15 @@ export class TrainingStore {
             return count + Number(gates.changes) + Number(steps.changes);
         }, 0));
     }
-    activeExamples() {
-        return this.#db.prepare(`SELECT e.id,e.input_hash inputHash,i.input_json inputJson,e.session_id sessionId,e.timestamp
-      FROM training_examples e JOIN training_inputs i ON i.hash=e.input_hash
-      WHERE e.active=1 AND i.preparation=? ORDER BY e.timestamp DESC,e.id`).all(TRAINING_PREPARATION);
-    }
     queryExamples(threshold = TRAINING_GATE_THRESHOLD) {
         if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1)
             throw new Error("Threshold must be between 0 and 1");
-        const probabilities = new Map(this.#db.prepare(`SELECT g.input_hash,g.probability FROM training_gates g
-      WHERE ${this.#scope} AND g.status='complete' AND g.probability>=?`)
-            .all(TRAINING_GATE_VERSION, TRAINING_GATE_MODEL, TRAINING_PREPARATION, threshold).map(row => [String(row.input_hash), Number(row.probability)]));
-        return this.activeExamples().flatMap(example => {
-            const recallProbability = probabilities.get(example.inputHash);
-            return recallProbability === undefined ? [] : [{ ...example, recallProbability }];
-        });
+        return this.#db.prepare(`SELECT e.id,e.input_hash inputHash,i.input_json inputJson,e.session_id sessionId,e.timestamp,
+      g.probability recallProbability FROM training_examples e JOIN training_inputs i ON i.hash=e.input_hash
+      JOIN training_gates g ON g.input_hash=e.input_hash
+      WHERE e.active=1 AND i.preparation=? AND g.prompt_version=? AND g.requested_model=?
+      AND g.status='complete' AND g.probability>=? ORDER BY e.timestamp DESC,e.id`)
+            .all(TRAINING_PREPARATION, TRAINING_GATE_VERSION, TRAINING_GATE_MODEL, threshold);
     }
     step(stage, parameters) {
         const request = { ...parameters, recipe: TRAINING_RECIPE_VERSION };

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/dist/src/whisperer-context.d.ts

@@ -3,4 +3,8 @@ export declare function messageText(message: unknown): {
     role: "user" | "assistant";
     text: string;
 } | undefined;
-export declare function buildSkillWhispererQuery(prompt: string, messages: readonly unknown[], historyMessages: number): string;
+export declare function recentSkillMessages(messages: readonly unknown[], limit: number): {
+    role: "user" | "assistant";
+    text: string;
+}[];
+export declare function buildSkillWhispererQuery(prompt: string, history: readonly NonNullable<ReturnType<typeof messageText>>[]): string;

package/dist/src/whisperer-context.js

@@ -11,11 +11,16 @@ export function messageText(message) {
         }).join("\n").trim() : "";
     return text ? { role: message.role, text } : undefined;
 }
-export function buildSkillWhispererQuery(prompt, messages, historyMessages) {
-    const availableHistory = messages.flatMap(message => {
-        const parsed = messageText(message);
-        return parsed ? [`${parsed.role}: ${parsed.text}`] : [];
-    });
-    const history = historyMessages === 0 ? [] : availableHistory.slice(-historyMessages);
-    return [...history, `user: ${prompt.trim()}`].join("\n\n").slice(-MAX_SKILL_QUERY_CHARS);
+export function recentSkillMessages(messages, limit) {
+    const history = [];
+    for (let i = messages.length - 1; i >= 0 && history.length < limit; i--) {
+        const parsed = messageText(messages[i]);
+        if (parsed)
+            history.push(parsed);
+    }
+    return history.reverse();
+}
+export function buildSkillWhispererQuery(prompt, history) {
+    return [...history.map(message => `${message.role}: ${message.text}`), `user: ${prompt.trim()}`]
+        .join("\n\n").slice(-MAX_SKILL_QUERY_CHARS);
 }

package/dist/src/workspace-path-classifier.js

@@ -2,40 +2,47 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { isPathStrictlyInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { readMemoryArtifactProvenance } from "openclaw/plugin-sdk/memory-core-host-runtime-core";
-export const classifyWorkspaceMemoryPaths = async (params) => await Promise.all(params.relativePaths.map(async (relativePath) => {
+export const classifyWorkspaceMemoryPaths = async (params) => {
+    if (!params.relativePaths.length)
+        return [];
     let workspacePath;
-    let filePath;
     try {
-        [workspacePath, filePath] = await Promise.all([
-            fs.realpath(params.workspaceDir),
-            fs.realpath(path.resolve(params.workspaceDir, relativePath)),
-        ]);
+        workspacePath = await fs.realpath(params.workspaceDir);
     }
     catch {
-        return { relativePath, originClass: "untrusted" };
+        return params.relativePaths.map(relativePath => ({ relativePath, originClass: "untrusted" }));
     }
-    if (!isPathStrictlyInside(workspacePath, filePath)) {
-        return { relativePath, originClass: "untrusted" };
-    }
-    const workspaceRelativePath = path.relative(workspacePath, filePath);
-    const segments = workspaceRelativePath.split(path.sep);
-    const curatedRoot = segments.length === 1 &&
-        ["MEMORY.md", "memory.md", "USER.md"].includes(segments[0]);
-    if ((segments.length === 1 && ["DREAMS.md", "dreams.md"].includes(segments[0])) ||
-        (segments[0] === "memory" && ["dreaming", ".dreams"].includes(segments[1]))) {
-        return { relativePath, originClass: "system" };
-    }
-    const isWorkspaceMemory = curatedRoot ||
-        (segments[0] === "memory" && segments.at(-1)?.endsWith(".md") === true);
-    const normalizedPath = workspaceRelativePath.replaceAll(path.sep, "/");
-    const recorded = isWorkspaceMemory
-        ? await readMemoryArtifactProvenance({
-            workspaceDir: params.workspaceDir,
-            relativePath: normalizedPath,
-        })
-        : undefined;
-    return {
-        relativePath,
-        originClass: recorded?.originClass ?? (isWorkspaceMemory ? "agent" : "untrusted"),
-    };
-}));
+    return await Promise.all(params.relativePaths.map(async (relativePath) => {
+        let filePath;
+        try {
+            filePath = await fs.realpath(path.resolve(params.workspaceDir, relativePath));
+        }
+        catch {
+            return { relativePath, originClass: "untrusted" };
+        }
+        if (!isPathStrictlyInside(workspacePath, filePath)) {
+            return { relativePath, originClass: "untrusted" };
+        }
+        const workspaceRelativePath = path.relative(workspacePath, filePath);
+        const segments = workspaceRelativePath.split(path.sep);
+        const curatedRoot = segments.length === 1 &&
+            ["MEMORY.md", "memory.md", "USER.md"].includes(segments[0]);
+        if ((segments.length === 1 && ["DREAMS.md", "dreams.md"].includes(segments[0])) ||
+            (segments[0] === "memory" && ["dreaming", ".dreams"].includes(segments[1]))) {
+            return { relativePath, originClass: "system" };
+        }
+        const isWorkspaceMemory = curatedRoot ||
+            (segments[0] === "memory" && segments.at(-1)?.endsWith(".md") === true);
+        const normalizedPath = workspaceRelativePath.replaceAll(path.sep, "/");
+        const recorded = isWorkspaceMemory
+            ? await readMemoryArtifactProvenance({
+                workspaceDir: params.workspaceDir,
+                relativePath: normalizedPath,
+            })
+            : undefined;
+        return {
+            relativePath,
+            originClass: recorded?.originClass ?? (isWorkspaceMemory ? "agent" : "untrusted"),
+        };
+    }));
+};

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/memory-training.md

@@ -70,9 +70,11 @@ continue without retrying failed requests. Storage/lease failures still stop the
 In-flight work drains and persists before snapshots close. Dry runs make no inference calls.
 
 Cached evaluations still validate the exact historical text and vector fingerprint,
-but do not rebuild a QMD index. The index is built only on the first uncached search,
-from the same read-only SQLite transaction used to compute that fingerprint.
-Concurrent queries share that index; changed corpus content still invalidates caches.
+but do not rebuild a QMD index. Each evaluation run captures immutable source text
+and vector bytes once, then closes the source reader. Each exact cutoff derives its
+own fingerprint and builds a private index only on its first uncached search.
+Concurrent queries at that cutoff share the index; later runs capture fresh source
+bytes, so changed corpus content still invalidates caches.
 
 ## Input and historical boundaries
 
@@ -99,10 +101,9 @@ unknown/future dates. Never infer dates from quoted headings. Copy existing vect
 only for complete chunks within the safe prefix; BM25 sees that same prefix.
 Validate returned passages/dates again. No reembedding or temporary transcripts.
 
-QMD cannot independently set per-method depth through its public search API.
-A small discovery adapter retains its tokenization, FTS-highlight chunk selection,
-source-aware dedup and installed chunk helpers, but requests ten from the selected
-backend and omits query-conditioned scoring. It does not rewrite QMD. Training and
+QMD's public `discoverCandidates` API owns tokenization, FTS-highlight chunk
+selection and source-aware deduplication. A small adapter requests ten from the
+selected backend and omits query-conditioned scoring. Training and
 runtime share complete-excerpt rendering, including the 1,200-character cap;
 oversized matches are discarded rather than truncated.
 

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.1",
+  "version": "0.7.3",
   "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."