@unblocklabs/unblock-memory 0.7.2 → 0.7.3

package/dist/src/analysis.js

@@ -260,8 +260,8 @@ function byteSlice(text, maxBytes) {
         return "";
     return bytes.subarray(0, maxBytes - 3).toString("utf8").replace(/\uFFFD$/u, "") + "…";
 }
-function members(db, runId, clusterId, limit, offset = 0, sort = "representative", maxExcerptBytes = MAX_EXCERPT_BYTES, maxTotalBytes = MAX_TOTAL_EXCERPT_BYTES, maxTotalAliases = MAX_TOTAL_ALIASES, temporal = {}) {
-    const representativeOrder = clusterId === -1
+function representativeOrder(clusterId) {
+    return clusterId === -1
         ? "m.outlier_score DESC, m.hash, m.seq"
         : `CASE WHEN m.representative_rank IS NULL THEN 1 ELSE 0 END,
        m.representative_rank,
@@ -269,9 +269,11 @@ function members(db, runId, clusterId, limit, offset = 0, sort = "representative
        m.outlier_score,
        m.hash,
        m.seq`;
+}
+function members(db, runId, clusterId, limit, offset = 0, sort = "representative", maxExcerptBytes = MAX_EXCERPT_BYTES, maxTotalBytes = MAX_TOTAL_EXCERPT_BYTES, maxTotalAliases = MAX_TOTAL_ALIASES, temporal = {}) {
     const score = clusterId === -1 ? "m.outlier_score" : "m.probability";
     const order = {
-        representative: representativeOrder,
+        representative: representativeOrder(clusterId),
         score_desc: `${score} DESC, m.hash, m.seq`,
         score_asc: `${score} ASC, m.hash, m.seq`,
         date_desc: "julianday(COALESCE(m.event_time, m.source_modified_at)) DESC, m.hash, m.seq",
@@ -395,24 +397,34 @@ function readMetadata(run) {
     }
     return { stale: false, staleSince: null, analyzedAt: run.completed_at };
 }
+function clusterPreview(db, runId, clusterId, maxBytes, aliasLimit) {
+    const row = db.prepare(`
+    SELECT m.hash, m.seq, m.probability, m.pos, m.chunk_len, m.doc
+    FROM memory_analysis_available_memberships m
+    WHERE m.run_id = ? AND m.cluster_id = ?
+    ORDER BY ${representativeOrder(clusterId)}
+    LIMIT 1
+  `).get(runId, clusterId);
+    if (!row)
+        return undefined;
+    return {
+        hash: row.hash,
+        seq: row.seq,
+        probability: row.probability,
+        text: byteSlice(row.doc.slice(row.pos, row.pos + row.chunk_len), maxBytes),
+        sourcePaths: sourcePaths(db, row.hash, Math.min(MAX_ALIASES_PER_MEMBER, aliasLimit)),
+    };
+}
 function toSummary(db, run, row, includePreview, previewBytes = 600, aliasLimit = MAX_TOTAL_ALIASES) {
     const preview = includePreview
-        ? members(db, run.id, row.cluster_id, 1, 0, "representative", previewBytes, previewBytes, aliasLimit)[0]
+        ? clusterPreview(db, run.id, row.cluster_id, previewBytes, aliasLimit)
         : undefined;
     return {
         clusterId: clusterReference(run.id, row.cluster_id),
         size: row.size,
         availableSize: row.available_size,
         meanProbability: row.mean_probability,
-        ...(preview ? {
-            preview: {
-                hash: preview.hash,
-                seq: preview.seq,
-                probability: preview.probability,
-                text: preview.text,
-                sourcePaths: preview.sourcePaths,
-            },
-        } : {}),
+        ...(preview ? { preview } : {}),
     };
 }
 function noiseRow(db, runId) {

package/dist/src/config.js

@@ -291,23 +291,8 @@ function resolvePeople(value) {
     };
 }
 export function resolveConfig(value) {
-    if (value === undefined || value === null) {
-        return {
-            corpora: DEFAULT_CORPORA,
-            extraction: resolveExtraction(undefined, DEFAULT_CORPORA),
-            keepEmbeddingModelWarm: true,
-            analysis: {},
-            typesafe: { ...DEFAULT_TYPESAFE_CONFIG },
-            qualityAudit: { ...DEFAULT_QUALITY_AUDIT },
-            evidenceReview: { enabled: false, corpora: [] },
-            responseAudit: resolveResponseAudit(undefined, DEFAULT_CORPORA),
-            insideOut: resolveInsideOut(undefined),
-            peoplePrimer: resolvePeoplePrimer(undefined, DEFAULT_CORPORA, false),
-            people: DEFAULT_PEOPLE_CONFIG,
-            skillWhisperer: DEFAULT_SKILL_WHISPERER,
-            memoryWhisperer: { ...DEFAULT_MEMORY_WHISPERER, api: resolveQueryApi(undefined) },
-        };
-    }
+    if (value === undefined || value === null)
+        value = {};
     if (typeof value !== "object" || Array.isArray(value)) {
         throw new Error("unblock-memory config must be an object");
     }

package/dist/src/manager.d.ts

@@ -12,7 +12,7 @@ import { reviewIndexedClaim } from "./evidence-review.js";
 import { reviewClusterIngestion } from "./cluster-review.js";
 import type { QueryPair } from "./query-contract.js";
 export { expandSessionSearchHit } from "./memory-passage.js";
-export type ManagerStore = Pick<QMDStore, "update" | "embed" | "getStatus" | "listCollections" | "vsearch" | "get" | "getDocumentBody" | "close">;
+export type ManagerStore = Pick<QMDStore, "update" | "embed" | "getStatus" | "listCollections" | "vsearch" | "get" | "close">;
 export type ManagerSessionConfig = {
     agentId: string;
     agentName: string;

package/dist/src/manager.js

@@ -991,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,

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-store.js

@@ -147,6 +147,7 @@ export class PeopleStore {
     #db;
     #maxOpenTodos;
     #maxBlurbChars;
+    #primerCacheReady = false;
     constructor(path, options) {
         this.#db = openMemoryDatabase(path);
         this.#maxOpenTodos = options.maxOpenTodos;
@@ -167,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/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/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

@@ -87,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/runtime.js

@@ -106,7 +106,8 @@ export class QmdMemoryRuntime {
             return { manager: await pending };
         }
         catch (error) {
-            this.#managers.delete(params.agentId);
+            if (this.#managers.get(params.agentId) === pending)
+                this.#managers.delete(params.agentId);
             return { manager: null, error: error instanceof Error ? error.message : String(error) };
         }
     }

package/dist/src/session-sync.js

@@ -332,8 +332,9 @@ export async function syncSessionProjections(params) {
         else
             counts.unchanged += 1;
     }
+    const liveIds = new Set(snapshot.windows.map(window => window.sessionId));
     for (const [sessionId, session] of Object.entries(previousManifest.sessions)) {
-        if (sessions[sessionId] || snapshot.windows.some((window) => window.sessionId === sessionId))
+        if (sessions[sessionId] || liveIds.has(sessionId))
             continue;
         await remove(projectionPath(params.outputDir, session.documentPath));
         counts.removed += 1;

package/dist/src/skill-whisperer.js

@@ -1,7 +1,7 @@
 import { basename } from "node:path";
 import { selectTypeSafeSkill } from "./typesafe.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
-import { buildSkillWhispererQuery, messageText } from "./whisperer-context.js";
+import { buildSkillWhispererQuery, recentSkillMessages } from "./whisperer-context.js";
 import { abortable } from "./abortable.js";
 const CANDIDATE_LIMIT = 10;
 const MAX_QUERY_CHARS = 12_000;
@@ -10,18 +10,15 @@ const TOTAL_TIMEOUT_MS = 3000;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function typeSafeConversation(prompt, messages, historyMessages) {
+function typeSafeConversation(prompt, messages) {
     const currentRequest = prompt.trim().slice(-MAX_QUERY_CHARS);
     let remaining = MAX_QUERY_CHARS - currentRequest.length;
-    const available = messages.flatMap(message => {
-        const parsed = messageText(message);
-        return parsed ? [{ role: parsed.role, content: parsed.text }] : [];
-    });
     const history = [];
-    for (const message of (historyMessages ? available.slice(-historyMessages) : []).reverse()) {
+    for (let i = messages.length - 1; i >= 0; i--) {
         if (remaining <= 0)
             break;
-        const content = message.content.slice(-remaining);
+        const message = messages[i];
+        const content = message.text.slice(-remaining);
         history.unshift({ role: message.role, content });
         remaining -= content.length;
     }
@@ -73,7 +70,8 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                 signal.throwIfAborted();
                 if (!apiKey)
                     diagnostics?.record(agentId, "skill", typesafe.enabled ? "missing_key" : "typesafe_disabled");
-                const candidates = await abortable(runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT), signal);
+                const recentMessages = recentSkillMessages(event.messages, config.historyMessages);
+                const candidates = await abortable(runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, recentMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT), signal);
                 signal.throwIfAborted();
                 const resolvedCandidates = candidates.flatMap((candidate) => {
                     const canonicalPath = runtime.resolveSkillPath(runtimeParams, candidate.path);
@@ -96,7 +94,7 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                     }
                     const selectedIndex = await abortable(selectTypeSafeSkill({
                         apiKey, timeoutMs: typesafe.timeoutMs, signal,
-                        ...typeSafeConversation(event.prompt, event.messages, config.historyMessages),
+                        ...typeSafeConversation(event.prompt, recentMessages),
                         candidates: shortlist.map(({ candidate }) => candidate),
                         onCandidateFailure: (candidateIndex, error) => {
                             if (signal.aborted)

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/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/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/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",
@@ -37,16 +37,18 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "knip": "knip --reporter compact",
-    "test": "node --import tsx --test --test-concurrency=1 tests/**/*.test.ts tests/**/*.test.mjs",
+    "test": "npm run test:node && npm run test:python",
+    "test:node": "node --import tsx --test --test-concurrency=1 tests/**/*.test.ts tests/**/*.test.mjs",
+    "test:python": "python3 -B tests/prepare-query-training.test.py",
     "eval:retrieval": "node --import tsx eval/retrieval/lab.ts",
     "plugin:inspect": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw",
-    "plugin:inspect:runtime": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw --runtime --mock-sdk --allow-execute",
+    "plugin:inspect:runtime": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw --runtime --real-sdk --allow-execute",
     "release:check": "node scripts/check-release-version.mjs",
     "preflight": "npm run knip && npm run build && npm run typecheck && npm test && npm run plugin:inspect && npm run plugin:inspect:runtime && npm pack --dry-run"
   },
   "dependencies": {
     "@huggingface/tokenizers": "0.2.0",
-    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.11.0/unblocklabs-qmd-2.11.0.tgz",
+    "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.11.1/unblocklabs-qmd-2.11.1.tgz",
     "chokidar": "5.0.0",
     "js-tiktoken": "1.0.21",
     "picomatch": "^4.0.5",