@unblocklabs/unblock-memory 0.7.1 → 0.7.3

package/dist/src/review-tools.js

@@ -13,6 +13,18 @@ const claimParameters = Type.Object({
 }, { additionalProperties: false });
 const clusterParameters = Type.Object({ clusterId: Type.String({ pattern: "^[0-9a-f]{10}$" }) }, { additionalProperties: false });
 const noParameters = Type.Object({}, { additionalProperties: false });
+/** Bound initialization as well as inference, without cancelling shared managers. */
+export async function reviewRequestContext(runtime, active, typesafe, signal) {
+    const deadline = AbortSignal.timeout(30_000);
+    const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    const apiKey = await abortable(resolveTypeSafeApiKey(typesafe), combined);
+    if (!apiKey)
+        return { status: "unavailable", reason: "TypeSafe API key not configured" };
+    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
+    if (!manager)
+        return { status: "unavailable", reason: "Memory manager unavailable" };
+    return { status: "ready", manager, apiKey, signal: combined, timeoutMs: typesafe.timeoutMs };
+}
 export function registerReviewTools(api, runtime, config, diagnostics) {
     api.registerTool(ctx => {
         const active = getContext(ctx);
@@ -59,20 +71,12 @@ export function registerReviewTools(api, runtime, config, diagnostics) {
                 const parsed = Value.Parse(claimParameters, params);
                 if (!config.evidenceReview.enabled || !config.typesafe.enabled)
                     return jsonResult({ status: "disabled" });
-                const deadline = AbortSignal.timeout(30_000);
-                const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
                 try {
-                    combined.throwIfAborted();
-                    const apiKey = await abortable(resolveTypeSafeApiKey(config.typesafe), combined);
-                    combined.throwIfAborted();
-                    if (!apiKey)
-                        return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
-                    combined.throwIfAborted();
-                    if (!manager)
-                        return jsonResult({ status: "unavailable" });
-                    return jsonResult(await manager.reviewClaim({ ...parsed, corpora: config.evidenceReview.corpora,
-                        apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined }));
+                    const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                    if (context.status !== "ready")
+                        return jsonResult(context);
+                    return jsonResult(await context.manager.reviewClaim({ ...parsed, corpora: config.evidenceReview.corpora,
+                        apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal }));
                 }
                 catch {
                     return jsonResult({ status: "unavailable", needsReview: true, reason: "Claim review failed or was cancelled; no claim verified" });
@@ -92,20 +96,12 @@ export function registerReviewTools(api, runtime, config, diagnostics) {
                 const parsed = Value.Parse(clusterParameters, params);
                 if (!config.qualityAudit.enabled || !config.typesafe.enabled)
                     return jsonResult({ status: "disabled" });
-                const deadline = AbortSignal.timeout(30_000);
-                const combined = signal ? AbortSignal.any([signal, deadline]) : deadline;
                 try {
-                    combined.throwIfAborted();
-                    const apiKey = await abortable(resolveTypeSafeApiKey(config.typesafe), combined);
-                    combined.throwIfAborted();
-                    if (!apiKey)
-                        return jsonResult({ status: "unavailable", reason: "TypeSafe API key not configured" });
-                    const { manager } = await abortable(runtime.getMemorySearchManager(active), combined);
-                    combined.throwIfAborted();
-                    if (!manager)
-                        return jsonResult({ status: "unavailable" });
-                    return jsonResult(await manager.reviewCluster({ ...parsed, corpora: config.qualityAudit.corpora,
-                        apiKey, timeoutMs: config.typesafe.timeoutMs, signal: combined }));
+                    const context = await reviewRequestContext(runtime, active, config.typesafe, signal);
+                    if (context.status !== "ready")
+                        return jsonResult(context);
+                    return jsonResult(await context.manager.reviewCluster({ ...parsed, corpora: config.qualityAudit.corpora,
+                        apiKey: context.apiKey, timeoutMs: context.timeoutMs, signal: context.signal }));
                 }
                 catch {
                     return jsonResult({ status: "unavailable", reason: "Cluster review failed or was cancelled; no cluster judgment made" });

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

@@ -109,8 +109,8 @@ export function projectMessage(row, input) {
         timestamp: timestamp(eventRecord.timestamp) ?? row.createdAt ?? timestamp(message.timestamp) ?? input.startedAt,
     };
 }
-function formatTimestamp(value, timezone) {
-    const parts = new Intl.DateTimeFormat("en-CA", {
+function timestampFormatter(timezone) {
+    return new Intl.DateTimeFormat("en-CA", {
         timeZone: timezone,
         year: "numeric",
         month: "2-digit",
@@ -120,7 +120,10 @@ function formatTimestamp(value, timezone) {
         second: "2-digit",
         hourCycle: "h23",
         timeZoneName: "short",
-    }).formatToParts(value);
+    });
+}
+function formatTimestamp(value, formatter) {
+    const parts = formatter.formatToParts(value);
     const part = (type) => parts.find((entry) => entry.type === type)?.value ?? "";
     return `${part("year")}-${part("month")}-${part("day")} ` +
         `${part("hour")}:${part("minute")}:${part("second")} ${part("timeZoneName")}`.trim();
@@ -169,11 +172,12 @@ export function projectSessionDocument(input) {
     }
     let content = "# Transcript\n\n";
     const spans = [];
+    const formatter = timestampFormatter(input.timezone);
     for (const message of messages.filter(message => !hidden.has(message))) {
         if (spans.length)
             content += "\n\n";
         const start = content.length;
-        const timestamp = formatTimestamp(message.timestamp, input.timezone);
+        const timestamp = formatTimestamp(message.timestamp, formatter);
         content += `## ${message.role === "user" ? "User" : "Assistant"} — ${message.speaker} — ${timestamp}\n\n`;
         const bodyStart = content.length;
         content += message.text;

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,25 +1,24 @@
 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;
 const TYPESAFE_CANDIDATE_LIMIT = 3;
+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;
     }
@@ -56,16 +55,24 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         const state = stateFor(scope);
         if (state.lastRunId === runId)
             return state.result;
+        state.controller?.abort();
+        const controller = new AbortController();
+        state.controller = controller;
+        const { signal } = controller;
+        const timer = setTimeout(() => controller.abort(new DOMException("Skill deadline", "TimeoutError")), TOTAL_TIMEOUT_MS);
         state.lastRunId = runId;
         state.turn += 1;
         // Reuse even an in-flight result when the host rebuilds this run's prompt.
         const run = async () => {
             try {
                 const runtimeParams = active(agentId);
-                const apiKey = await resolveTypeSafeApiKey(typesafe);
+                const apiKey = await abortable(resolveTypeSafeApiKey(typesafe), signal);
+                signal.throwIfAborted();
                 if (!apiKey)
                     diagnostics?.record(agentId, "skill", typesafe.enabled ? "missing_key" : "typesafe_disabled");
-                const candidates = await runtime.searchSkills(runtimeParams, buildSkillWhispererQuery(event.prompt, event.messages, config.historyMessages), apiKey ? -1 : config.minScore, CANDIDATE_LIMIT);
+                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);
                     return canonicalPath ? [{ candidate, canonicalPath }] : [];
@@ -75,19 +82,29 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                     diagnostics?.record(agentId, "skill", "no_candidates");
                     return;
                 }
+                const cooling = (path) => {
+                    const previous = state.skills.get(path);
+                    return state.turn - Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity) <= config.cooldownTurns;
+                };
                 if (apiKey) {
                     const shortlist = resolvedCandidates.slice(0, TYPESAFE_CANDIDATE_LIMIT);
-                    const selectedIndex = await selectTypeSafeSkill({
-                        apiKey, timeoutMs: typesafe.timeoutMs,
-                        ...typeSafeConversation(event.prompt, event.messages, config.historyMessages),
+                    if (shortlist.every(({ canonicalPath }) => cooling(canonicalPath))) {
+                        diagnostics?.record(agentId, "skill", "cooldown");
+                        return;
+                    }
+                    const selectedIndex = await abortable(selectTypeSafeSkill({
+                        apiKey, timeoutMs: typesafe.timeoutMs, signal,
+                        ...typeSafeConversation(event.prompt, recentMessages),
                         candidates: shortlist.map(({ candidate }) => candidate),
                         onCandidateFailure: (candidateIndex, error) => {
+                            if (signal.aborted)
+                                return;
                             diagnostics?.record(agentId, "skill", "judge_candidate_failed");
                             api.logger.warn("unblock-memory skill_whisperer " + JSON.stringify({ event: "candidate_failed",
                                 agentId, runId, candidateIndex, errorCode: error instanceof TypeSafeRequestError ? error.code : "unexpected",
                                 httpStatus: error instanceof TypeSafeRequestError ? error.status : undefined }));
                         },
-                    });
+                    }), signal);
                     if (selectedIndex === undefined) {
                         diagnostics?.record(agentId, "skill", "rejected");
                         return;
@@ -108,9 +125,7 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                 const { candidate: selected, canonicalPath } = resolved;
                 if (apiKey && runtime.resolveSkillPath(runtimeParams, selected.path) !== canonicalPath)
                     return;
-                const previous = state.skills.get(canonicalPath);
-                const lastSeen = Math.max(previous?.suggested ?? -Infinity, previous?.opened ?? -Infinity);
-                if (state.turn - lastSeen <= config.cooldownTurns) {
+                if (cooling(canonicalPath)) {
                     diagnostics?.record(agentId, "skill", "cooldown");
                     return;
                 }
@@ -123,10 +138,16 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
                 };
             }
             catch (error) {
-                diagnostics?.record(agentId, "skill", error instanceof TypeSafeRequestError && error.code === "timeout" ? "timed_out" : "failed");
-                api.logger.warn("unblock-memory skill whisperer failed; no hint emitted");
+                const timedOut = (error instanceof TypeSafeRequestError && error.code === "timeout") ||
+                    (signal.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError");
+                diagnostics?.record(agentId, "skill", timedOut ? "timed_out" : signal.aborted ? "cancelled" : "failed");
+                if (!signal.aborted)
+                    api.logger.warn("unblock-memory skill whisperer failed; no hint emitted");
                 return;
             }
+            finally {
+                clearTimeout(timer);
+            }
         };
         state.result = run();
         return state.result;
@@ -153,11 +174,17 @@ export function registerSkillWhisperer(api, runtime, config, typesafe, diagnosti
         }
     }, { matcher: ["read"] });
     api.on("session_end", (event, context) => {
-        sessions.delete(event.sessionId);
-        if (event.sessionKey)
-            sessions.delete(event.sessionKey);
-        if (context.sessionKey)
-            sessions.delete(context.sessionKey);
+        for (const scope of [event.sessionId, event.sessionKey, context.sessionKey]) {
+            if (!scope)
+                continue;
+            sessions.get(scope)?.controller?.abort();
+            sessions.delete(scope);
+        }
+    });
+    api.on("gateway_stop", () => {
+        for (const state of sessions.values())
+            state.controller?.abort();
+        sessions.clear();
     });
     return beforePrompt;
 }

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

@@ -1,22 +1,21 @@
 import type { QMDStore } from "@unblocklabs/qmd";
 import type { QueryLane } from "./query-contract.js";
-type Candidate = {
-    file: string;
-    body: string;
-    bestChunk: string;
-    bestChunkPos: number;
-    score: number;
-    explain: {
-        methods: string[];
-    };
+/** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
+export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal): Promise<{
     vector?: {
         score: number;
         rank: number;
-    };
+    } | undefined;
     bm25?: {
         score: number;
         rank: number;
+    } | undefined;
+    file: string;
+    body: string;
+    bestChunk: string;
+    bestChunkPos: number;
+    score: number;
+    explain: {
+        methods: ("vector" | "bm25")[];
     };
-};
-export declare function trainingCandidates(qmd: QMDStore, query: string, collection: string | string[], lane: QueryLane, signal?: AbortSignal): Promise<Candidate[]>;
-export {};
+}[]>;

package/dist/src/training-candidates.js

@@ -1,83 +1,13 @@
-import { randomUUID } from "node:crypto";
-const stopWords = new Set("a an and are as at be by can did do does for from how i in is it of on or that the their this to was were what when where which who why will with you".split(" "));
-function queryTerms(query) {
-    const words = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [])];
-    const meaningful = words.filter(word => !stopWords.has(word));
-    return (meaningful.length ? meaningful : words).slice(0, 64);
-}
-function lexicalChunk(chunks, body, highlighted, marker, intent) {
-    const compactLength = (text) => text.replace(/\s/gu, "").length;
-    const ranges = [];
-    let offset = 0;
-    for (const [i, part] of highlighted.split(marker).entries()) {
-        const end = offset + compactLength(part);
-        if (i % 2 === 1)
-            ranges.push({ start: offset, end });
-        offset = end;
-    }
-    const intentTerms = queryTerms(intent);
-    let sourcePos = 0, compactPos = 0;
-    return chunks.map(chunk => {
-        compactPos += compactLength(body.slice(sourcePos, chunk.pos));
-        sourcePos = chunk.pos;
-        const end = compactPos + compactLength(chunk.text);
-        const matches = ranges.reduce((sum, range) => sum + Math.max(0, Math.min(end, range.end) - Math.max(compactPos, range.start)) / Math.max(1, range.end - range.start), 0);
-        const lower = chunk.text.toLowerCase();
-        return { chunk, matches, intentMatches: intentTerms.filter(term => lower.includes(term)).length };
-    }).sort((a, b) => b.matches - a.matches || b.intentMatches - a.intentMatches || a.chunk.pos - b.chunk.pos)[0]?.chunk;
-}
+/** Runtime and training share the exact ten-candidate recipe, not hybrid ranking. */
 export async function trainingCandidates(qmd, query, collection, lane, signal) {
-    signal?.throwIfAborted();
-    if (!query.trim() || query.length > 12_000)
-        throw new Error("Invalid training query");
-    // QMD exposes its store but not these chunk helpers at the package root.
-    // Resolve relative to its installed SDK, never a global QMD or modified copy.
-    const chunksApi = await import(new URL("./store.js", import.meta.resolve("@unblocklabs/qmd")).href);
-    const candidates = new Map();
-    const add = (hit, method, rank, rawScore) => {
-        if (!hit.bestChunk.trim() || hit.bestChunk.length > 12_000)
-            return;
-        const key = JSON.stringify([hit.file, hit.bestChunk.trim()]), existing = candidates.get(key);
-        if (existing) {
-            if (!existing.explain.methods.includes(method))
-                existing.explain.methods.push(method);
-            existing.score = Math.max(existing.score, 1 / (rank + 1));
-            existing[method] ??= { score: rawScore, rank: rank + 1 };
-        }
-        else
-            candidates.set(key, { ...hit, score: 1 / (rank + 1), explain: { methods: [method] },
-                [method]: { score: rawScore, rank: rank + 1 } });
-    };
-    if (lane === "vec") {
-        const vectors = await qmd.searchVector(query, { limit: 10, collection });
-        signal?.throwIfAborted();
-        for (const [rank, hit] of vectors.entries()) {
-            const pos = hit.chunkPos, len = hit.chunkLen, body = hit.body ?? "";
-            if (pos === undefined || len === undefined || pos < 0 || len <= 0 || pos + len > body.length)
-                continue;
-            add({ file: hit.filepath, body, bestChunk: body.slice(pos, pos + len), bestChunkPos: pos }, "vector", rank, hit.score);
-        }
-        return [...candidates.values()];
-    }
-    const expression = queryTerms(query).map(term => `"${chunksApi.normalizeCjkForFTS(term).trim()}"`).join(" OR ");
-    if (expression) {
-        const marker = `qmd-match-${randomUUID()}`;
-        const rows = qmd.internal.db.prepare(`SELECT d.collection,d.path,d.hash,c.doc,
-      bm25(documents_fts,1.5,4.0,1.0) AS rank, highlight(documents_fts,2,?,?) AS highlighted
-      FROM documents_fts JOIN documents d ON d.id=documents_fts.rowid JOIN content c ON c.hash=d.hash
-      WHERE documents_fts MATCH ? AND d.active=1 AND d.collection IN (SELECT value FROM json_each(?))
-      ORDER BY rank,d.collection,d.path LIMIT 10`).all(marker, marker, expression, JSON.stringify(typeof collection === "string" ? [collection] : collection));
-        for (const [rank, row] of rows.entries()) {
-            signal?.throwIfAborted();
-            const file = `qmd://${row.collection}/${row.path}`;
-            const stored = chunksApi.getStoredChunkSpans(qmd.internal.db, row.hash)
-                .filter(span => span.pos >= 0 && span.chunk_len > 0 && span.pos + span.chunk_len <= row.doc.length)
-                .map(span => ({ pos: span.pos, text: row.doc.slice(span.pos, span.pos + span.chunk_len) }));
-            const chunks = stored.length ? stored : await chunksApi.chunkDocumentAsync(row.doc, undefined, undefined, undefined, file);
-            const selected = lexicalChunk(chunks, row.doc, row.highlighted, marker, query);
-            if (selected)
-                add({ file, body: row.doc, bestChunk: selected.text, bestChunkPos: selected.pos }, "bm25", rank, row.rank);
-        }
-    }
-    return [...candidates.values()].sort((a, b) => b.score - a.score);
+    const hits = await qmd.discoverCandidates({ query, lane, collection, limit: 10, signal,
+        // Preserve keyword chunk tie-breaking against this lane's own query.
+        intent: query });
+    return hits.map(({ method, rank, score, file, body, bestChunk, bestChunkPos }) => {
+        const retrieval = {
+            [method]: { score, rank: rank + 1 },
+        };
+        return { file, body, bestChunk, bestChunkPos, score: 1 / (rank + 1),
+            explain: { methods: [method] }, ...retrieval };
+    });
 }

package/dist/src/training-gate.js

@@ -1,6 +1,6 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
-import { requestTypeSafe, TYPESAFE_MODEL, TypeSafeRequestError } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_MODEL, TYPESAFE_NOUL_SCHEMA, TypeSafeRequestError } from "./typesafe-client.js";
 export const TRAINING_GATE_VERSION = "historical-recall-v2";
 export const TRAINING_GATE_MODEL = TYPESAFE_MODEL;
 export const TRAINING_GATE_THRESHOLD = 0.7;
@@ -27,7 +27,7 @@ export const TRAINING_GATE_QUESTIONS = { recall_needed: {
     } };
 const resultSchema = Type.Object({
     model: Type.Literal(TRAINING_GATE_MODEL),
-    answers: Type.Object({ recall_needed: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }) }),
+    answers: Type.Object({ recall_needed: TYPESAFE_NOUL_SCHEMA }),
     usage: Type.Object({ input_tokens: Type.Integer({ minimum: 0 }), output_tokens: Type.Integer({ minimum: 0 }) }),
 });
 export async function judgeTrainingInput(input, apiKey, signal) {

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: {