@unblocklabs/unblock-memory 0.3.29 → 0.4.0

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

@@ -1,5 +1,6 @@
 import type { UnblockMemoryConfig } from "./config.js";
-import type { TrainingInput } from "./training-input.js";
+import type { QueryPair } from "./query-contract.js";
+import { type TrainingInput } from "./training-input.js";
 import { historicalTrainingSearch } from "./training-retrieval.js";
 import type { QueryEvaluation, TrainingStore } from "./training-store.js";
 type Source = {
@@ -26,6 +27,7 @@ export declare function generateTrainingQueries(source: Source, store: TrainingS
     failed: number;
     ambiguous: number;
     blocked: number;
+    flagged: number;
     inputBytes: number;
     budgetLimited: boolean;
     refreshed: {
@@ -41,13 +43,20 @@ export declare function generateTrainingQueries(source: Source, store: TrainingS
         changed: number;
         unchanged: number;
         retired: number;
+        review: {
+            sessionId: string;
+            seq: number;
+            reason: string;
+        }[];
     };
 }>;
-export declare function selectTrainingQueries(queries: QueryEvaluation[]): string[];
-export declare function evaluateTrainingQueries(source: Source, store: TrainingStore, config: UnblockMemoryConfig, options: Options & {
+/** Raw top-three average, including values below runtime's injection threshold. */
+export declare function trainingQueryScore(probabilities: readonly number[]): number;
+export declare function selectTrainingQueries(queries: readonly QueryEvaluation[]): QueryPair;
+export declare function evaluateTrainingQueries(source: Source, store: TrainingStore, config: UnblockMemoryConfig, runtime: unknown, options: Options & {
     maxCalls?: number;
+    maxInputBytes?: number;
     concurrency?: number;
-    excludeJudgments?: string[];
 }, createSearch?: typeof historicalTrainingSearch): Promise<{
     concurrency: number;
     threshold: number;
@@ -63,6 +72,7 @@ export declare function evaluateTrainingQueries(source: Source, store: TrainingS
     failed: number;
     ambiguous: number;
     blocked: number;
+    flagged: number;
     inputBytes: number;
     budgetLimited: boolean;
     refreshed: {
@@ -78,6 +88,11 @@ export declare function evaluateTrainingQueries(source: Source, store: TrainingS
         changed: number;
         unchanged: number;
         retired: number;
+        review: {
+            sessionId: string;
+            seq: number;
+            reason: string;
+        }[];
     };
 }>;
 export declare function exportQueryTraining(store: TrainingStore, threshold?: number): Generator<{
@@ -86,7 +101,7 @@ export declare function exportQueryTraining(store: TrainingStore, threshold?: nu
     inputHash: string;
     recallProbability: number;
     threshold: number;
-    target: string[];
+    target: QueryPair;
     source: {
         nodeId: string;
         agentId: string;
@@ -97,7 +112,7 @@ export declare function exportQueryTraining(store: TrainingStore, threshold?: nu
         inputHash: string;
         timestamp: number;
         corpusHash: string;
-        teacherId: string;
+        teacherIds: string[];
         corpusReport: {
             sessions: number;
             chunks: number;
@@ -106,7 +121,8 @@ export declare function exportQueryTraining(store: TrainingStore, threshold?: nu
             excludedChunks: number;
         };
         queries: QueryEvaluation[];
-        selected: string[];
+        selected: QueryPair | null;
+        review: string[];
     };
     splitGroup: string;
     provenance: {

package/dist/src/training-queries.js

@@ -2,10 +2,11 @@ import { collectTraining } from "./training.js";
 import { trainingHash } from "./training-input.js";
 import { TRAINING_GATE_THRESHOLD } from "./training-gate.js";
 import { resolveTypeSafeApiKey, TypeSafeRequestError } from "./typesafe-client.js";
-import { trainingTeacher, trainingTeacherMessage, TRAINING_TEACHER_MODEL, TRAINING_TEACHER_PROMPT, TRAINING_TEACHER_VERSION } from "./training-models.js";
-import { historicalTrainingSearch, TRAINING_RETRIEVAL_VERSION, TRAINING_SEARCH_OPTIONS } from "./training-retrieval.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 { contextJudgeRequest, judgeTrainingPassage, CONTEXT_JUDGE_VERSION } from "./training-judge.js";
-const SELECTION_VERSION = "conversation-utility-top5-sum-v2";
+const LANES = ["lex", "vec"];
+const SELECTION_VERSION = "independent-lanes-top3-mean-v2";
 export const TRAINING_EVALUATION_CONCURRENCY = 4;
 function bounds(options) {
     for (const value of [options.maxExamples, options.maxCalls, options.maxInputBytes, options.concurrency]) {
@@ -13,13 +14,14 @@ function bounds(options) {
             throw new Error("Training bounds must be positive integers");
     }
 }
-function teacherRequest(example) {
+function teacherRequest(example, lane, feedback) {
     return { version: TRAINING_TEACHER_VERSION, model: TRAINING_TEACHER_MODEL, inputHash: example.inputHash,
-        input: JSON.parse(example.inputJson) };
+        input: JSON.parse(example.inputJson), lane, round: feedback ? 2 : 1,
+        ...(feedback ? { feedback: feedback.map(({ query, score }) => ({ query, score })) } : {}) };
 }
 const summary = () => ({ examples: 0, calls: 0, completed: 0, cached: 0, failed: 0, ambiguous: 0,
-    blocked: 0, inputBytes: 0, budgetLimited: false });
-/** One fenced checkpoint per paid operation, with no hidden transport retries. */
+    blocked: 0, flagged: 0, inputBytes: 0, budgetLimited: false });
+/** One fenced checkpoint per operation. Storage failures are fatal; provider failures are local. */
 async function checkpoint(store, step, result, operation) {
     if (step.result !== undefined) {
         result.cached++;
@@ -37,14 +39,19 @@ async function checkpoint(store, step, result, operation) {
         value = await operation();
     }
     catch (error) {
+        // Historical retrieval is local code. Only an explicitly unavailable corpus
+        // is a reviewable data case; do not swallow SQLite, I/O or snapshot-integrity errors.
+        if (step.stage === "retrieve" && !(error instanceof HistoricalCorpusUnavailableError))
+            throw error;
         const hostCode = error && typeof error === "object" && "code" in error && typeof error.code === "string" &&
             /^LLM_[A-Z_]+$/u.test(error.code) ? error.code : undefined;
-        const status = hostCode === "LLM_COMPLETION_NOT_AUTHORIZED" ||
+        const status = error instanceof HistoricalCorpusUnavailableError || hostCode === "LLM_COMPLETION_NOT_AUTHORIZED" ||
             (error instanceof TypeSafeRequestError && error.code === "http_error" &&
                 error.status !== undefined && error.status >= 400 && error.status < 500) ? "failed" : "ambiguous";
         store.finishStep(step.stage, step.id, attempt, { status,
             error: error instanceof TypeSafeRequestError && error.code === "http_error" ?
-                `http_${error.status}` : hostCode ?? "request_or_response_uncertain" });
+                `http_${error.status}` : error instanceof HistoricalCorpusUnavailableError ? "historical_corpus_unavailable" :
+                hostCode ?? "request_or_response_uncertain" });
         result[status]++;
         return;
     }
@@ -52,6 +59,18 @@ async function checkpoint(store, step, result, operation) {
     result.completed++;
     return value;
 }
+function save(store, step, value) {
+    const attempt = store.startStep(step.stage, step.id, step.request);
+    store.finishStep(step.stage, step.id, attempt, { result: value });
+    return value;
+}
+async function drain(tasks) {
+    const settled = await Promise.allSettled(tasks);
+    const failure = settled.find(item => item.status === "rejected");
+    if (failure)
+        throw failure.reason;
+    return settled.flatMap(item => item.status === "fulfilled" ? [item.value] : []);
+}
 export async function generateTrainingQueries(source, store, runtime, options) {
     bounds(options);
     const refreshed = collectTraining(source, store, { existingOnly: true }), result = summary();
@@ -59,8 +78,8 @@ export async function generateTrainingQueries(source, store, runtime, options) {
     let teacher;
     const examples = store.queryExamples(options.threshold);
     let next = 0, stopped = false;
-    const workers = await Promise.allSettled(Array.from({ length: Math.min(options.concurrency ?? 8, examples.length) }, async () => {
-        while (!stopped && !result.budgetLimited && !result.failed && !result.ambiguous) {
+    await drain(Array.from({ length: Math.min(options.concurrency ?? 8, examples.length) }, async () => {
+        while (!stopped && !result.budgetLimited) {
             const example = examples[next++];
             if (!example)
                 return;
@@ -68,29 +87,49 @@ export async function generateTrainingQueries(source, store, runtime, options) {
                 if (seen.has(example.inputHash))
                     continue;
                 seen.add(example.inputHash);
-                const request = teacherRequest(example), step = store.step("generate", request);
-                if (step.result) {
-                    result.cached++;
+                const steps = LANES.map(lane => ({ lane, step: store.step("generate", teacherRequest(example, lane)) }));
+                if (steps.every(({ step }) => step.result)) {
+                    result.cached += steps.length;
                     continue;
                 }
-                if (step.status !== "pending") {
-                    result.blocked++;
+                if (steps.every(({ step }) => step.result || step.status !== "pending")) {
+                    const problems = steps.filter(({ step }) => !step.result).map(({ step }) => step.id);
+                    result.blocked += problems.length;
+                    result.flagged++;
+                    store.flagReview(example, "generation-unresolved", { steps: problems });
                     continue;
                 }
                 if (options.maxExamples !== undefined && result.examples >= options.maxExamples)
                     return;
-                const bytes = Buffer.byteLength(trainingTeacherMessage(request.input)) + Buffer.byteLength(TRAINING_TEACHER_PROMPT);
-                if (result.inputBytes + bytes > options.maxInputBytes) {
-                    result.budgetLimited = true;
-                    return;
-                }
                 result.examples++;
-                result.inputBytes += bytes;
-                if (options.dryRun)
-                    continue;
-                teacher ??= trainingTeacher(runtime, source.agentId); // Capability check BEFORE committing a paid attempt.
-                if (!await checkpoint(store, step, result, () => teacher(request.input)))
-                    return;
+                const problems = [];
+                for (const { lane, step } of steps) {
+                    if (step.result) {
+                        result.cached++;
+                        continue;
+                    }
+                    if (step.status !== "pending") {
+                        result.blocked++;
+                        problems.push(step.id);
+                        continue;
+                    }
+                    const input = JSON.parse(example.inputJson);
+                    const bytes = Buffer.byteLength(trainingTeacherMessage(input, lane)) + Buffer.byteLength(trainingTeacherPrompt(lane));
+                    if (result.inputBytes + bytes > options.maxInputBytes) {
+                        result.budgetLimited = true;
+                        break;
+                    }
+                    result.inputBytes += bytes;
+                    if (options.dryRun)
+                        continue;
+                    teacher ??= trainingTeacher(runtime, source.agentId);
+                    if (!await checkpoint(store, step, result, () => teacher(input, lane)))
+                        problems.push(step.id);
+                }
+                if (problems.length) {
+                    store.flagReview(example, "generation-unresolved", { steps: problems });
+                    result.flagged++;
+                }
             }
             catch (error) {
                 stopped = true;
@@ -98,142 +137,250 @@ export async function generateTrainingQueries(source, store, runtime, options) {
             }
         }
     }));
-    const failure = workers.find(item => item.status === "rejected");
-    if (failure)
-        throw failure.reason;
     return { refreshed, ...result, threshold: options.threshold ?? TRAINING_GATE_THRESHOLD, model: TRAINING_TEACHER_MODEL };
 }
+/** Raw top-three average, including values below runtime's injection threshold. */
+export function trainingQueryScore(probabilities) {
+    const top = probabilities.toSorted((a, b) => b - a).slice(0, 3);
+    return top.length ? top.reduce((sum, value) => sum + value, 0) / top.length : 0;
+}
 export function selectTrainingQueries(queries) {
-    // Stable ties preserve teacher order; neither low scores nor overlapping hits reject a query.
-    return queries.toSorted((a, b) => b.score - a.score).slice(0, 3).map(q => q.query);
+    const winner = (lane) => {
+        const ranked = queries.filter(query => query.lane === lane).toSorted((a, b) => b.score - a.score);
+        if (!ranked[0])
+            throw new Error(`No resolved ${lane} candidates`);
+        return ranked[0].query; // Stable ties preserve round and teacher order.
+    };
+    return { lex: winner("lex"), vec: winner("vec") };
 }
-export async function evaluateTrainingQueries(source, store, config, options, createSearch = historicalTrainingSearch) {
+export async function evaluateTrainingQueries(source, store, config, runtime, options, createSearch = historicalTrainingSearch) {
     bounds(options);
-    if (options.excludeJudgments?.some(id => !/^[a-f0-9]{64}$/u.test(id)))
-        throw new Error("Invalid excluded judgment hash");
     const corpus = config.corpora.find(c => c.kind === "sessions");
     if (!corpus)
         throw new Error("Training retrieval requires a configured sessions corpus");
     const refreshed = collectTraining(source, store, { existingOnly: true });
     const result = { ...summary(), retrievals: 0, evaluated: 0, awaitingTeacher: 0 };
     const concurrency = options.concurrency ?? TRAINING_EVALUATION_CONCURRENCY;
-    let key;
+    let key, teacher;
     const apiKey = () => key ??= resolveTypeSafeApiKey(config.typesafe).then(value => {
         if (!value)
             throw new Error("TypeSafe is disabled or its credential is unavailable");
         return value;
     });
     let stopped = false;
-    const shouldStop = () => stopped || result.budgetLimited || result.failed > 0 || result.ambiguous > 0 || result.blocked > 0;
+    const shouldStop = () => stopped || result.budgetLimited;
+    const room = () => {
+        if (shouldStop())
+            return false;
+        if (options.maxCalls !== undefined && result.calls >= options.maxCalls) {
+            result.budgetLimited = true;
+            return false;
+        }
+        return true;
+    };
     const judgments = new Map();
+    const revisions = new Map();
+    const reviews = new Map(store.reviews().map(review => [review.sourceId, review]));
     const evaluate = async (example) => {
-        const teacher = store.step("generate", teacherRequest(example));
-        if (!teacher.result) {
-            result.awaitingTeacher++;
+        const previousReview = reviews.get(example.id);
+        if (previousReview && "steps" in previousReview.details) {
+            const blocked = previousReview.details.steps.filter(id => {
+                const status = store.stepRecordStatus(id);
+                return status !== undefined && status !== "pending" && status !== "complete";
+            });
+            // A known failed example cannot resolve before manual retry. Do not scan its
+            // historical corpus or consume the example budget on every invocation.
+            if (blocked.length) {
+                result.blocked += blocked.length;
+                result.flagged++;
+                return;
+            }
+        }
+        const initial = LANES.map(lane => ({ lane, step: store.step("generate", teacherRequest(example, lane)) }));
+        if (initial.some(({ step }) => !step.result)) {
+            const blocked = initial.filter(({ step }) => !step.result && step.status !== "pending");
+            if (blocked.length) {
+                result.blocked += blocked.length;
+                result.flagged++;
+                store.flagReview(example, "generation-unresolved", { steps: blocked.map(({ step }) => step.id) });
+            }
+            else
+                result.awaitingTeacher++;
             return;
         }
         if (options.maxExamples !== undefined && result.examples >= options.maxExamples)
             return;
         store.renew();
-        const snapshot = await createSearch(source.stateDir, corpus.chatTypes, example.timestamp);
+        let snapshot;
+        try {
+            snapshot = await createSearch(source.stateDir, corpus.chatTypes, example.timestamp);
+        }
+        catch (error) {
+            if (!(error instanceof HistoricalCorpusUnavailableError))
+                throw error;
+            store.flagReview(example, "historical-snapshot-unavailable", { timestamp: example.timestamp });
+            result.flagged++;
+            return;
+        }
         try {
             const evaluation = store.step("evaluate", { version: SELECTION_VERSION, sourceId: example.id, inputHash: example.inputHash,
-                timestamp: example.timestamp, teacherId: teacher.id, corpusHash: snapshot.corpusHash,
+                timestamp: example.timestamp, teacherIds: initial.map(({ step }) => step.id), corpusHash: snapshot.corpusHash,
                 retrievalVersion: TRAINING_RETRIEVAL_VERSION, judgeVersion: CONTEXT_JUDGE_VERSION,
-                exclusions: options.excludeJudgments?.toSorted() ?? [], options: TRAINING_SEARCH_OPTIONS });
+                minUsefulness: config.memoryWhisperer.minUsefulness, options: TRAINING_SEARCH_OPTIONS });
             if (evaluation.result) {
                 result.cached++;
+                if (evaluation.result.review.length) {
+                    result.flagged++;
+                    store.flagReview(example, "no-useful-evidence", { lanes: evaluation.result.review, evaluationId: evaluation.id });
+                }
+                else
+                    store.clearReview(example.id);
                 return;
             }
             if (evaluation.status !== "pending") {
                 result.blocked++;
+                result.flagged++;
+                store.flagReview(example, "evaluation-unresolved", { steps: [evaluation.id] });
                 return;
             }
-            // Snapshot creation is async: reserve the shared example budget only after it settles.
             if (shouldStop() || (options.maxExamples !== undefined && result.examples >= options.maxExamples))
                 return;
             result.examples++;
             if (options.dryRun)
                 return;
             const input = JSON.parse(example.inputJson);
+            const problems = new Set();
             const judge = (hit) => {
                 const request = contextJudgeRequest(input, snapshot.maxDate, hit);
-                // Same identity as the experiment: duplicate query memberships share one judgment.
-                const identity = trainingHash([CONTEXT_JUDGE_VERSION, example.inputHash, hit.position, request]);
+                const identity = trainingHash([CONTEXT_JUDGE_VERSION, request]);
                 let pending = judgments.get(identity);
                 if (!pending) {
                     pending = (async () => {
-                        const excluded = options.excludeJudgments?.includes(identity) || store.judgmentExcluded(identity);
-                        const step = store.step("judge", { identity, request, excluded });
+                        const step = store.step("judge", { identity, request });
                         if (step.result) {
                             result.cached++;
                             return { id: step.id, result: step.result };
                         }
-                        if (excluded) {
-                            const attempt = store.startStep("judge", step.id, step.request);
-                            const value = { excluded: true, reason: "operator-exclusion" };
-                            store.finishStep("judge", step.id, attempt, { result: value });
-                            return { id: step.id, result: value };
+                        if (step.status !== "pending") {
+                            result.blocked++;
+                            return { id: step.id, result: undefined };
                         }
                         const credential = await apiKey();
-                        if (shouldStop())
+                        if (!room())
                             return { id: step.id, result: undefined };
-                        if (options.maxCalls !== undefined && result.calls >= options.maxCalls) {
-                            result.budgetLimited = true;
-                            return { id: step.id, result: undefined };
-                        }
                         return { id: step.id, result: await checkpoint(store, step, result, () => judgeTrainingPassage(request, credential)) };
                     })();
                     judgments.set(identity, pending);
                 }
                 return pending;
             };
-            // Keep teacher order, and drain every in-flight operation before closing its snapshot.
-            const settled = await Promise.allSettled(teacher.result.queries.map(async (query) => {
+            const scoreQueries = async (lane, round, generation, generationId) => await drain(generation.queries.map(async (query) => {
                 try {
-                    if (shouldStop())
+                    const score = store.step("score", { version: SELECTION_VERSION, lane, round, generationId, query,
+                        sourceId: example.id, corpusHash: snapshot.corpusHash, judgeVersion: CONTEXT_JUDGE_VERSION,
+                        retrievalVersion: TRAINING_RETRIEVAL_VERSION });
+                    if (score.result) {
+                        result.cached++;
+                        return score.result;
+                    }
+                    if (score.status !== "pending") {
+                        problems.add(score.id);
+                        result.blocked++;
                         return;
-                    const retrieval = store.step("retrieve", { version: TRAINING_RETRIEVAL_VERSION, query,
+                    }
+                    const retrieval = store.step("retrieve", { version: TRAINING_RETRIEVAL_VERSION, query, lane,
                         sourceId: example.id, maxDate: snapshot.maxDate, corpusHash: snapshot.corpusHash, options: TRAINING_SEARCH_OPTIONS });
-                    if (shouldStop())
+                    if (!retrieval.result && retrieval.status === "pending" && !room())
                         return;
-                    // No await between this check and checkpoint's synchronous reservation of result.calls.
-                    if (!retrieval.result && options.maxCalls !== undefined && result.calls >= options.maxCalls) {
-                        result.budgetLimited = true;
+                    const retrieved = await checkpoint(store, retrieval, result, async () => ({ query, lane, maxDate: snapshot.maxDate,
+                        corpusHash: snapshot.corpusHash, hits: await snapshot.search(query, lane) }));
+                    if (!retrieved) {
+                        problems.add(retrieval.id);
                         return;
                     }
-                    const retrieved = await checkpoint(store, retrieval, result, async () => ({ query, maxDate: snapshot.maxDate,
-                        corpusHash: snapshot.corpusHash, hits: await snapshot.search(query) }));
-                    if (!retrieved)
-                        return;
                     if (!retrieval.result)
                         result.retrievals++;
-                    const settledHits = await Promise.allSettled(retrieved.hits.map(judge));
-                    const failure = settledHits.find(item => item.status === "rejected");
-                    if (failure)
-                        throw failure.reason;
-                    const scored = settledHits.flatMap(item => item.status === "fulfilled" ? [item.value] : []);
-                    if (scored.some(item => !item.result))
+                    const scored = await drain(retrieved.hits.map(judge));
+                    const missing = scored.filter(item => !item.result);
+                    if (missing.length) {
+                        for (const item of missing) {
+                            const record = store.stepRecordStatus(item.id);
+                            if (record && record !== "pending")
+                                problems.add(item.id);
+                        }
                         return;
-                    const scores = scored.flatMap(item => item.result && "score" in item.result ? [item.result.score] : []);
-                    return { query, retrievalId: retrieval.id, score: scores.sort((a, b) => b - a).slice(0, 5).reduce((a, b) => a + b, 0),
-                        judgments: scored.map(item => ({ id: item.id, excluded: !!item.result && "excluded" in item.result })) };
+                    }
+                    const probabilities = scored.map(item => item.result.probability);
+                    return save(store, score, { query, lane, round, retrievalId: retrieval.id,
+                        score: trainingQueryScore(probabilities), maxProbability: Math.max(0, ...probabilities), judgments: scored.map(item => item.id) });
                 }
                 catch (error) {
                     stopped = true;
                     throw error;
                 }
             }));
-            const failure = settled.find(item => item.status === "rejected");
-            if (failure)
-                throw failure.reason;
-            const queries = settled.flatMap(item => item.status === "fulfilled" && item.value ? [item.value] : []);
-            if (queries.length !== 10)
-                return; // Resume only unfinished queries; never repeat completed calls.
-            const selected = selectTrainingQueries(queries);
-            const attempt = store.startStep("evaluate", evaluation.id, evaluation.request);
-            store.finishStep("evaluate", evaluation.id, attempt, { result: { sourceId: example.id, inputHash: example.inputHash,
-                    timestamp: example.timestamp, corpusHash: snapshot.corpusHash, corpusReport: snapshot.report, teacherId: teacher.id, queries, selected } });
+            const lanes = await drain(initial.map(async ({ lane, step }) => {
+                try {
+                    const first = await scoreQueries(lane, 1, step.result, step.id);
+                    if (first.some(item => !item) || shouldStop())
+                        return;
+                    const feedback = first.map(item => ({ query: item.query, score: item.score }));
+                    // The only feedback sent to Luna is this lane's exact earlier queries and scores.
+                    const revision = store.step("generate", teacherRequest(example, lane, feedback));
+                    let pending = revisions.get(revision.id);
+                    if (!pending) {
+                        pending = (async () => {
+                            if (!revision.result && revision.status === "pending") {
+                                const bytes = Buffer.byteLength(trainingTeacherMessage(input, lane, feedback)) + Buffer.byteLength(trainingTeacherPrompt(lane));
+                                if (!room())
+                                    return;
+                                if (result.inputBytes + bytes > (options.maxInputBytes ?? 3_000_000)) {
+                                    result.budgetLimited = true;
+                                    return;
+                                }
+                                result.inputBytes += bytes;
+                                teacher ??= trainingTeacher(runtime, source.agentId);
+                            }
+                            return checkpoint(store, revision, result, () => teacher(input, lane, feedback));
+                        })();
+                        revisions.set(revision.id, pending);
+                    }
+                    const revised = await pending;
+                    if (!revised) {
+                        if (store.stepRecordStatus(revision.id))
+                            problems.add(revision.id);
+                        return;
+                    }
+                    const second = await scoreQueries(lane, 2, revised, revision.id);
+                    if (second.some(item => !item))
+                        return;
+                    return { teacherIds: [step.id, revision.id], queries: [...first, ...second].filter((item) => !!item) };
+                }
+                catch (error) {
+                    stopped = true;
+                    throw error;
+                }
+            }));
+            if (problems.size) {
+                result.flagged++;
+                store.flagReview(example, "evaluation-unresolved", { steps: [...problems] });
+                return;
+            }
+            if (lanes.some(lane => !lane))
+                return; // Budget pause: completed operations remain reusable.
+            const queries = lanes.flatMap(lane => lane.queries);
+            const review = LANES.filter(lane => !queries.some(query => query.lane === lane && query.judgments.length > 0 &&
+                query.maxProbability >= config.memoryWhisperer.minUsefulness))
+                .map(lane => `${lane}-no-useful-evidence`);
+            const selected = review.length ? null : selectTrainingQueries(queries);
+            save(store, evaluation, { sourceId: example.id, inputHash: example.inputHash, timestamp: example.timestamp,
+                corpusHash: snapshot.corpusHash, corpusReport: snapshot.report, teacherIds: lanes.flatMap(lane => lane.teacherIds), queries, selected, review });
+            if (review.length) {
+                store.flagReview(example, "no-useful-evidence", { lanes: review, evaluationId: evaluation.id });
+                result.flagged++;
+            }
+            else
+                store.clearReview(example.id);
             result.evaluated++;
         }
         finally {
@@ -242,7 +389,7 @@ export async function evaluateTrainingQueries(source, store, config, options, cr
     };
     const examples = store.queryExamples(options.threshold);
     let next = 0;
-    const workers = await Promise.allSettled(Array.from({ length: Math.min(concurrency, examples.length) }, async () => {
+    await drain(Array.from({ length: Math.min(concurrency, examples.length) }, async () => {
         while (!shouldStop() && (options.maxExamples === undefined || result.examples < options.maxExamples)) {
             const example = examples[next++];
             if (!example)
@@ -256,27 +403,25 @@ export async function evaluateTrainingQueries(source, store, config, options, cr
             }
         }
     }));
-    const failure = workers.find(item => item.status === "rejected");
-    if (failure)
-        throw failure.reason; // All workers/snapshots have drained, including on storage failures.
     return { refreshed, ...result, concurrency, threshold: options.threshold ?? TRAINING_GATE_THRESHOLD,
-        retrievalMethod: "vector10-bm25-10", callUnit: "retrieval operation or uncached passage judgment" };
+        retrievalMethod: "independent-lex10-vec10", callUnit: "teacher completion, retrieval operation or uncached passage judgment" };
 }
 export function* exportQueryTraining(store, threshold = TRAINING_GATE_THRESHOLD) {
     const active = new Map(store.queryExamples(threshold).map(e => [e.id, e]));
-    const exported = new Set();
-    for (const evaluation of store.completedEvaluations({ selection: SELECTION_VERSION, retrieval: TRAINING_RETRIEVAL_VERSION })) {
+    const unresolved = new Set(store.reviews().map(review => review.sourceId)), exported = new Set();
+    for (const evaluation of store.completedEvaluations({ selection: SELECTION_VERSION, retrieval: TRAINING_RETRIEVAL_VERSION, judge: CONTEXT_JUDGE_VERSION })) {
         const source = active.get(evaluation.sourceId);
         if (!source || source.inputHash !== evaluation.inputHash || source.timestamp !== evaluation.timestamp || exported.has(source.id))
             continue;
-        if (store.step("generate", teacherRequest(source)).id !== evaluation.teacherId)
+        exported.add(source.id); // Never fall back to an older accepted corpus after a newer flagged result.
+        if (!evaluation.selected || unresolved.has(source.id))
+            continue;
+        if (!LANES.every(lane => evaluation.teacherIds.includes(store.step("generate", teacherRequest(source, lane)).id)))
             continue;
-        exported.add(source.id); // Only the newest corpus evaluation per source.
-        const provenance = [evaluation.teacherId, ...evaluation.queries.flatMap(q => [q.retrievalId, ...q.judgments?.map(j => j.id) ?? []])];
+        const provenance = [...evaluation.teacherIds, ...evaluation.queries.flatMap(q => [q.retrievalId, ...q.judgments])];
         yield { stage: "query-training", input: JSON.parse(source.inputJson), inputHash: source.inputHash,
-            recallProbability: source.recallProbability, threshold,
-            target: evaluation.selected, source: store.sourceDetails(source.id), evaluation,
-            splitGroup: trainingHash(source.sessionId), // Also keep identical inputHash groups together across sessions/nodes.
+            recallProbability: source.recallProbability, threshold, target: evaluation.selected,
+            source: store.sourceDetails(source.id), evaluation, splitGroup: trainingHash(source.sessionId),
             provenance: [...new Set(provenance)].map(id => store.stepRecord(id)) };
     }
 }

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

@@ -1,6 +1,7 @@
 import type { ChatType } from "./config.js";
 import type { SessionMessageSpan } from "./session-projector.js";
-export declare const TRAINING_RETRIEVAL_VERSION = "qmd-2.10.1-historical-prefix-depth10-v2";
+import type { QueryLane } from "./query-contract.js";
+export declare const TRAINING_RETRIEVAL_VERSION = "qmd-2.10.2-historical-lanes-depth10-v3:complete-excerpt-1200-v1";
 export declare const TRAINING_SEARCH_OPTIONS: {
     readonly vector: 10;
     readonly bm25: 10;
@@ -9,12 +10,18 @@ export declare const TRAINING_SEARCH_OPTIONS: {
 };
 export type TrainingHit = {
     path: string;
+    corpus: string;
     text: string;
     dates: string[];
     position: number;
+    startLine: number;
+    endLine: number;
     score: number;
     methods: string[];
 };
+/** Missing historical evidence is reviewable; unexpected SQLite/I/O failures remain fatal. */
+export declare class HistoricalCorpusUnavailableError extends Error {
+}
 /** Never infer dates by parsing message bodies: headings can be quoted or forged. */
 export declare function historicalPrefix(body: string, spans: readonly SessionMessageSpan[] | undefined, cutoff: number): {
     body: string;
@@ -32,6 +39,6 @@ export declare function historicalTrainingSearch(stateDir: string, chatTypes: re
         excludedChunks: number;
     };
     maxDate: string;
-    search: (query: string) => Promise<TrainingHit[]>;
+    search: (query: string, lane: QueryLane) => Promise<TrainingHit[]>;
     close: () => Promise<void>;
 }>;