@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/benchmarks/gaia-hardness/predictor.js

@@ -1,260 +0,0 @@
-/**
- * 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/dist/src/benchmarks/gaia-hardness/predictor.smoke.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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/dist/src/benchmarks/gaia-hardness/predictor.smoke.js

@@ -1,235 +0,0 @@
-/**
- * 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/dist/src/benchmarks/gaia-hardness/train-data-loader.d.ts

@@ -1,51 +0,0 @@
-/**
- * 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