claude-flow 3.10.4 → 3.10.5

package/v3/@claude-flow/cli/dist/src/benchmarks/gaia-hardness/predictor.js

@@ -0,0 +1,260 @@
+/**
+ * GAIA Hardness Predictor — Linear Classifier (ADR-136 Track Q)
+ *
+ * Classifies GAIA questions into easy / medium / hard using a
+ * hand-rolled logistic regression (no external ML dependencies).
+ *
+ * Training:
+ *   `predictor.train(labeledData)` — fits weights via gradient descent
+ *   on cross-entropy loss using the 17-dim feature vectors.
+ *
+ * Inference:
+ *   `predictor.predict(question)` — returns difficulty class + confidence
+ *   + a ComputeBudget that drives model/turns/voting choices in gaia-bench.
+ *
+ * Cold-start:
+ *   When untrained (weights = null), classifies everything as "medium".
+ *   This is the correct safe default: no wasted Haiku-on-hard, no missed
+ *   Sonnet-on-easy.
+ *
+ * Compute budget policy (from ADR-136 Track Q research):
+ *   easy   → Haiku,  max 4 turns,  1 attempt
+ *   medium → Sonnet, max 8 turns,  1 attempt
+ *   hard   → Sonnet, max 12 turns, 3-vote (Track A)
+ *
+ * Conservative threshold:
+ *   If in doubt, classify UP (medium→hard preferred over medium→easy).
+ *   `conservativeMode: true` (default) shifts the easy/medium boundary
+ *   so fewer questions fall into "easy".
+ *
+ * Refs: ADR-136, ADR-135, #2156
+ */
+import { extractFeatures } from './features.js';
+// ---------------------------------------------------------------------------
+// Compute budget policy
+// ---------------------------------------------------------------------------
+export const COMPUTE_BUDGETS = {
+    easy: {
+        model: 'haiku',
+        maxTurns: 4,
+        votingAttempts: 1,
+    },
+    medium: {
+        model: 'sonnet',
+        maxTurns: 8,
+        votingAttempts: 1,
+    },
+    hard: {
+        model: 'sonnet',
+        maxTurns: 12,
+        votingAttempts: 3,
+    },
+};
+// ---------------------------------------------------------------------------
+// Internal constants
+// ---------------------------------------------------------------------------
+const FEATURE_DIM = 17;
+const NUM_CLASSES = 3; // easy=0, medium=1, hard=2
+const CLASS_NAMES = ['easy', 'medium', 'hard'];
+// Learning-rate and regularisation tuned for ~300-example datasets
+const LEARNING_RATE = 0.05;
+const REGULARISATION_LAMBDA = 0.01;
+const TRAINING_EPOCHS = 200;
+// Conservative mode: shift the probability threshold so fewer questions
+// are classified as "easy" (reduces risk of underpowering hard questions).
+// With conservativeMode: the easy threshold is 0.6 (not 0.5).
+const EASY_THRESHOLD_CONSERVATIVE = 0.55;
+// ---------------------------------------------------------------------------
+// Math helpers (pure functions, no deps)
+// ---------------------------------------------------------------------------
+function softmax(logits) {
+    const maxLogit = Math.max(...logits);
+    const exps = logits.map((l) => Math.exp(l - maxLogit));
+    const sumExps = exps.reduce((a, b) => a + b, 0);
+    return exps.map((e) => e / sumExps);
+}
+function dot(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++)
+        sum += a[i] * b[i];
+    return sum;
+}
+// ---------------------------------------------------------------------------
+// HardnessPredictor
+// ---------------------------------------------------------------------------
+export class HardnessPredictor {
+    /**
+     * Weight matrix: weights[classIdx][featureIdx].
+     * null = untrained (cold-start: return medium for everything).
+     */
+    weights = null;
+    /** Bias terms per class. */
+    biases = null;
+    /** Whether conservative mode is active (default: true). */
+    conservativeMode;
+    constructor(options = {}) {
+        this.conservativeMode = options.conservativeMode ?? true;
+    }
+    /**
+     * Returns true when the predictor has been trained and is ready
+     * to make non-trivial predictions.
+     */
+    get isTrained() {
+        return this.weights !== null;
+    }
+    // ── Training ─────────────────────────────────────────────────────────────
+    /**
+     * Train the linear classifier using labelled examples from prior runs.
+     *
+     * Labelling strategy (weak supervision):
+     *   - All correct + turns ≤ median turns  → easy
+     *   - All correct + turns > median turns  → medium
+     *   - Incorrect                           → hard
+     *
+     * With < 10 examples, refuses to train (cold-start is safer).
+     * With 10-50 examples, trains but sets `conservativeMode`-threshold high.
+     */
+    train(labeledData) {
+        if (labeledData.length < 10) {
+            // Too few examples for meaningful generalisation.
+            this.weights = null;
+            this.biases = null;
+            return;
+        }
+        // Derive labels using weak-supervision strategy.
+        const allTurns = labeledData
+            .filter((d) => d.turns !== undefined)
+            .map((d) => d.turns);
+        const medianTurns = allTurns.length > 0 ? median(allTurns) : 6;
+        const X = [];
+        const y = [];
+        for (const example of labeledData) {
+            const fv = extractFeatures(example.question);
+            X.push(fv.values);
+            let classIdx;
+            if (example.wasCorrect) {
+                const t = example.turns ?? medianTurns;
+                classIdx = t <= medianTurns ? 0 : 1; // easy=0, medium=1
+            }
+            else {
+                classIdx = 2; // hard
+            }
+            y.push(classIdx);
+        }
+        // Initialise weights to 0.
+        const W = Array.from({ length: NUM_CLASSES }, () => new Array(FEATURE_DIM).fill(0));
+        const b = new Array(NUM_CLASSES).fill(0);
+        // Mini-batch gradient descent (batch = full dataset for small sizes).
+        for (let epoch = 0; epoch < TRAINING_EPOCHS; epoch++) {
+            // Accumulate gradients.
+            const dW = Array.from({ length: NUM_CLASSES }, () => new Array(FEATURE_DIM).fill(0));
+            const db = new Array(NUM_CLASSES).fill(0);
+            for (let n = 0; n < X.length; n++) {
+                const x = X[n];
+                const trueClass = y[n];
+                // Compute logits and softmax probabilities.
+                const logits = W.map((w, k) => dot(w, x) + b[k]);
+                const probs = softmax(logits);
+                // Cross-entropy gradient for each class.
+                for (let k = 0; k < NUM_CLASSES; k++) {
+                    const grad = probs[k] - (k === trueClass ? 1 : 0);
+                    for (let f = 0; f < FEATURE_DIM; f++) {
+                        dW[k][f] += grad * x[f];
+                    }
+                    db[k] += grad;
+                }
+            }
+            // Update weights with L2 regularisation.
+            const N = X.length;
+            for (let k = 0; k < NUM_CLASSES; k++) {
+                for (let f = 0; f < FEATURE_DIM; f++) {
+                    W[k][f] -= LEARNING_RATE * (dW[k][f] / N + REGULARISATION_LAMBDA * W[k][f]);
+                }
+                b[k] -= LEARNING_RATE * (db[k] / N);
+            }
+        }
+        this.weights = W;
+        this.biases = b;
+    }
+    // ── Inference ─────────────────────────────────────────────────────────────
+    /**
+     * Predict the hardness class of a single GAIA question.
+     *
+     * Cold-start (untrained): returns medium with confidence=0.5.
+     */
+    predict(question) {
+        const features = extractFeatures(question);
+        if (!this.weights || !this.biases) {
+            // Cold-start fallback: medium for everything.
+            return {
+                difficulty: 'medium',
+                confidence: 0.5,
+                budget: COMPUTE_BUDGETS.medium,
+                features,
+            };
+        }
+        const logits = this.weights.map((w, k) => dot(w, features.values) + this.biases[k]);
+        const probs = softmax(logits);
+        // Conservative mode: down-weight easy probability.
+        let adjustedProbs = [...probs];
+        if (this.conservativeMode) {
+            // Transfer a fraction of easy probability to medium.
+            const easyExcess = Math.max(0, probs[0] - EASY_THRESHOLD_CONSERVATIVE);
+            adjustedProbs[0] = probs[0] - easyExcess;
+            adjustedProbs[1] = probs[1] + easyExcess;
+        }
+        // Re-normalise after adjustment.
+        const sumAdj = adjustedProbs.reduce((a, b) => a + b, 0);
+        adjustedProbs = adjustedProbs.map((p) => p / sumAdj);
+        // Pick argmax.
+        let bestClass = 0;
+        for (let k = 1; k < NUM_CLASSES; k++) {
+            if (adjustedProbs[k] > adjustedProbs[bestClass])
+                bestClass = k;
+        }
+        const difficulty = CLASS_NAMES[bestClass];
+        const confidence = adjustedProbs[bestClass];
+        return {
+            difficulty,
+            confidence,
+            budget: COMPUTE_BUDGETS[difficulty],
+            features,
+        };
+    }
+    // ── Serialisation ─────────────────────────────────────────────────────────
+    /**
+     * Export weights as a plain JSON-serialisable object.
+     * Returns null if untrained.
+     */
+    export() {
+        if (!this.weights || !this.biases)
+            return null;
+        return { weights: this.weights, biases: this.biases };
+    }
+    /**
+     * Import previously exported weights.
+     */
+    import(state) {
+        if (!Array.isArray(state.weights) ||
+            state.weights.length !== NUM_CLASSES ||
+            !Array.isArray(state.biases) ||
+            state.biases.length !== NUM_CLASSES) {
+            throw new Error(`Invalid weight state: expected ${NUM_CLASSES}×${FEATURE_DIM} matrix + ${NUM_CLASSES} biases`);
+        }
+        this.weights = state.weights.map((row) => [...row]);
+        this.biases = [...state.biases];
+    }
+}
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+function median(values) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0
+        ? (sorted[mid - 1] + sorted[mid]) / 2
+        : sorted[mid];
+}
+//# sourceMappingURL=predictor.js.map

