claude-flow 3.10.4 → 3.10.5

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

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Smoke tests for extractFinalAnswer + buildUserMessage (iter 53a T2 narrowed).
+ *
+ * Iter 53a changes vs iter 52 T2:
+ *   - Stage 2/3 (prose fallback) REMOVED — extractFinalAnswer is Stage 1 only.
+ *   - Commitment prompt no longer has "FINAL_ANSWER: unknown" surrender instruction.
+ *   - Reversed-text preprocessor PRESERVED (not the source of regressions).
+ *
+ * Anti-regression suite (7 cases):
+ *   These are the exact failure modes from iter 52 T2 that must not regress.
+ *   They test that the extraction logic is stable and correct for the 7 questions
+ *   where iter 52 broke but iter 51 was correct.
+ *
+ * Run (after build):
+ *   node dist/benchmarks/gaia-extract.smoke.js
+ *
+ * Exit 0 on all pass, 1 on any failure.
+ *
+ * Refs: ADR-133, ADR-135, iter 52 T2, iter 53a, #2156
+ */
+// Dynamic import so this file can run either as TS source (tsx) or compiled JS.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _extractFinalAnswer;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _buildUserMessage;
+function makeResp(text) {
+    return {
+        id: 'test',
+        model: 'test',
+        stop_reason: 'end_turn',
+        content: [{ type: 'text', text }],
+        usage: { input_tokens: 0, output_tokens: 0 },
+    };
+}
+const CASES = [
+    // ---------------------------------------------------------------------------
+    // Stage 1: primary FINAL_ANSWER: pattern (iter 53a: this is the ONLY stage)
+    // ---------------------------------------------------------------------------
+    {
+        label: 'Stage1 basic FINAL_ANSWER:',
+        input: 'I searched and found the capital.\nFINAL_ANSWER: Paris',
+        expected: 'Paris',
+    },
+    {
+        label: 'Stage1 case-insensitive final_answer:',
+        input: 'The result is known.\nfinal_answer: 42',
+        expected: '42',
+    },
+    {
+        label: 'Stage1 with leading whitespace',
+        input: 'Done.\n   FINAL_ANSWER:   Tokyo   ',
+        expected: 'Tokyo',
+    },
+    // ---------------------------------------------------------------------------
+    // Prose-only outputs with no FINAL_ANSWER: tag — must return null (iter 53a).
+    // These were previously handled by Stage 2/3 (iter 52 T2).
+    // In iter 53a, we rely on the agent committing with the tag instead.
+    // ---------------------------------------------------------------------------
+    {
+        label: 'Prose-only "The answer is X" — null in iter 53a (no Stage 2)',
+        input: 'After analysis, the answer is Right.',
+        expected: null,
+    },
+    {
+        label: 'Prose-only "Therefore X" — null in iter 53a (no Stage 2)',
+        input: 'Based on the clues, therefore the answer is Berlin.',
+        expected: null,
+    },
+    {
+        label: 'Prose-only "Answer: X" — null in iter 53a (no Stage 2)',
+        input: 'Let me compute this.\nAnswer: 17',
+        expected: null,
+    },
+    {
+        label: 'Prose-only all-caps last line — null in iter 53a (no Stage 3)',
+        input: 'I computed the value based on many steps.\nRIGHT',
+        expected: null,
+    },
+    {
+        label: 'Prose-only numeric last line — null in iter 53a (no Stage 3)',
+        input: 'The final calculation gives us:\n346',
+        expected: null,
+    },
+    {
+        label: 'Prose-only short-phrase last line — null in iter 53a (no Stage 3)',
+        input: 'After extensive research, the result is:\nBerlin, Germany',
+        expected: null,
+    },
+    // Null case: no answer extractable (verbose prose, no commitment)
+    {
+        label: 'Null case: only tool-call reasoning, no commitment',
+        input: 'I tried searching but could not find the specific information requested.',
+        expected: null,
+    },
+    // ---------------------------------------------------------------------------
+    // Reversed text pre-processor (buildUserMessage) — PRESERVED in iter 53a
+    // ---------------------------------------------------------------------------
+    {
+        label: 'Reversed text: adds decoded hint',
+        input: '.rewsna eht sa "tfel" drow eht fo etisoppo eht etirw ,ecnetnes siht dnatsrednu uoy fI',
+        expected: '[NOTE:',
+        isUserMsg: true,
+    },
+    {
+        label: 'Normal text: no hint added',
+        input: 'What is the capital of France?',
+        expected: 'What is the capital of France?',
+        isUserMsg: true,
+    },
+    // ---------------------------------------------------------------------------
+    // Anti-regression suite (iter 53a) — 7 cases for iter 52 regressions.
+    //
+    // These represent the exact regression patterns from iter 52 T2:
+    //   a1e91b78: agent surrendered with "unknown" (commitment prompt over-trigger)
+    //   935e2cff: agent gave empty answer (Stage 2/3 failed after extraction)
+    //   305ac316: agent gave empty answer (Stage 2/3 failed after extraction)
+    //   7673d772: agent gave empty answer (Stage 2/3 failed after extraction)
+    //   3f57289b: Stage 3 grabbed wrong number from prose
+    //   50ec8903: Stage 3 grabbed markdown fragment instead of correct answer
+    //   5a0c1adf: Stage 3 grabbed "Claus Peter" instead of correct "Claus"
+    //
+    // Each test constructs a synthetic response that mimics the failure mode
+    // and asserts the correct Stage 1 extraction behavior.
+    // ---------------------------------------------------------------------------
+    // AR-1: a1e91b78 — agent used to surrender with "FINAL_ANSWER: unknown"
+    //   In iter 52, system prompt said to output "FINAL_ANSWER: unknown" if unsure.
+    //   With that instruction removed, the agent reasons further and finds the answer.
+    //   This test verifies: if the agent DOES output a correct FINAL_ANSWER, we extract it.
+    {
+        label: 'AR-1 (a1e91b78): Stage1 extracts correct answer — not "unknown"',
+        input: 'I found the video. The maximum number of bird species seen together is 3.\nFINAL_ANSWER: 3',
+        expected: '3',
+    },
+    // AR-2: 935e2cff — agent had the answer but Stage 2 produced empty string
+    //   In iter 53a, agent should output FINAL_ANSWER: Research correctly.
+    {
+        label: 'AR-2 (935e2cff): Stage1 extracts "Research" correctly',
+        input: 'After reviewing the policy document, R stands for Research.\nFINAL_ANSWER: Research',
+        expected: 'Research',
+    },
+    // AR-3: 305ac316 — agent had "Wojciech" but extraction failed
+    {
+        label: 'AR-3 (305ac316): Stage1 extracts Polish name correctly',
+        input: 'The actor played Wojciech in the movie.\nFINAL_ANSWER: Wojciech',
+        expected: 'Wojciech',
+    },
+    // AR-4: 7673d772 — agent had "inference" but extraction failed
+    {
+        label: 'AR-4 (7673d772): Stage1 extracts legal term correctly',
+        input: 'The fifth section of the federal rule uses the word "inference".\nFINAL_ANSWER: inference',
+        expected: 'inference',
+    },
+    // AR-5: 3f57289b — Stage 3 grabbed wrong number (525 instead of 519)
+    //   The regression was caused by Stage 3 picking a wrong number from prose.
+    //   With Stage 3 removed, Stage 1 is the only source — agent must use the tag.
+    {
+        label: 'AR-5 (3f57289b): Stage1 extracts correct at-bat count',
+        input: 'Reggie Jackson had 525 at-bats but the player with most walks had 519.\nFINAL_ANSWER: 519',
+        expected: '519',
+    },
+    // AR-6: 50ec8903 — Stage 3 grabbed "- Orange-Green edge →" (markdown fragment)
+    //   With Stage 3 removed, only FINAL_ANSWER: tag is extracted.
+    {
+        label: 'AR-6 (50ec8903): Stage1 extracts Rubik cube colors correctly',
+        input: 'After solving the cube configuration, the answer is green, white.\nFINAL_ANSWER: green, white',
+        expected: 'green, white',
+    },
+    // AR-7: 5a0c1adf — Stage 3 grabbed "Claus Peter" (too many words)
+    //   With Stage 3 removed, only FINAL_ANSWER: tag is extracted.
+    {
+        label: 'AR-7 (5a0c1adf): Stage1 extracts first name only, not "Claus Peter"',
+        input: 'The conductor\'s full name is Claus Peter Flor, but his first name is Claus.\nFINAL_ANSWER: Claus',
+        expected: 'Claus',
+    },
+];
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+async function main() {
+    // Import at runtime to work with both tsx and compiled JS.
+    const mod = await import('./gaia-agent.js');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const m = mod;
+    _extractFinalAnswer = m._extractFinalAnswerForTest;
+    _buildUserMessage = m._buildUserMessageForTest;
+    if (typeof _extractFinalAnswer !== 'function' || typeof _buildUserMessage !== 'function') {
+        console.error('ERROR: _extractFinalAnswerForTest / _buildUserMessageForTest not exported from gaia-agent.' +
+            '\nAdd `export { extractFinalAnswer as _extractFinalAnswerForTest, ' +
+            'buildUserMessage as _buildUserMessageForTest }` to gaia-agent.ts.');
+        process.exit(1);
+    }
+    let failures = 0;
+    const PASS = '\x1b[32mPASS\x1b[0m';
+    const FAIL = '\x1b[31mFAIL\x1b[0m';
+    console.log('\n=== gaia-extract smoke (iter 53a T2 narrowed) ===\n');
+    console.log('Suite: 12 original + 7 anti-regression = 19 cases\n');
+    for (const tc of CASES) {
+        let actual;
+        if (tc.isUserMsg) {
+            actual = _buildUserMessage(tc.input);
+            // For user message tests, check startsWith instead of exact equality.
+            const pass = tc.expected === null
+                ? actual === null
+                : actual !== null && (tc.expected === actual || actual.startsWith(tc.expected));
+            if (pass) {
+                console.log(`  ${PASS}  ${tc.label}`);
+            }
+            else {
+                console.log(`  ${FAIL}  ${tc.label}`);
+                console.log(`         expected starts-with: ${JSON.stringify(tc.expected)}`);
+                console.log(`         actual:               ${JSON.stringify((actual ?? '').slice(0, 80))}`);
+                failures++;
+            }
+        }
+        else {
+            actual = _extractFinalAnswer(makeResp(tc.input));
+            const pass = tc.expected === null
+                ? actual === null
+                : actual !== null && actual === tc.expected;
+            if (pass) {
+                console.log(`  ${PASS}  ${tc.label}`);
+            }
+            else {
+                console.log(`  ${FAIL}  ${tc.label}`);
+                console.log(`         expected: ${JSON.stringify(tc.expected)}`);
+                console.log(`         actual:   ${JSON.stringify(actual)}`);
+                failures++;
+            }
+        }
+    }
+    const total = CASES.length;
+    const passed = total - failures;
+    console.log(`\n=== ${failures === 0 ? 'ALL PASSED' : `${failures} FAILED`} (${passed}/${total} cases) ===\n`);
+    if (failures > 0)
+        process.exit(1);
+}
+main().catch((err) => {
+    console.error('Smoke crashed:', err);
+    process.exit(2);
+});
+//# sourceMappingURL=gaia-extract.smoke.js.map

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

