@10et/cli 1.0.0

package/dist/commands/train.js

@@ -0,0 +1,692 @@
+/**
+ * @purpose CLI commands for policy head training — v1 MLP + v2 transformer, transform, generate, eval
+ */
+import chalk from "chalk";
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { TrainingBuffer } from "../lib/training-buffer.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DEFAULT_THRESHOLD = {
+    min_entries: 50,
+    min_new_since_last: 25,
+    min_hours_since_last: 12,
+};
+function findProjectRoot() {
+    let dir = process.cwd();
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, ".jfl", "config.json")))
+            return dir;
+        if (existsSync(join(dir, ".jfl")))
+            return dir;
+        dir = dirname(dir);
+    }
+    return process.cwd();
+}
+function getTrainingMeta(projectRoot) {
+    const metaPath = join(projectRoot, ".jfl", "training-meta.json");
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(metaPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function getWeights(projectRoot) {
+    const weightsPath = join(projectRoot, ".jfl", "policy-weights.json");
+    if (!existsSync(weightsPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(weightsPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function getV2Meta(projectRoot) {
+    const paths = [
+        join(projectRoot, ".jfl", "checkpoints", "policy-head-v2.json"),
+        join(projectRoot, ".jfl", "policy-head-v2.json"),
+    ];
+    for (const p of paths) {
+        if (existsSync(p)) {
+            try {
+                return JSON.parse(readFileSync(p, "utf-8"));
+            }
+            catch { /* skip */ }
+        }
+    }
+    return null;
+}
+function checkThreshold(projectRoot, threshold) {
+    const buffer = new TrainingBuffer(projectRoot);
+    const entries = buffer.readAll();
+    const meta = getTrainingMeta(projectRoot);
+    const total = entries.length;
+    let newSinceLast = total;
+    let hoursSinceLast = null;
+    if (meta?.trained_at) {
+        const lastTrained = new Date(meta.trained_at).getTime();
+        hoursSinceLast = (Date.now() - lastTrained) / (1000 * 60 * 60);
+        newSinceLast = entries.filter(e => new Date(e.ts).getTime() > lastTrained).length;
+    }
+    if (total < threshold.min_entries) {
+        return {
+            ready: false,
+            reason: `Need ${threshold.min_entries} entries, have ${total}`,
+            total, newSinceLast, hoursSinceLast,
+        };
+    }
+    if (newSinceLast < threshold.min_new_since_last) {
+        return {
+            ready: false,
+            reason: `Need ${threshold.min_new_since_last} new entries since last training, have ${newSinceLast}`,
+            total, newSinceLast, hoursSinceLast,
+        };
+    }
+    if (hoursSinceLast !== null && hoursSinceLast < threshold.min_hours_since_last) {
+        return {
+            ready: false,
+            reason: `Last trained ${hoursSinceLast.toFixed(1)}h ago (min: ${threshold.min_hours_since_last}h)`,
+            total, newSinceLast, hoursSinceLast,
+        };
+    }
+    return {
+        ready: true,
+        reason: `${total} entries, ${newSinceLast} new, ready to train`,
+        total, newSinceLast, hoursSinceLast,
+    };
+}
+function findPython() {
+    const cliRoot = join(__dirname, "..", "..");
+    const venvPython = join(cliRoot, ".venv", "bin", "python3");
+    if (existsSync(venvPython)) {
+        const check = spawnSync(venvPython, ["-c", "import torch"], { encoding: "utf-8" });
+        if (check.status === 0)
+            return venvPython;
+    }
+    const sysCheck = spawnSync("python3", ["-c", "import torch"], { encoding: "utf-8" });
+    if (sysCheck.status === 0)
+        return "python3";
+    return "";
+}
+export async function trainPolicyHead(options) {
+    const projectRoot = findProjectRoot();
+    const useV1 = options.v1 === true;
+    if (!options.force) {
+        const threshold = checkThreshold(projectRoot, DEFAULT_THRESHOLD);
+        if (!threshold.ready) {
+            console.log(chalk.yellow(`\n  Training threshold not met: ${threshold.reason}`));
+            console.log(chalk.gray("  Use --force to train anyway\n"));
+            return;
+        }
+    }
+    const pythonBin = findPython();
+    if (!pythonBin) {
+        const cliRoot = join(__dirname, "..", "..");
+        console.log(chalk.red("\n  PyTorch not installed."));
+        console.log(chalk.gray("  Install with: python3 -m venv .venv && .venv/bin/pip install torch numpy requests scikit-learn tqdm"));
+        console.log(chalk.gray(`  Or: cd ${cliRoot} && pip install -r scripts/train/requirements.txt\n`));
+        return;
+    }
+    const buffer = new TrainingBuffer(projectRoot);
+    const stats = buffer.stats();
+    console.log(chalk.bold(`\n  Training Policy Head (${useV1 ? "v1 MLP" : "v2 Transformer"})`));
+    console.log(chalk.gray("  ─".repeat(30)));
+    console.log(chalk.gray(`  Data: ${stats.total} entries, ${Object.keys(stats.byAgent).length} agents`));
+    console.log(chalk.gray(`  Avg reward: ${stats.avgReward.toFixed(4)}, Improved rate: ${(stats.improvedRate * 100).toFixed(1)}%`));
+    if (useV1) {
+        // v1 training path (legacy)
+        const bufferPath = join(projectRoot, ".jfl", "training-buffer.jsonl");
+        const outputPath = options.output || join(projectRoot, ".jfl", "policy-weights.json");
+        if (!existsSync(bufferPath)) {
+            console.log(chalk.red("\n  No training data found at .jfl/training-buffer.jsonl\n"));
+            return;
+        }
+        const trainScript = join(__dirname, "..", "..", "scripts", "train", "train-policy-head.py");
+        if (!existsSync(trainScript)) {
+            console.log(chalk.red(`\n  Training script not found: ${trainScript}`));
+            return;
+        }
+        const args = [trainScript, "--data", bufferPath, "--output", outputPath];
+        if (options.epochs)
+            args.push("--epochs", options.epochs);
+        if (options.lr)
+            args.push("--lr", options.lr);
+        if (options.batchSize)
+            args.push("--batch-size", options.batchSize);
+        console.log(chalk.gray(`  Running: ${pythonBin.split("/").pop()} train-policy-head.py`));
+        console.log();
+        const result = spawnSync(pythonBin, args, {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: "inherit",
+            timeout: 30 * 60 * 1000,
+            env: { ...process.env },
+        });
+        if (result.status === 0) {
+            console.log(chalk.green("\n  v1 training complete."));
+            const weights = getWeights(projectRoot);
+            if (weights) {
+                console.log(chalk.gray(`  Direction accuracy: ${weights.direction_accuracy?.toFixed(3)}`));
+                console.log(chalk.gray(`  Rank correlation: ${weights.rank_correlation?.toFixed(3)}`));
+                console.log(chalk.gray(`  Trained on: ${weights.trained_on} entries`));
+            }
+        }
+        else {
+            console.log(chalk.red(`\n  Training failed (exit code ${result.status})`));
+        }
+    }
+    else {
+        // v2 training path
+        const dataDir = join(projectRoot, ".jfl", "v2-data");
+        const trainDataPath = join(dataDir, "train.jsonl");
+        if (!existsSync(trainDataPath)) {
+            console.log(chalk.yellow("\n  No v2 training data found. Running transform first..."));
+            await trainTransform({});
+        }
+        // Auto-precompute embeddings if cache is missing or stale
+        const embeddingCache = join(dataDir, "embeddings_cache.npz");
+        const precomputeScript = join(__dirname, "..", "..", "scripts", "train", "v2", "precompute.py");
+        if (existsSync(precomputeScript)) {
+            const needsPrecompute = !existsSync(embeddingCache);
+            if (needsPrecompute) {
+                console.log(chalk.gray("  Precomputing embeddings (Stratus)..."));
+                const pcResult = spawnSync(pythonBin, [precomputeScript, "--data-dir", dataDir], {
+                    cwd: projectRoot,
+                    encoding: "utf-8",
+                    stdio: "inherit",
+                    timeout: 10 * 60 * 1000,
+                    env: { ...process.env },
+                });
+                if (pcResult.status !== 0) {
+                    console.log(chalk.red("  Embedding precompute failed — training may use zero vectors"));
+                }
+            }
+        }
+        const trainScript = join(__dirname, "..", "..", "scripts", "train", "v2", "train.py");
+        if (!existsSync(trainScript)) {
+            console.log(chalk.red(`\n  v2 training script not found: ${trainScript}`));
+            return;
+        }
+        // Pass domain.json path if it exists (for tool definitions)
+        const domainPath = join(__dirname, "..", "..", "scripts", "train", "v2", "domain.json");
+        const outputDir = join(projectRoot, ".jfl", "checkpoints");
+        const args = [trainScript, "--data-dir", dataDir, "--output-dir", outputDir];
+        if (existsSync(domainPath))
+            args.push("--domain", domainPath);
+        if (options.epochs)
+            args.push("--epochs", options.epochs);
+        if (options.lr)
+            args.push("--lr", options.lr);
+        if (options.batchSize)
+            args.push("--batch-size", options.batchSize);
+        console.log(chalk.gray(`  Running: ${pythonBin.split("/").pop()} v2/train.py`));
+        console.log();
+        const result = spawnSync(pythonBin, args, {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            stdio: "inherit",
+            timeout: 120 * 60 * 1000,
+            env: { ...process.env },
+        });
+        if (result.status === 0) {
+            console.log(chalk.green("\n  v2 training complete."));
+            const v2Meta = getV2Meta(projectRoot);
+            if (v2Meta) {
+                console.log(chalk.gray(`  Architecture: ${v2Meta.architecture}`));
+                console.log(chalk.gray(`  Val accuracy: ${(v2Meta.val_accuracy * 100).toFixed(1)}%`));
+                console.log(chalk.gray(`  Parameters: ${v2Meta.parameters?.toLocaleString()}`));
+                console.log(chalk.gray(`  Trained on: ${v2Meta.trained_on} entries`));
+            }
+        }
+        else {
+            console.log(chalk.red(`\n  Training failed (exit code ${result.status})`));
+        }
+    }
+    console.log();
+}
+export async function trainTransform(options) {
+    const projectRoot = findProjectRoot();
+    const bufferPath = join(projectRoot, ".jfl", "training-buffer.jsonl");
+    if (!existsSync(bufferPath)) {
+        console.log(chalk.red("\n  No training buffer found at .jfl/training-buffer.jsonl\n"));
+        return;
+    }
+    const pythonBin = findPython();
+    if (!pythonBin) {
+        console.log(chalk.red("\n  Python/PyTorch not available\n"));
+        return;
+    }
+    const transformScript = join(__dirname, "..", "..", "scripts", "train", "v2", "transform_buffer.py");
+    const outputDir = join(projectRoot, ".jfl", "v2-data");
+    console.log(chalk.bold("\n  Transforming Training Buffer → v2 Format"));
+    console.log(chalk.gray("  ─".repeat(30)));
+    const args = [transformScript, "--buffer", bufferPath, "--output", outputDir];
+    if (options.all)
+        args.push("--all");
+    const result = spawnSync(pythonBin, args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: "inherit",
+        timeout: 5 * 60 * 1000,
+        env: { ...process.env },
+    });
+    if (result.status === 0) {
+        console.log(chalk.green("\n  Transform complete."));
+        // Auto-run precompute if STRATUS_API_KEY is available
+        if (process.env.STRATUS_API_KEY) {
+            console.log(chalk.gray("  Pre-computing embeddings..."));
+            const precomputeScript = join(__dirname, "..", "..", "scripts", "train", "v2", "precompute.py");
+            spawnSync(pythonBin, [precomputeScript, "--data-dir", outputDir], {
+                cwd: projectRoot,
+                encoding: "utf-8",
+                stdio: "inherit",
+                timeout: 30 * 60 * 1000,
+                env: { ...process.env },
+            });
+        }
+        else {
+            console.log(chalk.yellow("  Set STRATUS_API_KEY to pre-compute embeddings"));
+        }
+    }
+    else {
+        console.log(chalk.red(`\n  Transform failed (exit code ${result.status})`));
+    }
+    console.log();
+}
+export async function trainGenerate(options) {
+    const projectRoot = findProjectRoot();
+    const pythonBin = findPython();
+    if (!pythonBin) {
+        console.log(chalk.red("\n  Python not available\n"));
+        return;
+    }
+    const generateScript = join(__dirname, "..", "..", "scripts", "train", "v2", "generate_data.py");
+    const outputDir = join(projectRoot, ".jfl", "v2-data");
+    console.log(chalk.bold("\n  Generating Synthetic Training Data"));
+    console.log(chalk.gray("  ─".repeat(30)));
+    const args = [generateScript, "--output", outputDir];
+    if (options.goalsPerTool)
+        args.push("--goals-per-tool", options.goalsPerTool);
+    if (options.statesPerGoal)
+        args.push("--states-per-goal", options.statesPerGoal);
+    const result = spawnSync(pythonBin, args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: "inherit",
+        timeout: 60 * 60 * 1000,
+        env: { ...process.env },
+    });
+    if (result.status === 0) {
+        console.log(chalk.green("\n  Synthetic data generation complete.\n"));
+    }
+    else {
+        console.log(chalk.red(`\n  Generation failed (exit code ${result.status})\n`));
+    }
+}
+export async function trainEval(options) {
+    const projectRoot = findProjectRoot();
+    const pythonBin = findPython();
+    if (!pythonBin) {
+        console.log(chalk.red("\n  Python not available\n"));
+        return;
+    }
+    const checkpointPath = join(projectRoot, ".jfl", "checkpoints", "best_policy_head.pt");
+    if (!existsSync(checkpointPath)) {
+        console.log(chalk.red("\n  No v2 checkpoint found. Train first: jfl train policy-head\n"));
+        return;
+    }
+    const evalScript = join(__dirname, "..", "..", "scripts", "train", "v2", "eval.py");
+    const dataDir = join(projectRoot, ".jfl", "v2-data");
+    console.log(chalk.bold("\n  Evaluating v2 Policy Head"));
+    console.log(chalk.gray("  ─".repeat(30)));
+    const args = [evalScript, "--checkpoint", checkpointPath, "--data-dir", dataDir];
+    if (options.split)
+        args.push("--split", options.split);
+    const result = spawnSync(pythonBin, args, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: "inherit",
+        timeout: 10 * 60 * 1000,
+        env: { ...process.env },
+    });
+    if (result.status !== 0) {
+        console.log(chalk.red(`\n  Evaluation failed (exit code ${result.status})\n`));
+    }
+}
+export async function trainStatus() {
+    const projectRoot = findProjectRoot();
+    const buffer = new TrainingBuffer(projectRoot);
+    const stats = buffer.stats();
+    const meta = getTrainingMeta(projectRoot);
+    const weights = getWeights(projectRoot);
+    const v2Meta = getV2Meta(projectRoot);
+    const threshold = checkThreshold(projectRoot, DEFAULT_THRESHOLD);
+    console.log(chalk.bold("\n  Policy Head Training Status"));
+    console.log(chalk.gray("  ─".repeat(30)));
+    console.log(chalk.bold("\n  Training Data"));
+    console.log(`    Total entries:    ${stats.total}`);
+    console.log(`    By agent:         ${Object.entries(stats.byAgent).map(([k, v]) => `${k}(${v})`).join(", ") || "none"}`);
+    console.log(`    By source:        ${Object.entries(stats.bySource).map(([k, v]) => `${k}(${v})`).join(", ") || "none"}`);
+    console.log(`    Avg reward:       ${stats.avgReward.toFixed(4)}`);
+    console.log(`    Improved rate:    ${(stats.improvedRate * 100).toFixed(1)}%`);
+    if (v2Meta) {
+        console.log(chalk.bold("\n  v2 Policy Head (Transformer)"));
+        console.log(`    Architecture:     ${v2Meta.architecture}`);
+        console.log(`    Parameters:       ${v2Meta.parameters?.toLocaleString()}`);
+        console.log(`    Val accuracy:     ${(v2Meta.val_accuracy * 100).toFixed(1)}%`);
+        console.log(`    Tools:            ${v2Meta.num_tools}`);
+        console.log(`    Trained on:       ${v2Meta.trained_on} entries`);
+        console.log(`    Trained at:       ${v2Meta.trained_at}`);
+    }
+    if (weights) {
+        console.log(chalk.bold(`\n  v1 Policy Head (MLP)${v2Meta ? " [legacy]" : ""}`));
+        console.log(`    Architecture:     ${weights.architecture}`);
+        console.log(`    Embed dim:        ${weights.embed_dim}`);
+        console.log(`    Direction acc:    ${weights.direction_accuracy?.toFixed(3)}`);
+        console.log(`    Rank correlation: ${weights.rank_correlation?.toFixed(3)}`);
+        console.log(`    Trained on:       ${weights.trained_on} entries`);
+    }
+    if (!v2Meta && !weights) {
+        console.log(chalk.yellow("\n  No policy weights loaded"));
+    }
+    if (meta) {
+        console.log(chalk.bold("\n  Last v1 Training"));
+        console.log(`    Trained at:       ${meta.trained_at}`);
+        console.log(`    Entries used:     ${meta.entries}`);
+        console.log(`    Best epoch:       ${meta.best_epoch} / ${meta.epochs_run}`);
+        console.log(`    Val loss:         ${meta.best_val_loss?.toFixed(6)}`);
+        console.log(`    Device:           ${meta.device}`);
+    }
+    console.log(chalk.bold("\n  Training Threshold"));
+    console.log(`    Ready:            ${threshold.ready ? chalk.green("YES") : chalk.yellow("NO")}`);
+    console.log(`    Reason:           ${threshold.reason}`);
+    console.log(`    Total entries:    ${threshold.total}`);
+    console.log(`    New since last:   ${threshold.newSinceLast}`);
+    if (threshold.hoursSinceLast !== null) {
+        console.log(`    Hours since last: ${threshold.hoursSinceLast.toFixed(1)}h`);
+    }
+    // v2 data status
+    const v2DataDir = join(projectRoot, ".jfl", "v2-data");
+    if (existsSync(join(v2DataDir, "train.jsonl"))) {
+        const trainLines = readFileSync(join(v2DataDir, "train.jsonl"), "utf-8").split("\n").filter(l => l.trim()).length;
+        const valLines = existsSync(join(v2DataDir, "val.jsonl")) ? readFileSync(join(v2DataDir, "val.jsonl"), "utf-8").split("\n").filter(l => l.trim()).length : 0;
+        const testLines = existsSync(join(v2DataDir, "test.jsonl")) ? readFileSync(join(v2DataDir, "test.jsonl"), "utf-8").split("\n").filter(l => l.trim()).length : 0;
+        const hasCache = existsSync(join(v2DataDir, "embeddings_cache.npz"));
+        console.log(chalk.bold("\n  v2 Training Data"));
+        console.log(`    Train:            ${trainLines} examples`);
+        console.log(`    Val:              ${valLines} examples`);
+        console.log(`    Test:             ${testLines} examples`);
+        console.log(`    Embeddings:       ${hasCache ? chalk.green("cached") : chalk.yellow("not cached")}`);
+    }
+    console.log();
+}
+export async function trainExport(options) {
+    const projectRoot = findProjectRoot();
+    const buffer = new TrainingBuffer(projectRoot);
+    const exported = buffer.exportForTraining();
+    if (exported.length === 0) {
+        console.log(chalk.yellow("\n  No training data to export\n"));
+        return;
+    }
+    const format = options.format || "jsonl";
+    const exportDir = join(projectRoot, ".jfl", "train-export");
+    mkdirSync(exportDir, { recursive: true });
+    if (format === "jsonl") {
+        const outPath = join(exportDir, "training-data.jsonl");
+        const lines = exported.map(e => JSON.stringify(e)).join("\n") + "\n";
+        const { writeFileSync } = await import("fs");
+        writeFileSync(outPath, lines);
+        console.log(chalk.green(`\n  Exported ${exported.length} entries to ${outPath}\n`));
+    }
+    else if (format === "csv") {
+        const outPath = join(exportDir, "training-data.csv");
+        const header = "state_text,action_text,reward,agent,ts\n";
+        const rows = exported.map(e => `"${e.state_text.replace(/"/g, '""')}","${e.action_text.replace(/"/g, '""')}",${e.reward},"${e.agent}","${e.ts}"`).join("\n") + "\n";
+        const { writeFileSync } = await import("fs");
+        writeFileSync(outPath, header + rows);
+        console.log(chalk.green(`\n  Exported ${exported.length} entries to ${outPath}\n`));
+    }
+}
+export async function trainThresholdCheck(options) {
+    const projectRoot = findProjectRoot();
+    const threshold = checkThreshold(projectRoot, DEFAULT_THRESHOLD);
+    if (!options.quiet) {
+        if (threshold.ready) {
+            console.log(chalk.green(`\n  Ready to train: ${threshold.reason}\n`));
+        }
+        else {
+            console.log(chalk.yellow(`\n  Not ready: ${threshold.reason}\n`));
+        }
+    }
+    return threshold.ready;
+}
+export async function trainOnline(options) {
+    const projectRoot = findProjectRoot();
+    const v2Dir = join(projectRoot, "scripts", "train", "v2");
+    const onlineScript = join(v2Dir, "online_train.py");
+    if (!existsSync(onlineScript)) {
+        console.log(chalk.red(`  Online training script not found: ${onlineScript}`));
+        return;
+    }
+    // Find checkpoint
+    const checkpointDir = join(projectRoot, ".jfl", "checkpoints");
+    const checkpointPath = join(checkpointDir, "best_policy_head.pt");
+    if (!existsSync(checkpointPath)) {
+        console.log(chalk.yellow("  No pre-trained checkpoint found."));
+        console.log(chalk.gray("  Run offline training first: jfl train policy-head"));
+        return;
+    }
+    const dataDir = join(projectRoot, ".jfl", "v2-data");
+    console.log(chalk.bold("\n  Online Fine-Tuning (Experience Replay)\n"));
+    console.log(chalk.gray("  Drew's architecture: 70% historical + 30% new, lr=1e-5, rollback on degradation\n"));
+    const args = [
+        onlineScript,
+        "--checkpoint", checkpointPath,
+        "--data-dir", dataDir,
+        "--output-dir", checkpointDir,
+    ];
+    if (options.newData)
+        args.push("--new-data", options.newData);
+    if (options.epochs)
+        args.push("--epochs", options.epochs);
+    if (options.lr)
+        args.push("--lr", options.lr);
+    if (options.replayRatio)
+        args.push("--replay-ratio", options.replayRatio);
+    if (options.degradationThreshold)
+        args.push("--degradation-threshold", options.degradationThreshold);
+    const pythonBin = findPython();
+    const result = spawnSync(pythonBin, args, {
+        cwd: v2Dir,
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            PYTHONPATH: v2Dir,
+        },
+    });
+    if (result.status !== 0) {
+        console.log(chalk.red(`\n  Online training failed (exit ${result.status})`));
+    }
+}
+export async function trainCounterfactual(options) {
+    const { createCounterfactualBridge } = await import("../lib/counterfactual-training-bridge.js");
+    const projectRoot = findProjectRoot();
+    const ratio = options.ratio ? parseFloat(options.ratio) : 0.3;
+    const bridge = createCounterfactualBridge(projectRoot, {
+        syntheticRatio: ratio,
+    });
+    // Show current stats
+    const stats = bridge.getBufferStats();
+    console.log(chalk.bold("\n  Counterfactual → Training Buffer Bridge\n"));
+    console.log(chalk.gray(`  Current buffer: ${stats.total} entries (${stats.real} real, ${stats.synthetic} synthetic)`));
+    console.log(chalk.gray(`  Current ratio: ${(stats.ratio * 100).toFixed(1)}% synthetic (target: ${(stats.targetRatio * 100).toFixed(1)}%)`));
+    console.log(chalk.gray(`  Needs more synthetic: ${stats.needsMore ? "YES" : "no"}`));
+    console.log();
+    if (options.dryRun) {
+        console.log(chalk.yellow("  Dry run — no data will be written\n"));
+        return;
+    }
+    const since = options.since ? Date.now() - (parseFloat(options.since) * 3600000) : undefined;
+    console.log(chalk.gray("  Processing counterfactuals..."));
+    const result = await bridge.run(since);
+    console.log(chalk.bold("\n  Results:\n"));
+    console.log(`  Counterfactuals processed: ${result.counterfactualsProcessed}`);
+    console.log(`  Passed quality filters:    ${result.passedFilters}`);
+    console.log(`  Tuples added to buffer:    ${chalk.green(String(result.tuplesAdded))}`);
+    console.log(`  Duplicates skipped:        ${result.duplicatesSkipped}`);
+    console.log();
+    console.log(chalk.bold("  Buffer composition:"));
+    console.log(`  Total:     ${result.bufferComposition.totalEntries}`);
+    console.log(`  Real:      ${result.bufferComposition.realEntries}`);
+    console.log(`  Synthetic: ${result.bufferComposition.syntheticEntries}`);
+    console.log(`  Ratio:     ${(result.bufferComposition.syntheticRatio * 100).toFixed(1)}% synthetic (target: ${(result.bufferComposition.targetRatio * 100).toFixed(1)}%)`);
+    if (result.v2FilesGenerated.length > 0) {
+        console.log();
+        console.log(chalk.bold("  V2 format files:"));
+        for (const f of result.v2FilesGenerated) {
+            console.log(`    ${f}`);
+        }
+    }
+    console.log();
+}
+export async function trainBenchmark(options) {
+    const projectRoot = findProjectRoot();
+    const v2Dir = join(projectRoot, "scripts", "train", "v2");
+    const benchmarkScript = join(v2Dir, "benchmark.py");
+    if (!existsSync(benchmarkScript)) {
+        console.log(chalk.red(`  Benchmark script not found: ${benchmarkScript}`));
+        return;
+    }
+    console.log(chalk.bold("\n  PolicyHead Benchmark Scenarios\n"));
+    const args = [benchmarkScript];
+    if (options.generate) {
+        const outputPath = join(projectRoot, ".jfl", "v2-data", "benchmark.jsonl");
+        args.push("--generate", "--output", outputPath);
+        console.log(chalk.gray("  Generating benchmark.jsonl for offline eval...\n"));
+    }
+    else {
+        const checkpointPath = join(projectRoot, ".jfl", "checkpoints", "best_policy_head.pt");
+        if (existsSync(checkpointPath)) {
+            args.push("--checkpoint", checkpointPath);
+        }
+    }
+    if (options.difficulty)
+        args.push("--difficulty", options.difficulty);
+    if (options.category)
+        args.push("--category", options.category);
+    if (options.json)
+        args.push("--json");
+    const pythonBin = findPython();
+    const result = spawnSync(pythonBin, args, {
+        cwd: v2Dir,
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            PYTHONPATH: v2Dir,
+        },
+    });
+    if (result.status !== 0) {
+        console.log(chalk.red(`\n  Benchmark failed (exit ${result.status})`));
+    }
+}
+export function registerTrainCommands(parent) {
+    const train = parent.command("train").description("Policy head training pipeline");
+    train
+        .command("policy-head")
+        .description("Train policy head (v2 transformer by default, --v1 for legacy MLP)")
+        .option("-f, --force", "Train even if threshold not met")
+        .option("--v1", "Use v1 MLP trainer instead of v2 transformer")
+        .option("--epochs <n>", "Max training epochs")
+        .option("--lr <rate>", "Learning rate")
+        .option("--batch-size <n>", "Batch size")
+        .option("--min-entries <n>", "Minimum entries required")
+        .option("-o, --output <path>", "Output path for weights (v1 only)")
+        .option("-a, --agent <name>", "Filter training data to specific agent")
+        .action(async (options) => {
+        await trainPolicyHead(options);
+    });
+    train
+        .command("transform")
+        .description("Transform training buffer to v2 format (current_state, goal, correct_tool)")
+        .option("--all", "Include entries where improved=false")
+        .action(async (options) => {
+        await trainTransform(options);
+    });
+    train
+        .command("generate")
+        .description("Generate synthetic training data for v2 policy head")
+        .option("--goals-per-tool <n>", "Goals to generate per tool (default: 50)")
+        .option("--states-per-goal <n>", "States to generate per goal (default: 2)")
+        .action(async (options) => {
+        await trainGenerate(options);
+    });
+    train
+        .command("eval")
+        .description("Evaluate v2 policy head — per-tool accuracy report")
+        .option("--split <name>", "Which split to evaluate: train/val/test (default: test)")
+        .action(async (options) => {
+        await trainEval(options);
+    });
+    train
+        .command("status")
+        .description("Show training data stats, model info, and threshold")
+        .action(async () => {
+        await trainStatus();
+    });
+    train
+        .command("export")
+        .description("Export training data for external tools")
+        .option("--format <fmt>", "Export format: jsonl or csv (default: jsonl)")
+        .action(async (options) => {
+        await trainExport(options);
+    });
+    train
+        .command("check")
+        .description("Check if training threshold is met")
+        .option("-q, --quiet", "Quiet mode — exit code only")
+        .action(async (options) => {
+        const ready = await trainThresholdCheck(options);
+        if (!ready)
+            process.exitCode = 1;
+    });
+    train
+        .command("online")
+        .description("Online fine-tuning with experience replay (70% historical + 30% new)")
+        .option("--new-data <path>", "Path to new training data JSONL")
+        .option("--epochs <n>", "Max fine-tuning epochs (default: 10)")
+        .option("--lr <rate>", "Learning rate (default: 1e-5)")
+        .option("--replay-ratio <r>", "Fraction of batch that is new data (default: 0.3)")
+        .option("--degradation-threshold <t>", "Rollback if val accuracy drops more than this (default: 0.10)")
+        .action(async (options) => {
+        await trainOnline(options);
+    });
+    train
+        .command("counterfactual")
+        .description("Generate synthetic training data from counterfactual scenarios (70/30 mix)")
+        .option("--since <hours>", "Only process counterfactuals from last N hours")
+        .option("--ratio <r>", "Target synthetic ratio (default: 0.3)")
+        .option("--dry-run", "Show what would be generated without writing")
+        .action(async (options) => {
+        await trainCounterfactual(options);
+    });
+    train
+        .command("benchmark")
+        .description("Run benchmark scenarios — synthetic eval for rapid PolicyHead iteration")
+        .option("--generate", "Generate benchmark.jsonl for offline eval (no checkpoint needed)")
+        .option("--difficulty <level>", "Filter by difficulty: easy/medium/hard")
+        .option("--category <cat>", "Filter by category: diagnostic/recovery/optimization")
+        .option("--json", "Output results as JSON")
+        .action(async (options) => {
+        await trainBenchmark(options);
+    });
+    train.action(async () => {
+        await trainStatus();
+    });
+}
+//# sourceMappingURL=train.js.map