package/v3/@claude-flow/cli/dist/src/benchmarks/gaia-hardness/predictor.smoke.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Smoke tests for gaia-hardness predictor — ADR-136 Track Q
+ *
+ * All tests are mock-based (no live API calls, no HF token, $0 cost).
+ *
+ * Test matrix:
+ *   1. Feature extraction: math question fires requiresMath + qword_calc
+ *   2. Feature extraction: simple factual question has low complexity signal
+ *   3. Feature extraction: question with file attachment fires has_file_attachment
+ *   4. Feature extraction: multi-hop question fires multi_hop_signal
+ *   5. Cold-start fallback: untrained predictor returns medium with confidence=0.5
+ *   6. Train on mock data: predictor becomes trained after ≥ 10 examples
+ *   7. Trained predictor: math-heavy question predicts harder than trivial question
+ *   8. Export/import: weights round-trip through JSON without loss
+ *
+ * Refs: ADR-136, #2156
+ */
+declare function runSmoke(): Promise<void>;
+export { runSmoke };
+//# sourceMappingURL=predictor.smoke.d.ts.map

package/v3/@claude-flow/cli/dist/src/benchmarks/gaia-hardness/predictor.smoke.js

@@ -0,0 +1,235 @@
+/**
+ * Smoke tests for gaia-hardness predictor — ADR-136 Track Q
+ *
+ * All tests are mock-based (no live API calls, no HF token, $0 cost).
+ *
+ * Test matrix:
+ *   1. Feature extraction: math question fires requiresMath + qword_calc
+ *   2. Feature extraction: simple factual question has low complexity signal
+ *   3. Feature extraction: question with file attachment fires has_file_attachment
+ *   4. Feature extraction: multi-hop question fires multi_hop_signal
+ *   5. Cold-start fallback: untrained predictor returns medium with confidence=0.5
+ *   6. Train on mock data: predictor becomes trained after ≥ 10 examples
+ *   7. Trained predictor: math-heavy question predicts harder than trivial question
+ *   8. Export/import: weights round-trip through JSON without loss
+ *
+ * Refs: ADR-136, #2156
+ */
+import assert from 'node:assert/strict';
+import { extractFeatures, FEATURE_LABELS } from './features.js';
+import { HardnessPredictor } from './predictor.js';
+// ---------------------------------------------------------------------------
+// Fixture helpers
+// ---------------------------------------------------------------------------
+function makeQuestion(text, overrides = {}) {
+    return {
+        task_id: 'smoke-test',
+        level: 1,
+        question: text,
+        final_answer: 'X',
+        file_name: null,
+        file_path: null,
+        ...overrides,
+    };
+}
+function labelIndex(label) {
+    return FEATURE_LABELS.indexOf(label);
+}
+// ---------------------------------------------------------------------------
+// Test 1: Math question fires expected features
+// ---------------------------------------------------------------------------
+function testMathQuestionFeatures() {
+    const q = makeQuestion('What is 15 multiplied by 4? Calculate the exact product.');
+    const fv = extractFeatures(q);
+    const calcIdx = labelIndex('qword_calc_compute');
+    const mathIdx = labelIndex('requires_math');
+    const numIdx = labelIndex('has_numeric');
+    assert.ok(calcIdx >= 0, 'qword_calc_compute feature not found');
+    assert.ok(mathIdx >= 0, 'requires_math feature not found');
+    assert.ok(numIdx >= 0, 'has_numeric feature not found');
+    assert.equal(fv.values[numIdx], 1, 'has_numeric should be 1 for "15 multiplied by 4"');
+    // "Calculate" or "what" triggers calc compute or requires_math
+    const eitherMath = fv.values[calcIdx] === 1 || fv.values[mathIdx] === 1;
+    assert.ok(eitherMath, 'math question should fire qword_calc_compute or requires_math');
+    console.log('  [PASS] Test 1: math question fires expected features');
+}
+// ---------------------------------------------------------------------------
+// Test 2: Simple factual question has low complexity
+// ---------------------------------------------------------------------------
+function testSimpleFactualQuestion() {
+    const q = makeQuestion('What is the capital of France?');
+    const fv = extractFeatures(q);
+    assert.equal(fv.values.length, 17, 'feature vector should have 17 dims');
+    const multiHopIdx = labelIndex('multi_hop_signal');
+    const toolIdx = labelIndex('tool_implication_norm');
+    const fileIdx = labelIndex('has_file_attachment');
+    assert.equal(fv.values[multiHopIdx], 0, 'simple question should have no multi-hop signal');
+    assert.equal(fv.values[toolIdx], 0, 'simple question should have no tool implication');
+    assert.equal(fv.values[fileIdx], 0, 'simple question should have no file attachment');
+    // Word count should be normalised well below 1
+    const wordNormIdx = labelIndex('len_words_norm');
+    assert.ok(fv.values[wordNormIdx] < 0.3, 'short question should have normalised word count < 0.3');
+    console.log('  [PASS] Test 2: simple factual question has low complexity signal');
+}
+// ---------------------------------------------------------------------------
+// Test 3: File attachment fires has_file_attachment
+// ---------------------------------------------------------------------------
+function testFileAttachmentFeature() {
+    const q = makeQuestion('Analyse the attached PDF document and extract the table.', {
+        file_name: 'document.pdf',
+        file_path: '/tmp/document.pdf',
+    });
+    const fv = extractFeatures(q);
+    const fileIdx = labelIndex('has_file_attachment');
+    const toolIdx = labelIndex('tool_implication_norm');
+    assert.equal(fv.values[fileIdx], 1, 'question with file_name should have has_file_attachment=1');
+    assert.ok(fv.values[toolIdx] > 0, 'PDF question should have tool_implication > 0');
+    console.log('  [PASS] Test 3: file attachment fires has_file_attachment');
+}
+// ---------------------------------------------------------------------------
+// Test 4: Multi-hop question fires multi_hop_signal
+// ---------------------------------------------------------------------------
+function testMultiHopFeature() {
+    const q = makeQuestion('Who was the president of the country that won the most gold medals at the Olympics that was held in the city that hosted the 1936 Games?');
+    const fv = extractFeatures(q);
+    const multiHopIdx = labelIndex('multi_hop_signal');
+    assert.equal(fv.values[multiHopIdx], 1, 'multi-hop question should fire multi_hop_signal');
+    console.log('  [PASS] Test 4: multi-hop question fires multi_hop_signal');
+}
+// ---------------------------------------------------------------------------
+// Test 5: Cold-start fallback returns medium with confidence=0.5
+// ---------------------------------------------------------------------------
+function testColdStartFallback() {
+    const predictor = new HardnessPredictor();
+    assert.equal(predictor.isTrained, false, 'new predictor should not be trained');
+    const q = makeQuestion('What is the capital of France?');
+    const result = predictor.predict(q);
+    assert.equal(result.difficulty, 'medium', 'cold-start should return medium');
+    assert.equal(result.confidence, 0.5, 'cold-start should return confidence=0.5');
+    assert.equal(result.budget.model, 'sonnet', 'medium budget should use sonnet');
+    assert.equal(result.budget.maxTurns, 8, 'medium budget should have maxTurns=8');
+    assert.equal(result.budget.votingAttempts, 1, 'medium budget should have votingAttempts=1');
+    console.log('  [PASS] Test 5: cold-start fallback returns medium with confidence=0.5');
+}
+// ---------------------------------------------------------------------------
+// Test 6: Becomes trained after ≥ 10 labelled examples
+// ---------------------------------------------------------------------------
+function testBecomesTrainedWith10Examples() {
+    const predictor = new HardnessPredictor();
+    // Generate 15 mock examples (mix of correct/incorrect)
+    const examples = [];
+    for (let i = 0; i < 15; i++) {
+        examples.push({
+            question: makeQuestion(`Mock question number ${i} about topic ${i % 3}`),
+            wasCorrect: i % 3 !== 0,
+            turns: 3 + (i % 6),
+        });
+    }
+    assert.equal(predictor.isTrained, false, 'should not be trained before training');
+    predictor.train(examples);
+    assert.equal(predictor.isTrained, true, 'should be trained after ≥10 examples');
+    console.log('  [PASS] Test 6: predictor becomes trained after ≥ 10 examples');
+}
+// ---------------------------------------------------------------------------
+// Test 7: Trained predictor scores math question harder than trivial question
+// ---------------------------------------------------------------------------
+function testTrainedRelativeHardness() {
+    const predictor = new HardnessPredictor({ conservativeMode: false });
+    // Train on 20 examples with clear pattern:
+    // - Short simple questions → correct (easy)
+    // - Long multi-step questions → incorrect (hard)
+    const examples = [];
+    for (let i = 0; i < 10; i++) {
+        examples.push({
+            question: makeQuestion(`What is the capital of country ${i}?`),
+            wasCorrect: true,
+            turns: 2,
+        });
+        examples.push({
+            question: makeQuestion(`Calculate the exact percentage difference between ${i * 100} and ${i * 100 + 50}, ` +
+                `then multiply by the number of years between 1990 and 2023. ` +
+                `Express as a decimal rounded to 3 places.`),
+            wasCorrect: false,
+            turns: 12,
+        });
+    }
+    predictor.train(examples);
+    const trivialQ = makeQuestion('What is the capital of France?');
+    const mathQ = makeQuestion('Calculate the exact percentage difference between 750 and 1250, ' +
+        'then multiply by the number of years between 1990 and 2023. ' +
+        'Express as a decimal rounded to 3 places.');
+    const trivialResult = predictor.predict(trivialQ);
+    const mathResult = predictor.predict(mathQ);
+    // The difficulty ordering should not put math as easier than trivial.
+    const ORDER = { easy: 0, medium: 1, hard: 2 };
+    assert.ok(ORDER[mathResult.difficulty] >= ORDER[trivialResult.difficulty], `math question (${mathResult.difficulty}) should be ≥ trivial (${trivialResult.difficulty})`);
+    console.log(`  [PASS] Test 7: math="${mathResult.difficulty}" (conf=${mathResult.confidence.toFixed(2)}) ≥ trivial="${trivialResult.difficulty}" (conf=${trivialResult.confidence.toFixed(2)})`);
+}
+// ---------------------------------------------------------------------------
+// Test 8: Weights round-trip through JSON export/import
+// ---------------------------------------------------------------------------
+function testWeightRoundTrip() {
+    const predictor = new HardnessPredictor();
+    const examples = [];
+    for (let i = 0; i < 12; i++) {
+        examples.push({
+            question: makeQuestion(`Question ${i}`),
+            wasCorrect: i % 2 === 0,
+            turns: 4 + i,
+        });
+    }
+    predictor.train(examples);
+    const exported = predictor.export();
+    assert.ok(exported !== null, 'exported state should not be null after training');
+    const predictor2 = new HardnessPredictor();
+    predictor2.import(exported);
+    assert.equal(predictor2.isTrained, true, 'imported predictor should be trained');
+    // Both predictors should give the same result for the same question.
+    const q = makeQuestion('How many sides does a hexagon have?');
+    const r1 = predictor.predict(q);
+    const r2 = predictor2.predict(q);
+    assert.equal(r1.difficulty, r2.difficulty, 'exported/imported predictor should give same difficulty');
+    assert.ok(Math.abs(r1.confidence - r2.confidence) < 0.001, 'exported/imported predictor should give same confidence');
+    console.log('  [PASS] Test 8: weights round-trip through export/import without loss');
+}
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+async function runSmoke() {
+    console.log('\n=== gaia-hardness predictor.smoke.ts — ADR-136 Track Q ===');
+    console.log('(mock-based, no live API, $0 cost)\n');
+    let passed = 0;
+    let total = 0;
+    function run(name, fn) {
+        total++;
+        try {
+            fn();
+            passed++;
+        }
+        catch (err) {
+            console.error(`  [FAIL] ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    run('Feature extraction: math question', testMathQuestionFeatures);
+    run('Feature extraction: simple factual', testSimpleFactualQuestion);
+    run('Feature extraction: file attachment', testFileAttachmentFeature);
+    run('Feature extraction: multi-hop signal', testMultiHopFeature);
+    run('Cold-start fallback: medium + confidence=0.5', testColdStartFallback);
+    run('Train: becomes trained with ≥10 examples', testBecomesTrainedWith10Examples);
+    run('Trained: math harder than trivial', testTrainedRelativeHardness);
+    run('Export/import: weights round-trip', testWeightRoundTrip);
+    console.log(`\n=== Summary: ${passed}/${total} tests passed ===`);
+    if (passed < total) {
+        process.exit(1);
+    }
+}
+// Run when invoked directly.
+if (process.argv[1]?.endsWith('predictor.smoke.js') ||
+    process.argv[1]?.endsWith('predictor.smoke.ts')) {
+    runSmoke().catch((err) => {
+        console.error('Smoke crashed:', err);
+        process.exit(2);
+    });
+}
+export { runSmoke };
+//# sourceMappingURL=predictor.smoke.js.map

package/v3/@claude-flow/cli/dist/src/benchmarks/gaia-hardness/train-data-loader.d.ts

@@ -0,0 +1,51 @@
+/**
+ * GAIA Hardness Predictor — Training Data Loader (ADR-136 Track Q)
+ *
+ * Loads labelled training examples from prior bench-run result JSONs
+ * (iter-15, iter-23, iter-28 outputs) and converts them into the
+ * `LabeledExample[]` format consumed by `HardnessPredictor.train()`.
+ *
+ * Expected result JSON schema (matches gaia-bench --output json):
+ * {
+ *   level: number,
+ *   model: string,
+ *   summary: { total, passed, passRate, estCostUsd, meanTurns, meanWallMs },
+ *   results: [
+ *     {
+ *       task_id: string, question: string, model: string, correct: boolean,
+ *       answer: string | null, expected_output: string, error?: string,
+ *       turns?: number, wallMs?: number, inputTokens?: number, outputTokens?: number
+ *     }
+ *   ]
+ * }
+ *
+ * The file may contain either:
+ *   (a) a single JSON object (one model run), or
+ *   (b) a JSON array of objects (multi-model run from --models a,b,c), or
+ *   (c) a text preamble followed by JSON (raw output from gaia-bench text mode
+ *       — we scan for the first '[' or '{' and parse from there).
+ *
+ * Missing files are silently skipped (returns empty array).
+ * Malformed files emit a warning to stderr and are skipped.
+ *
+ * Default search paths (tried in order, first found wins per iter):
+ *   /tmp/gaia-l1-full.json
+ *   /tmp/gaia-l1-haiku.json
+ *   /tmp/gaia-all-p1b.json
+ *   /tmp/gaia-all-p2.json
+ *   <custom paths passed by caller>
+ *
+ * Refs: ADR-136, #2156
+ */
+import type { LabeledExample } from './predictor.js';
+/** Default candidate paths for historical bench-run result JSONs. */
+export declare const DEFAULT_RESULT_PATHS: readonly string[];
+/**
+ * Load labelled training examples from historical bench-run result JSONs.
+ *
+ * @param additionalPaths - Extra file paths to scan beyond the defaults.
+ * @param verbose - If true, log loaded example counts to stderr.
+ * @returns Deduplicated array of LabeledExample (dedup by task_id, last write wins).
+ */
+export declare function loadTrainingData(additionalPaths?: string[], verbose?: boolean): LabeledExample[];
+//# sourceMappingURL=train-data-loader.d.ts.map