@@ -0,0 +1,46 @@
+/**
+ * GAIA Hardness Predictor — Feature Extraction (ADR-136 Track Q)
+ *
+ * Extracts a 17-dimensional feature vector from a GaiaQuestion for use
+ * in the linear hardness classifier.  Deliberately avoids external
+ * dependencies (no spacy, no heavy NLP) — all extraction is regex-based
+ * with O(1) per question.
+ *
+ * Feature vector layout (17 dims):
+ *   [0]  question length in characters (normalised / 500)
+ *   [1]  question length in words      (normalised / 100)
+ *   [2]  sentence count                (normalised / 5)
+ *   [3]  question word: "what"         (0/1)
+ *   [4]  question word: "how"          (0/1)
+ *   [5]  question word: "who/when/where" (0/1)
+ *   [6]  question word: "calculate/compute/how many/what percentage" (0/1)
+ *   [7]  has numeric token             (0/1)
+ *   [8]  has year token (4-digit)      (0/1)
+ *   [9]  has comparison keyword        (0/1)
+ *   [10] estimated named-entity count  (normalised / 5)
+ *   [11] digit-token count             (normalised / 5)
+ *   [12] multi-hop signal              (0/1)  — bridge/relative clause pattern
+ *   [13] requires math                 (0/1)  — "how many/much/percentage/calculate/compute"
+ *   [14] temporal chain                (0/1)  — "before/after X happened / since / until"
+ *   [15] tool implication count        (normalised / 4)  — PDF/image/video/URL markers
+ *   [16] file attachment present       (0/1)
+ *
+ * All continuous values are min-max normalised to [0, 1] using fixed
+ * divisors chosen so typical GAIA questions fall in [0.1, 0.9].
+ *
+ * Refs: ADR-136, #2156
+ */
+import type { GaiaQuestion } from '../gaia-loader.js';
+export interface FeatureVector {
+    /** Raw 17-element array in [0, 1]. */
+    values: number[];
+    /** Human-readable labels matching values index. */
+    labels: string[];
+}
+export declare const FEATURE_LABELS: readonly string[];
+/**
+ * Extract the 17-dimensional feature vector from a GaiaQuestion.
+ * All features are in [0, 1].  Never throws.
+ */
+export declare function extractFeatures(q: GaiaQuestion): FeatureVector;
+//# sourceMappingURL=features.d.ts.map

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

@@ -0,0 +1,170 @@
+/**
+ * GAIA Hardness Predictor — Feature Extraction (ADR-136 Track Q)
+ *
+ * Extracts a 17-dimensional feature vector from a GaiaQuestion for use
+ * in the linear hardness classifier.  Deliberately avoids external
+ * dependencies (no spacy, no heavy NLP) — all extraction is regex-based
+ * with O(1) per question.
+ *
+ * Feature vector layout (17 dims):
+ *   [0]  question length in characters (normalised / 500)
+ *   [1]  question length in words      (normalised / 100)
+ *   [2]  sentence count                (normalised / 5)
+ *   [3]  question word: "what"         (0/1)
+ *   [4]  question word: "how"          (0/1)
+ *   [5]  question word: "who/when/where" (0/1)
+ *   [6]  question word: "calculate/compute/how many/what percentage" (0/1)
+ *   [7]  has numeric token             (0/1)
+ *   [8]  has year token (4-digit)      (0/1)
+ *   [9]  has comparison keyword        (0/1)
+ *   [10] estimated named-entity count  (normalised / 5)
+ *   [11] digit-token count             (normalised / 5)
+ *   [12] multi-hop signal              (0/1)  — bridge/relative clause pattern
+ *   [13] requires math                 (0/1)  — "how many/much/percentage/calculate/compute"
+ *   [14] temporal chain                (0/1)  — "before/after X happened / since / until"
+ *   [15] tool implication count        (normalised / 4)  — PDF/image/video/URL markers
+ *   [16] file attachment present       (0/1)
+ *
+ * All continuous values are min-max normalised to [0, 1] using fixed
+ * divisors chosen so typical GAIA questions fall in [0.1, 0.9].
+ *
+ * Refs: ADR-136, #2156
+ */
+// ---------------------------------------------------------------------------
+// Feature labels (in order, matches values array)
+// ---------------------------------------------------------------------------
+export const FEATURE_LABELS = [
+    'len_chars_norm',
+    'len_words_norm',
+    'sentence_count_norm',
+    'qword_what',
+    'qword_how',
+    'qword_who_when_where',
+    'qword_calc_compute',
+    'has_numeric',
+    'has_year',
+    'has_comparison',
+    'entity_count_norm',
+    'digit_token_norm',
+    'multi_hop_signal',
+    'requires_math',
+    'temporal_chain',
+    'tool_implication_norm',
+    'has_file_attachment',
+];
+// ---------------------------------------------------------------------------
+// Regex catalogue (compiled once at module load)
+// ---------------------------------------------------------------------------
+// Named entity proxy: capitalised word sequences (not at sentence start)
+// e.g. "Barack Obama", "New York City", "United States of America"
+const RE_ENTITY = /(?<!^|\.\s{1,3})(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,4})/g;
+const RE_YEAR = /\b(1[0-9]{3}|20[0-9]{2})\b/g;
+const RE_DIGIT_TOKEN = /\b\d[\d,._]*/g;
+const RE_NUMERIC = /\b\d/;
+const RE_COMPARISON = /\b(more|fewer|greater|less|compare|versus|vs\.?|differ|increase|decrease|ratio|proportion)\b/i;
+const RE_MULTI_HOP = /\b(the\s+\w+\s+that\s+|which\s+was\s+|who\s+was\s+|whose\s+|of\s+the\s+\w+\s+that\s+)/i;
+// Requires math: stems without trailing \b to handle "calculate", "multiply", "division", etc.
+const RE_MATH = /\b(how\s+many|how\s+much|what\s+percentage|what\s+fraction|what\s+proportion|calculat|comput|multipli|divis|subtract|sum\s+of|total\s+of|average\s+of|product\s+of|express\s+as\s+a\s+decimal)/i;
+const RE_TEMPORAL = /\b(before|after|since|until|during|between\s+\d|in\s+the\s+year|by\s+the\s+time|at\s+the\s+time)\b/i;
+// Tool implication markers
+const RE_TOOL_FILE = /\b(pdf|\.docx|\.xlsx|\.csv|file|attachment|document|spreadsheet)\b/i;
+const RE_TOOL_IMAGE = /\b(image|photo|picture|screenshot|figure|diagram|chart)\b/i;
+const RE_TOOL_VIDEO = /\b(video|youtube|clip|footage)\b/i;
+const RE_TOOL_URL = /https?:\/\//i;
+// Question-word detection (first word of question, or full-text for calc/compute)
+const RE_QWORD_WHAT = /^(what|which)\b/i;
+const RE_QWORD_HOW = /^how\b/i;
+const RE_QWORD_WHO_WHEN_WHERE = /^(who|when|where|why|whom)\b/i;
+// calc/compute: fires if question contains calculate/compute anywhere (stems, no trailing \b)
+const RE_QWORD_CALC = /\b(calculat|comput|how\s+many|what\s+percentage|how\s+much)/i;
+// Sentence boundary (rough — period/exclamation/question-mark followed by space+capital)
+const RE_SENTENCE = /[.!?]\s+[A-Z]/g;
+// ---------------------------------------------------------------------------
+// Helper: clamp value to [0, 1]
+// ---------------------------------------------------------------------------
+function clamp(v, max) {
+    return Math.min(v / max, 1.0);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Extract the 17-dimensional feature vector from a GaiaQuestion.
+ * All features are in [0, 1].  Never throws.
+ */
+export function extractFeatures(q) {
+    const text = q.question ?? '';
+    // ── Syntactic scalars ──────────────────────────────────────────────────
+    const lenChars = text.length;
+    const words = text.trim().split(/\s+/).filter(Boolean);
+    const lenWords = words.length;
+    const sentenceMatches = text.match(RE_SENTENCE);
+    const sentenceCount = 1 + (sentenceMatches ? sentenceMatches.length : 0);
+    // ── Question-word one-hot ─────────────────────────────────────────────
+    const firstWord = text.trim();
+    const qwWhat = RE_QWORD_WHAT.test(firstWord) ? 1 : 0;
+    const qwHow = RE_QWORD_HOW.test(firstWord) ? 1 : 0;
+    const qwWhoWhenWhere = RE_QWORD_WHO_WHEN_WHERE.test(firstWord) ? 1 : 0;
+    const qwCalcCompute = RE_QWORD_CALC.test(text) ? 1 : 0;
+    // ── Lexical booleans ──────────────────────────────────────────────────
+    const hasNumeric = RE_NUMERIC.test(text) ? 1 : 0;
+    // Count year tokens
+    const yearMatches = text.match(RE_YEAR);
+    const hasYear = yearMatches && yearMatches.length > 0 ? 1 : 0;
+    const hasComparison = RE_COMPARISON.test(text) ? 1 : 0;
+    // ── Named entity proxy (capitalised word sequences) ───────────────────
+    // Reset lastIndex for global regex
+    RE_ENTITY.lastIndex = 0;
+    let entityCount = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const m = RE_ENTITY.exec(text);
+        if (!m)
+            break;
+        entityCount++;
+    }
+    // ── Digit token count ─────────────────────────────────────────────────
+    RE_DIGIT_TOKEN.lastIndex = 0;
+    const digitTokenMatches = text.match(RE_DIGIT_TOKEN);
+    const digitTokenCount = digitTokenMatches ? digitTokenMatches.length : 0;
+    // ── Multi-hop signal ──────────────────────────────────────────────────
+    const multiHopSignal = RE_MULTI_HOP.test(text) ? 1 : 0;
+    // ── Math requirement ──────────────────────────────────────────────────
+    const requiresMath = RE_MATH.test(text) ? 1 : 0;
+    // ── Temporal chain ────────────────────────────────────────────────────
+    const temporalChain = RE_TEMPORAL.test(text) ? 1 : 0;
+    // ── Tool implication (PDF/image/video/URL → file_read/web_browse/image_describe) ──
+    let toolImplication = 0;
+    if (RE_TOOL_FILE.test(text) || q.file_name)
+        toolImplication++;
+    if (RE_TOOL_IMAGE.test(text))
+        toolImplication++;
+    if (RE_TOOL_VIDEO.test(text))
+        toolImplication++;
+    if (RE_TOOL_URL.test(text))
+        toolImplication++;
+    // ── File attachment ───────────────────────────────────────────────────
+    const hasFileAttachment = q.file_name && q.file_name.trim() ? 1 : 0;
+    // ── Assemble normalised vector ────────────────────────────────────────
+    const values = [
+        clamp(lenChars, 500), // [0]
+        clamp(lenWords, 100), // [1]
+        clamp(sentenceCount, 5), // [2]
+        qwWhat, // [3]
+        qwHow, // [4]
+        qwWhoWhenWhere, // [5]
+        qwCalcCompute, // [6]
+        hasNumeric, // [7]
+        hasYear, // [8]
+        hasComparison, // [9]
+        clamp(entityCount, 5), // [10]
+        clamp(digitTokenCount, 5), // [11]
+        multiHopSignal, // [12]
+        requiresMath, // [13]
+        temporalChain, // [14]
+        clamp(toolImplication, 4), // [15]
+        hasFileAttachment ? 1 : 0, // [16]
+    ];
+    return { values, labels: FEATURE_LABELS };
+}
+//# sourceMappingURL=features.js.map

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

@@ -0,0 +1,105 @@
+/**
+ * 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 type { GaiaQuestion } from '../gaia-loader.js';
+import { type FeatureVector } from './features.js';
+export type DifficultyClass = 'easy' | 'medium' | 'hard';
+export interface ComputeBudget {
+    model: 'haiku' | 'sonnet';
+    maxTurns: number;
+    votingAttempts: number;
+}
+export interface PredictionResult {
+    difficulty: DifficultyClass;
+    confidence: number;
+    budget: ComputeBudget;
+    features: FeatureVector;
+}
+export interface LabeledExample {
+    question: GaiaQuestion;
+    wasCorrect: boolean;
+    /** Number of turns the agent used (optional; used to refine label). */
+    turns?: number;
+}
+export declare const COMPUTE_BUDGETS: Record<DifficultyClass, ComputeBudget>;
+export declare class HardnessPredictor {
+    /**
+     * Weight matrix: weights[classIdx][featureIdx].
+     * null = untrained (cold-start: return medium for everything).
+     */
+    private weights;
+    /** Bias terms per class. */
+    private biases;
+    /** Whether conservative mode is active (default: true). */
+    private readonly conservativeMode;
+    constructor(options?: {
+        conservativeMode?: boolean;
+    });
+    /**
+     * Returns true when the predictor has been trained and is ready
+     * to make non-trivial predictions.
+     */
+    get isTrained(): boolean;
+    /**
+     * 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: LabeledExample[]): void;
+    /**
+     * Predict the hardness class of a single GAIA question.
+     *
+     * Cold-start (untrained): returns medium with confidence=0.5.
+     */
+    predict(question: GaiaQuestion): PredictionResult;
+    /**
+     * Export weights as a plain JSON-serialisable object.
+     * Returns null if untrained.
+     */
+    export(): {
+        weights: number[][];
+        biases: number[];
+    } | null;
+    /**
+     * Import previously exported weights.
+     */
+    import(state: {
+        weights: number[][];
+        biases: number[];
+    }): void;
+}
+//# sourceMappingURL=predictor.d.ts.map