jfl 0.4.3 → 0.5.0

package/dist/commands/peter.js

@@ -16,6 +16,8 @@ import { PeterParkerBridge } from "../lib/peter-parker-bridge.js";
 import { getProjectHubUrl } from "../utils/context-hub-port.js";
 import { TrajectoryLoader } from "../lib/trajectory-loader.js";
 import { readEvals } from "../lib/eval-store.js";
+import { TrainingBuffer } from "../lib/training-buffer.js";
+import { PolicyHeadInference } from "../lib/policy-head.js";
 function hasRalphTui() {
     try {
         execSync("which ralph-tui", { stdio: "ignore" });
@@ -374,6 +376,51 @@ async function runWithPR(projectRoot, task) {
     gitExec(["checkout", baseBranch], projectRoot);
     console.log(chalk.green("  PP: Done\n"));
 }
+function buildRLState(evals, trajectoryLength, recentDeltas) {
+    const latest = evals.sort((a, b) => b.ts.localeCompare(a.ts))[0];
+    return {
+        composite_score: latest?.composite ?? 0,
+        dimension_scores: latest?.metrics ?? {},
+        tests_passing: latest?.metrics?.tests_passed ?? 0,
+        tests_total: latest?.metrics?.tests_total ?? 1,
+        trajectory_length: trajectoryLength,
+        recent_deltas: recentDeltas,
+        agent: "peter-parker",
+    };
+}
+function proposalToRLAction(p) {
+    return {
+        type: "experiment",
+        description: p.task,
+        files_affected: [],
+        scope: "medium",
+        branch: "",
+    };
+}
+async function rerankWithPolicyHead(projectRoot, proposals, evals, recentDeltas) {
+    const ph = new PolicyHeadInference(projectRoot);
+    if (!ph.isLoaded || proposals.length < 2)
+        return proposals;
+    const state = buildRLState(evals, 0, recentDeltas);
+    const actions = proposals.map(proposalToRLAction);
+    try {
+        const ranked = await ph.rankActions(state, actions);
+        const reordered = ranked.map(r => proposals[actions.indexOf(r.action)]);
+        const stats = ph.stats;
+        console.log(chalk.magenta(`  Policy head re-ranked ${proposals.length} proposals (trained on ${stats.trained_on} tuples, rank_corr=${stats.rank_correlation.toFixed(3)})`));
+        for (let i = 0; i < ranked.length; i++) {
+            const r = ranked[i];
+            const p = reordered[i];
+            console.log(chalk.gray(`    #${i + 1} [pred=${r.predictedReward.toFixed(4)}] ${p.task.slice(0, 60)}`));
+        }
+        console.log();
+        return reordered;
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  Policy head ranking failed: ${err.message}`));
+        return proposals;
+    }
+}
 function writeJournalEntry(projectRoot, entry) {
     const journalDir = path.join(projectRoot, ".jfl", "journal");
     if (!fs.existsSync(journalDir)) {
@@ -484,9 +531,14 @@ Respond with ONLY a JSON array, no other text.`;
             const content = response.choices[0]?.message?.content || "";
             const jsonMatch = content.match(/\[[\s\S]*\]/);
             if (jsonMatch) {
-                const proposals = JSON.parse(jsonMatch[0]);
+                let proposals = JSON.parse(jsonMatch[0]);
                 if (proposals.length > 0) {
                     proposals.sort((a, b) => b.predicted_delta - a.predicted_delta);
+                    const recentDeltas = experimentEntries
+                        .slice(0, 5)
+                        .map(e => e.score_delta ?? 0)
+                        .filter((d) => typeof d === "number");
+                    proposals = await rerankWithPolicyHead(projectRoot, proposals, evals, recentDeltas);
                     console.log(chalk.bold("  Top 3 Proposals:\n"));
                     for (let i = 0; i < Math.min(3, proposals.length); i++) {
                         const p = proposals[i];
@@ -560,8 +612,1119 @@ Respond with ONLY a JSON array, no other text.`;
     console.log(chalk.cyan("  Dispatching to Peter Parker PR workflow...\n"));
     await runWithPR(projectRoot, proposal.task);
 }
+async function runAutoresearch(projectRoot, rounds) {
+    console.log(chalk.bold(`\n  Peter Parker - Autoresearch Mode (${rounds} rounds)\n`));
+    console.log(chalk.gray("  Pattern: branch → change → eval → keep|revert → repeat"));
+    console.log(chalk.gray("  Only the winning experiment gets a PR.\n"));
+    if (!hasRalphTui()) {
+        console.log(chalk.yellow("  ralph-tui is not installed"));
+        console.log(chalk.gray("  Install: bun install -g ralph-tui\n"));
+        return;
+    }
+    const configPath = path.join(projectRoot, ".ralph-tui", "config.toml");
+    if (!fs.existsSync(configPath)) {
+        console.log(chalk.yellow("  No Peter Parker config found"));
+        console.log(chalk.gray("  Run: jfl peter setup\n"));
+        return;
+    }
+    const loader = new TrajectoryLoader(projectRoot);
+    const evals = readEvals(projectRoot);
+    if (evals.length === 0) {
+        console.log(chalk.yellow("  No eval history. Run `jfl peter pr` first.\n"));
+        return;
+    }
+    const baseBranch = "main";
+    const latestEval = evals.sort((a, b) => b.ts.localeCompare(a.ts))[0];
+    const baselinePassRate = latestEval?.composite ?? 0;
+    const baselineTotal = latestEval?.metrics?.tests_total ?? 0;
+    const baselineScore = baselinePassRate + (baselineTotal > 0 ? baselineTotal * 0.001 : 0);
+    console.log(chalk.gray(`  Baseline composite: ${baselineScore.toFixed(4)} (${baselineTotal} tests)`));
+    const results = [];
+    let bestResult = null;
+    for (let round = 1; round <= rounds; round++) {
+        console.log(chalk.bold(`\n  ── Round ${round}/${rounds} ${"─".repeat(40)}\n`));
+        const experimentEntries = loader.load({ type: "experiment", maxAge: "30d", limit: 20 });
+        const pastTitles = [
+            ...experimentEntries.map(e => e.title),
+            ...results.map(r => r.task),
+        ];
+        let proposal = null;
+        const stratusKey = process.env.STRATUS_API_KEY;
+        if (stratusKey) {
+            try {
+                const { StratusClient } = await import("../lib/stratus-client.js");
+                const stratus = new StratusClient({
+                    baseUrl: process.env.STRATUS_API_URL || "https://api.stratus.run",
+                    apiKey: stratusKey,
+                    model: "stratus-x1ac-base-claude-sonnet-4-6",
+                    timeout: 60000,
+                });
+                const evalSummary = buildEvalSummary(evals.concat(results.map(r => ({
+                    v: 1, ts: new Date().toISOString(), agent: "autoresearch",
+                    run_id: `autoresearch-r${r.round}`,
+                    metrics: { composite: r.score }, composite: r.score,
+                    model_version: `round-${r.round}`,
+                }))), 15);
+                const policyHead = new PolicyHeadInference(projectRoot);
+                const useMultiProposal = policyHead.isLoaded;
+                const prompt = useMultiProposal
+                    ? `Autoresearch round ${round}/${rounds}. Suggest 3 specific improvements ranked by expected impact.
+
+Eval history:
+${evalSummary}
+
+Already tried (avoid these):
+${pastTitles.map(t => `- ${t}`).join("\n") || "Nothing yet"}
+
+Previous rounds this session:
+${results.map(r => `- Round ${r.round}: "${r.task}" → delta=${r.delta > 0 ? "+" : ""}${r.delta.toFixed(4)}`).join("\n") || "None yet"}
+
+Respond with ONLY a JSON array of 3 objects: [{"task": "...", "predicted_delta": 0.0-1.0, "reasoning": "...", "risk": "..."}, ...]`
+                    : `Autoresearch round ${round}/${rounds}. Suggest ONE specific improvement.
+
+Eval history:
+${evalSummary}
+
+Already tried (avoid these):
+${pastTitles.map(t => `- ${t}`).join("\n") || "Nothing yet"}
+
+Previous rounds this session:
+${results.map(r => `- Round ${r.round}: "${r.task}" → delta=${r.delta > 0 ? "+" : ""}${r.delta.toFixed(4)}`).join("\n") || "None yet"}
+
+Suggest the SINGLE highest-value change. JSON format:
+{"task": "...", "predicted_delta": 0.0-1.0, "reasoning": "...", "risk": "..."}`;
+                const response = await stratus.reason(prompt, {
+                    temperature: 0.8 + (round * 0.05),
+                    maxTokens: useMultiProposal ? 1500 : 500,
+                    featureContext: "autoresearch",
+                });
+                const content = response.choices[0]?.message?.content || "";
+                if (useMultiProposal) {
+                    const jsonMatch = content.match(/\[[\s\S]*\]/);
+                    if (jsonMatch) {
+                        let proposals = JSON.parse(jsonMatch[0]);
+                        const recentDeltas = results.slice(-5).map(r => r.delta);
+                        proposals = await rerankWithPolicyHead(projectRoot, proposals, evals, recentDeltas);
+                        if (proposals.length > 0)
+                            proposal = proposals[0];
+                    }
+                }
+                if (!proposal) {
+                    const jsonMatch = content.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        proposal = JSON.parse(jsonMatch[0]);
+                    }
+                }
+            }
+            catch (err) {
+                console.log(chalk.yellow(`  Stratus failed: ${err.message}`));
+            }
+        }
+        if (!proposal) {
+            const regressed = findRegressedDimensions(evals);
+            const lowest = findLowestDimension(evals);
+            if (regressed.length > 0) {
+                const worst = regressed[0];
+                proposal = {
+                    task: `Improve ${worst.dimension} score (regressed by ${worst.delta.toFixed(4)})`,
+                    predicted_delta: Math.abs(worst.delta),
+                    reasoning: `Recovering ${worst.dimension} regression`,
+                    risk: "May not fully recover",
+                };
+            }
+            else if (lowest) {
+                proposal = {
+                    task: `Improve ${lowest.dimension} score (currently ${lowest.score.toFixed(4)})`,
+                    predicted_delta: Math.max(0.01, (1 - lowest.score) * 0.1),
+                    reasoning: `${lowest.dimension} is weakest dimension`,
+                    risk: "May trade off against others",
+                };
+            }
+            else {
+                console.log(chalk.yellow("  No target found, skipping round"));
+                continue;
+            }
+        }
+        console.log(chalk.cyan(`  Task: ${proposal.task}`));
+        console.log(chalk.gray(`  Predicted: +${proposal.predicted_delta.toFixed(4)}\n`));
+        const branchName = `pp/autoresearch-r${round}-${Date.now()}`;
+        gitExec(["stash", "--include-untracked"], projectRoot);
+        gitExec(["fetch", "origin", baseBranch], projectRoot);
+        let checkout = gitExec(["checkout", "-b", branchName, `origin/${baseBranch}`], projectRoot);
+        if (!checkout.ok) {
+            checkout = gitExec(["checkout", "-b", branchName, baseBranch], projectRoot);
+        }
+        if (!checkout.ok) {
+            console.log(chalk.red(`  Failed to create branch ${branchName}`));
+            continue;
+        }
+        await new Promise((resolve) => {
+            const ralphDir = path.join(projectRoot, ".ralph-tui");
+            if (!fs.existsSync(ralphDir))
+                fs.mkdirSync(ralphDir, { recursive: true });
+            const prdPath = path.join(ralphDir, "autoresearch-task.json");
+            const prd = {
+                name: "Autoresearch Task",
+                branchName: `ralph/autoresearch-${Date.now()}`,
+                description: proposal.task,
+                userStories: [{
+                        id: "US-001",
+                        title: proposal.task.slice(0, 80),
+                        description: proposal.task,
+                        acceptanceCriteria: ["Task completed"],
+                        priority: 1, passes: false, notes: "", dependsOn: [],
+                    }],
+                metadata: { updatedAt: new Date().toISOString() },
+            };
+            fs.writeFileSync(prdPath, JSON.stringify(prd, null, 2));
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.CLAUDE_CODE;
+            const child = spawn("claude", [
+                "--dangerously-skip-permissions",
+                "-p", proposal.task,
+                "--output-format", "text",
+            ], {
+                cwd: projectRoot, stdio: "inherit", env,
+            });
+            child.on("error", () => { try {
+                fs.unlinkSync(prdPath);
+            }
+            catch { } resolve(); });
+            child.on("exit", () => { try {
+                fs.unlinkSync(prdPath);
+            }
+            catch { } resolve(); });
+        });
+        const diffCheck = gitExec(["diff", "--quiet", "HEAD"], projectRoot);
+        const untrackedResult = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
+            cwd: projectRoot, encoding: "utf-8", stdio: "pipe",
+        });
+        const hasChanges = !diffCheck.ok || (untrackedResult.stdout || "").trim().length > 0;
+        if (!hasChanges) {
+            console.log(chalk.yellow(`  Round ${round}: No changes, skipping eval`));
+            gitExec(["checkout", baseBranch], projectRoot);
+            gitExec(["branch", "-D", branchName], projectRoot);
+            continue;
+        }
+        gitExec(["add", "-A"], projectRoot);
+        gitExec(["commit", "-m", `autoresearch: round ${round} - ${proposal.task}`], projectRoot);
+        console.log(chalk.gray("  Running local eval..."));
+        const testResult = spawnSync("npx", ["jest", "--json", "--silent"], {
+            cwd: projectRoot, encoding: "utf-8", stdio: "pipe", timeout: 120000,
+        });
+        let passing = 0, total = 1;
+        try {
+            const json = JSON.parse(testResult.stdout || "{}");
+            passing = json.numPassedTests || 0;
+            total = json.numTotalTests || 1;
+        }
+        catch { }
+        const passRate = total > 0 ? passing / total : 0;
+        const testsAdded = total - baselineTotal;
+        const score = passRate + (testsAdded > 0 ? testsAdded * 0.001 : 0);
+        const delta = score - baselineScore;
+        const result = {
+            round,
+            task: proposal.task,
+            score,
+            delta,
+            testsPassing: passing,
+            testsTotal: total,
+            branch: branchName,
+        };
+        results.push(result);
+        const emoji = delta > 0 ? "+" : delta < 0 ? "" : "=";
+        console.log(chalk.bold(`  Round ${round} result: ${score.toFixed(4)} (${emoji}${delta.toFixed(4)})`));
+        console.log(chalk.gray(`  Tests: ${passing}/${total}${testsAdded > 0 ? chalk.green(` (+${testsAdded} new)`) : ""}`));
+        if (!bestResult || result.delta > bestResult.delta) {
+            bestResult = result;
+            console.log(chalk.green(`  New best! (round ${round})`));
+        }
+        writeJournalEntry(projectRoot, {
+            v: 1,
+            ts: new Date().toISOString(),
+            session: "autoresearch",
+            type: "experiment",
+            status: (delta > 0 || testsAdded > 0) ? "complete" : "incomplete",
+            title: `Autoresearch R${round}: ${proposal.task.slice(0, 60)}`,
+            summary: `Score: ${score.toFixed(4)}, delta: ${delta > 0 ? "+" : ""}${delta.toFixed(4)}`,
+            detail: `Task: ${proposal.task}\nResult: ${passing}/${total} tests passing`,
+            hypothesis: `"${proposal.task}" improves composite by ~${proposal.predicted_delta.toFixed(4)}`,
+            outcome: delta > 0 ? "confirmed" : delta < 0 ? "rejected" : "inconclusive",
+            score_delta: delta,
+            agent_id: "peter-parker",
+        });
+        const tb = new TrainingBuffer(projectRoot);
+        tb.append({
+            agent: "peter-parker",
+            state: {
+                composite_score: baselineScore,
+                dimension_scores: evals.sort((a, b) => b.ts.localeCompare(a.ts))[0]?.metrics ?? {},
+                tests_passing: evals.sort((a, b) => b.ts.localeCompare(a.ts))[0]?.metrics?.tests_passed ?? 0,
+                tests_total: evals.sort((a, b) => b.ts.localeCompare(a.ts))[0]?.metrics?.tests_total ?? 1,
+                trajectory_length: results.length,
+                recent_deltas: results.slice(-5).map(r => r.delta),
+                agent: "peter-parker",
+            },
+            action: {
+                type: "experiment",
+                description: proposal.task,
+                files_affected: [],
+                scope: "medium",
+                branch: branchName,
+            },
+            reward: {
+                composite_delta: delta,
+                dimension_deltas: {},
+                tests_added: testsAdded,
+                quality_score: passRate,
+                improved: delta > 0 || testsAdded > 0,
+                prediction_error: Math.abs(proposal.predicted_delta - delta),
+            },
+            metadata: {
+                branch: branchName,
+                autoresearch_round: round,
+                source: "autoresearch",
+            },
+        });
+        gitExec(["checkout", baseBranch], projectRoot);
+    }
+    console.log(chalk.bold(`\n  ── Autoresearch Complete ${"─".repeat(35)}\n`));
+    console.log(chalk.gray(`  Rounds: ${rounds}`));
+    console.log(chalk.gray(`  Results:`));
+    for (const r of results) {
+        const emoji = r.delta > 0 ? chalk.green("+") : r.delta < 0 ? chalk.red("-") : chalk.gray("=");
+        const best = bestResult && r.round === bestResult.round ? chalk.yellow(" ★") : "";
+        console.log(chalk.gray(`    R${r.round}: ${r.score.toFixed(4)} (${emoji}${Math.abs(r.delta).toFixed(4)}) ${r.task.slice(0, 50)}${best}`));
+    }
+    if (bestResult && bestResult.delta > 0) {
+        console.log(chalk.green(`\n  Winner: Round ${bestResult.round} (${bestResult.delta > 0 ? "+" : ""}${bestResult.delta.toFixed(4)})`));
+        console.log(chalk.cyan("  Creating PR for winning experiment...\n"));
+        gitExec(["checkout", bestResult.branch], projectRoot);
+        const pushResult = gitExec(["push", "-u", "origin", bestResult.branch], projectRoot);
+        if (pushResult.ok) {
+            const prTitle = `PP autoresearch: ${bestResult.task.slice(0, 50)} (+${bestResult.delta.toFixed(4)})`;
+            const prBody = [
+                "## Autoresearch Winner",
+                "",
+                `**Task:** ${bestResult.task}`,
+                `**Score:** ${bestResult.score.toFixed(4)} (delta: +${bestResult.delta.toFixed(4)})`,
+                `**Tests:** ${bestResult.testsPassing}/${bestResult.testsTotal}`,
+                `**Round:** ${bestResult.round}/${rounds}`,
+                "",
+                "### All Rounds",
+                ...results.map(r => `- R${r.round}: ${r.score.toFixed(4)} (${r.delta > 0 ? "+" : ""}${r.delta.toFixed(4)}) ${r.task.slice(0, 60)}${r.round === bestResult.round ? " **← winner**" : ""}`),
+                "",
+                "---",
+                "*Generated by JFL autoresearch loop*",
+            ].join("\n");
+            let prResult = ghExec([
+                "pr", "create", "--title", prTitle, "--body", prBody,
+                "--base", baseBranch, "--head", bestResult.branch, "--label", "pp-generated",
+            ], projectRoot);
+            if (!prResult.ok) {
+                prResult = ghExec([
+                    "pr", "create", "--title", prTitle, "--body", prBody,
+                    "--base", baseBranch, "--head", bestResult.branch,
+                ], projectRoot);
+            }
+            if (prResult.ok) {
+                console.log(chalk.green(`  PR created: ${prResult.output}`));
+                await postHubEvent(projectRoot, "autoresearch:complete", {
+                    rounds,
+                    winner_round: bestResult.round,
+                    winner_task: bestResult.task,
+                    winner_delta: bestResult.delta,
+                    pr_url: prResult.output,
+                    all_results: results.map(r => ({
+                        round: r.round, task: r.task, score: r.score, delta: r.delta,
+                    })),
+                });
+            }
+            else {
+                console.log(chalk.red(`  Failed to create PR: ${prResult.output}`));
+            }
+        }
+        else {
+            console.log(chalk.red(`  Failed to push: ${pushResult.output}`));
+        }
+        gitExec(["checkout", baseBranch], projectRoot);
+    }
+    else {
+        console.log(chalk.yellow("\n  No improvement found across all rounds."));
+        console.log(chalk.gray("  All experiment branches preserved for review.\n"));
+    }
+    for (const r of results) {
+        if (!bestResult || r.round !== bestResult.round) {
+            gitExec(["branch", "-D", r.branch], projectRoot);
+        }
+    }
+    gitExec(["stash", "pop"], projectRoot);
+    console.log();
+}
+// ============================================================================
+// Scoped Agent Commands
+// ============================================================================
+async function agentCreate(projectRoot) {
+    const { writeAgentConfig, generateAgentToml } = await import("../lib/agent-config.js");
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    console.log(chalk.bold("\n  Create Scoped Agent\n"));
+    const name = await ask("  Agent name (e.g., search-quality): ");
+    const scope = await ask("  Scope (e.g., search, tests, quality): ");
+    const metric = await ask("  Metric (e.g., ndcg@10, test_pass_rate): ");
+    const direction = await ask("  Direction (maximize/minimize) [maximize]: ") || "maximize";
+    const timeBudget = await ask("  Time budget seconds [300]: ") || "300";
+    const evalScript = await ask("  Eval script path [eval/eval.ts]: ") || "eval/eval.ts";
+    const evalData = await ask("  Eval data path [eval/fixtures/data.jsonl]: ") || "eval/fixtures/data.jsonl";
+    const filesInScope = await ask("  Files in scope (glob, comma-sep) [src/**]: ") || "src/**";
+    rl.close();
+    const configPath = writeAgentConfig(projectRoot, {
+        name,
+        scope,
+        metric,
+        direction: direction,
+        time_budget_seconds: parseInt(timeBudget, 10),
+        eval: {
+            script: evalScript,
+            data: evalData,
+        },
+        constraints: {
+            files_in_scope: filesInScope.split(",").map(s => s.trim()),
+            files_readonly: ["eval/**"],
+            max_file_changes: 10,
+        },
+        policy: {
+            embedding_model: "stratus-x1ac-base-claude-sonnet-4-6",
+            exploration_rate: 0.2,
+            decay_per_round: 0.01,
+            min_exploration: 0.05,
+        },
+    });
+    console.log(chalk.green(`\n  Agent config created: ${configPath}\n`));
+}
+async function agentList(projectRoot) {
+    const { listAgentConfigs, loadAgentConfig } = await import("../lib/agent-config.js");
+    const agents = listAgentConfigs(projectRoot);
+    if (agents.length === 0) {
+        console.log(chalk.yellow("\n  No agents configured."));
+        console.log(chalk.gray("  Run: jfl peter agent create\n"));
+        return;
+    }
+    console.log(chalk.bold("\n  Configured Agents\n"));
+    for (const name of agents) {
+        try {
+            const config = loadAgentConfig(projectRoot, name);
+            console.log(chalk.cyan(`  ${name}`));
+            console.log(chalk.gray(`    Scope: ${config.scope}`));
+            console.log(chalk.gray(`    Metric: ${config.metric} (${config.direction})`));
+            console.log(chalk.gray(`    Time budget: ${config.time_budget_seconds}s`));
+            console.log(chalk.gray(`    Files: ${config.constraints.files_in_scope.join(", ")}`));
+            console.log();
+        }
+        catch (err) {
+            console.log(chalk.red(`  ${name}: Error loading config - ${err.message}`));
+        }
+    }
+}
+async function agentRun(projectRoot, agentName, roundsOverride) {
+    const { loadAgentConfig, validateAgentConfig } = await import("../lib/agent-config.js");
+    const { startSession, runBaseline, runRound, endSession, saveSessionState, writeExperimentHistory } = await import("../lib/agent-session.js");
+    const { ReplayBuffer } = await import("../lib/replay-buffer.js");
+    const { StratusClient } = await import("../lib/stratus-client.js");
+    // Load and validate config
+    let config;
+    try {
+        config = loadAgentConfig(projectRoot, agentName);
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  Agent not found: ${agentName}`));
+        console.log(chalk.gray("  Run: jfl peter agent list\n"));
+        return;
+    }
+    const validation = validateAgentConfig(config, projectRoot);
+    if (!validation.valid) {
+        console.log(chalk.red(`\n  Invalid agent config:`));
+        for (const err of validation.errors) {
+            console.log(chalk.red(`    - ${err}`));
+        }
+        console.log();
+        return;
+    }
+    // Use config.rounds as default (Karpathy: ~50 experiments per session)
+    // Allow override via CLI for debugging/testing
+    const rounds = roundsOverride ?? config.rounds ?? 50;
+    // Get scope_files for display
+    const displayScopeFiles = config.constraints.scope_files || config.constraints.files_in_scope;
+    const scopeFilesDisplay = displayScopeFiles.slice(0, 3).join(", ") + (displayScopeFiles.length > 3 ? "..." : "");
+    console.log(chalk.bold(`\n  Running Scoped Agent: ${agentName} (${rounds} rounds)\n`));
+    console.log(chalk.gray(`  Metric: ${config.metric} (${config.direction})`));
+    console.log(chalk.gray(`  Time budget: ${config.time_budget_seconds}s per round`));
+    console.log(chalk.gray(`  Focus files: ${scopeFilesDisplay}`));
+    console.log(chalk.gray(`  Pattern: branch → change → eval → keep|revert → repeat\n`));
+    // Start session
+    const session = startSession(config, projectRoot);
+    saveSessionState(session);
+    console.log(chalk.cyan(`  Session: ${session.id}`));
+    console.log(chalk.cyan(`  Branch: ${session.branch}`));
+    console.log(chalk.gray(`  Eval snapshot: ${session.evalSnapshot.hash.slice(0, 8)}\n`));
+    // Run baseline
+    console.log(chalk.gray("  Running baseline eval..."));
+    let baseline;
+    try {
+        baseline = await runBaseline(session);
+    }
+    catch (err) {
+        console.log(chalk.red(`  Baseline eval failed: ${err.message}`));
+        return;
+    }
+    console.log(chalk.green(`  Baseline: ${baseline.toFixed(4)}\n`));
+    const replayBuffer = new ReplayBuffer(projectRoot);
+    const transitions = [];
+    // Stratus for task generation
+    const stratus = process.env.STRATUS_API_KEY
+        ? new StratusClient({ apiKey: process.env.STRATUS_API_KEY })
+        : null;
+    // Get scope_files from config (Karpathy pattern: focused file list)
+    const scopeFiles = config.constraints.scope_files || config.constraints.files_in_scope || [];
+    const scopeFilesStr = scopeFiles.slice(0, 5).join(", ");
+    for (let round = 1; round <= rounds; round++) {
+        console.log(chalk.bold(`\n  ── Round ${round}/${rounds} ${"─".repeat(40)}\n`));
+        // Generate task — informed by past experiment history
+        // Default task uses scope_files for focused changes (Karpathy pattern)
+        let task = `Improve ${config.metric} by modifying: ${scopeFilesStr}. Make ONE small, focused change.`;
+        // Build history context from replay buffer + current session transitions
+        const pastTuples = replayBuffer.getForAgent(config.name).slice(-20); // Last 20 tuples
+        const keptExperiments = [];
+        const rejectedExperiments = [];
+        // From replay buffer (past sessions)
+        for (const t of pastTuples) {
+            const action = t.action?.description || "unknown";
+            const reward = t.reward ?? 0;
+            if (reward > 0) {
+                keptExperiments.push(`"${action.slice(0, 50)}" (+${reward.toFixed(4)})`);
+            }
+            else {
+                rejectedExperiments.push(`"${action.slice(0, 50)}"`);
+            }
+        }
+        // From current session transitions
+        for (const t of transitions) {
+            const action = t.action?.description || "unknown";
+            const reward = t.reward ?? 0;
+            if (reward > 0) {
+                keptExperiments.push(`"${action.slice(0, 50)}" (+${reward.toFixed(4)})`);
+            }
+            else {
+                rejectedExperiments.push(`"${action.slice(0, 50)}"`);
+            }
+        }
+        let historyContext = "";
+        if (keptExperiments.length > 0 || rejectedExperiments.length > 0) {
+            historyContext = `
+
+Experiment history for ${config.name}:
+KEPT (these worked — build on them): ${keptExperiments.slice(-5).join(", ") || "none yet"}
+REJECTED (do NOT repeat these): ${rejectedExperiments.slice(-5).join(", ") || "none yet"}
+
+CRITICAL: Do NOT repeat rejected experiments. Try something NEW and DIFFERENT.`;
+        }
+        // Read product context (Layer 2) if available
+        let productContext = "";
+        const productContextPath = path.join(projectRoot, ".jfl", "product-context.md");
+        if (fs.existsSync(productContextPath)) {
+            const pc = fs.readFileSync(productContextPath, "utf-8");
+            // Extract agent-specific guidance if present
+            const agentSection = pc.match(new RegExp(`${config.name}[:\\s].*?(?=\\n[A-Z#]|$)`, "s"));
+            productContext = agentSection
+                ? `\n\nProduct context for this agent:\n${agentSection[0].slice(0, 500)}`
+                : `\n\nProduct context (summary):\n${pc.slice(0, 500)}`;
+        }
+        if (stratus) {
+            try {
+                // Enhanced prompt with scope_files and history
+                const prompt = `Suggest ONE specific code change to improve the ${config.metric} metric (${config.direction}).
+
+FOCUS FILES (modify only these): ${scopeFilesStr}
+CURRENT METRIC: ${session.baselineMetric.toFixed(4)}
+ROUND: ${round}/${rounds}
+${historyContext}${productContext}
+
+Be concrete and actionable. Return just the task description (1-2 sentences).`;
+                const response = await stratus.reason(prompt, { maxTokens: 200, temperature: 0.7 + round * 0.03 });
+                task = response.choices[0]?.message?.content || task;
+            }
+            catch { }
+        }
+        const hypothesis = `Implementing this will improve ${config.metric}`;
+        console.log(chalk.cyan(`  Task: ${task.slice(0, 80)}...`));
+        // Pass transitions to runRound so it can build experiment history (Karpathy pattern)
+        const { result, transition } = await runRound(session, round, task, hypothesis, transitions);
+        transitions.push(transition);
+        // Write to replay buffer
+        replayBuffer.write({
+            agent: config.name,
+            session_id: session.id,
+            state_hash: transition.state_hash,
+            state: transition.state,
+            action_diff: transition.action_diff,
+            action: transition.action,
+            hypothesis,
+            reward: result.delta,
+            timestamp: new Date().toISOString(),
+        });
+        const emoji = result.kept ? chalk.green("✓") : chalk.red("✗");
+        const deltaStr = result.delta > 0 ? `+${result.delta.toFixed(4)}` : result.delta.toFixed(4);
+        console.log(`  ${emoji} Result: ${result.metricAfter.toFixed(4)} (${deltaStr}) ${result.kept ? "KEPT" : "REVERTED"}`);
+    }
+    // End session
+    const summary = await endSession(session, transitions);
+    console.log(chalk.bold(`\n  ── Session Complete ${"─".repeat(35)}\n`));
+    console.log(chalk.gray(`  Rounds: ${summary.rounds}`));
+    console.log(chalk.gray(`  Improved: ${summary.improvedRounds}`));
+    console.log(chalk.gray(`  Total delta: ${summary.totalDelta > 0 ? "+" : ""}${summary.totalDelta.toFixed(4)}`));
+    console.log(chalk.gray(`  Best delta: +${summary.bestDelta.toFixed(4)}`));
+    if (summary.branchUrl) {
+        console.log(chalk.green(`\n  Branch pushed for review: ${summary.branchUrl}`));
+    }
+    if (summary.prUrl) {
+        console.log(chalk.green(`  PR: ${summary.prUrl}`));
+    }
+    console.log();
+}
+// ============================================================================
+// Telemetry Agent V2 Commands
+// ============================================================================
+async function runTelemetryAgent(projectRoot) {
+    const { TelemetryAgentV2 } = await import("../lib/telemetry-agent-v2.js");
+    console.log(chalk.bold("\n  Telemetry Agent V2 - Platform Digest Analysis\n"));
+    const agent = new TelemetryAgentV2({
+        projectRoot,
+        emitEvent: (type, data) => {
+            console.log(chalk.gray(`  [EVENT] ${type}`));
+        },
+    });
+    console.log(chalk.gray("  Fetching platform digest..."));
+    const result = await agent.run();
+    if (!result.digest24h) {
+        console.log(chalk.yellow("\n  Could not fetch platform digest."));
+        console.log(chalk.gray("  Check JFL_PLATFORM_URL and network connectivity.\n"));
+        return;
+    }
+    console.log(chalk.green(`\n  Digest fetched for ${result.digest24h.periodHours}h period\n`));
+    // Show metrics
+    if (result.metrics) {
+        console.log(chalk.bold("  Current Metrics:"));
+        console.log(chalk.gray(`    Command Success Rate:  ${(result.metrics.command_success_rate * 100).toFixed(1)}%`));
+        console.log(chalk.gray(`    Command P90 Latency:   ${result.metrics.command_p90_latency_ms}ms`));
+        console.log(chalk.gray(`    Session Crash Rate:    ${(result.metrics.session_crash_rate * 100).toFixed(2)}%`));
+        console.log(chalk.gray(`    Hub Crash Rate:        ${(result.metrics.hub_crash_rate * 100).toFixed(2)}%`));
+        console.log(chalk.gray(`    Flow Completion Rate:  ${(result.metrics.flow_completion_rate * 100).toFixed(1)}%`));
+        console.log(chalk.gray(`    Cost Per Session:      $${result.metrics.cost_per_session_usd.toFixed(4)}`));
+        console.log(chalk.gray(`    Active Installs:       ${result.metrics.active_installs}`));
+        console.log(chalk.gray(`    Error Clusters:        ${result.metrics.error_cluster_count}`));
+        console.log();
+    }
+    // Show alerts
+    if (result.alerts.length > 0) {
+        console.log(chalk.bold(chalk.red("  Alerts:")));
+        for (const alert of result.alerts) {
+            console.log(chalk.red(`    ⚠ ${alert.name}: ${alert.percentChange.toFixed(1)}% decline`));
+            console.log(chalk.gray(`      ${alert.previous.toFixed(4)} → ${alert.current.toFixed(4)}`));
+        }
+        console.log();
+    }
+    // Show wins
+    if (result.wins.length > 0) {
+        console.log(chalk.bold(chalk.green("  Wins:")));
+        for (const win of result.wins) {
+            console.log(chalk.green(`    ✓ ${win.name}: ${win.percentChange.toFixed(1)}% improvement`));
+            console.log(chalk.gray(`      ${win.previous.toFixed(4)} → ${win.current.toFixed(4)}`));
+        }
+        console.log();
+    }
+    // Show proposed agents
+    if (result.proposedAgents.length > 0) {
+        console.log(chalk.bold("  Proposed Agents:"));
+        for (const agent of result.proposedAgents) {
+            const priority = agent.priority === "high" ? chalk.red(agent.priority) :
+                agent.priority === "medium" ? chalk.yellow(agent.priority) :
+                    chalk.gray(agent.priority);
+            console.log(chalk.cyan(`    ${agent.name} [${priority}]`));
+            console.log(chalk.gray(`      ${agent.reason}`));
+        }
+        console.log(chalk.gray(`\n  Agent configs written to .jfl/agents/proposed/\n`));
+    }
+    // Show status
+    const status = agent.getStatus();
+    console.log(chalk.gray(`  Run #${status.runCount}`));
+    console.log(chalk.gray(`  Training tuples generated: ${status.totalTrainingTuples}`));
+    console.log();
+}
+async function runSentinelReview(projectRoot) {
+    const { SentinelRL } = await import("../lib/sentinel-rl.js");
+    console.log(chalk.bold("\n  Sentinel - Nightly System Review\n"));
+    const sentinel = new SentinelRL({
+        projectRoot,
+        emitEvent: (type, data) => {
+            console.log(chalk.gray(`  [EVENT] ${type}`));
+        },
+    });
+    console.log(chalk.gray("  Collecting inputs..."));
+    const { scores, recommendations, inputs } = await sentinel.run();
+    // Show scores
+    console.log(chalk.bold("\n  System Scores:"));
+    console.log(chalk.gray(`    Product Health:       ${(scores.productHealth * 100).toFixed(0)}% ${scoreEmoji(scores.productHealth)}`));
+    console.log(chalk.gray(`    Development Velocity: ${(scores.developmentVelocity * 100).toFixed(0)}% ${scoreEmoji(scores.developmentVelocity)}`));
+    console.log(chalk.gray(`    Agent Effectiveness:  ${(scores.agentEffectiveness * 100).toFixed(0)}% ${scoreEmoji(scores.agentEffectiveness)}`));
+    console.log(chalk.gray(`    Data Quality:         ${(scores.dataQuality * 100).toFixed(0)}% ${scoreEmoji(scores.dataQuality)}`));
+    console.log(chalk.bold(`    Composite:            ${(scores.composite * 100).toFixed(0)}% ${scoreEmoji(scores.composite)}`));
+    console.log();
+    // Show recommendations
+    if (recommendations.length > 0) {
+        console.log(chalk.bold("  Recommendations:"));
+        for (const rec of recommendations) {
+            const priority = rec.priority === "high" ? chalk.red(`[${rec.priority}]`) :
+                rec.priority === "medium" ? chalk.yellow(`[${rec.priority}]`) :
+                    chalk.gray(`[${rec.priority}]`);
+            console.log(`    ${priority} ${rec.description}`);
+            console.log(chalk.gray(`      ${rec.reason}`));
+        }
+        console.log();
+    }
+    else {
+        console.log(chalk.green("  No recommendations at this time.\n"));
+    }
+    // Show data summary
+    console.log(chalk.gray(`  Journal entries analyzed: ${inputs.journalEntries.length}`));
+    console.log(chalk.gray(`  Eval entries analyzed: ${inputs.evalHistory.length}`));
+    console.log(chalk.gray(`  PR reviews analyzed: ${inputs.prReviews.length}`));
+    console.log(chalk.gray(`  Training tuples: ${inputs.trainingStats.total}`));
+    console.log(chalk.gray(`  Replay entries: ${inputs.replayStats.totalEntries}`));
+    console.log(chalk.gray(`\n  Report written to .jfl/SENTINEL-REPORT.md\n`));
+}
+function scoreEmoji(score) {
+    if (score >= 0.8)
+        return chalk.green("●");
+    if (score >= 0.5)
+        return chalk.yellow("●");
+    return chalk.red("●");
+}
+async function showMetrics(projectRoot) {
+    const { TelemetryAgentV2 } = await import("../lib/telemetry-agent-v2.js");
+    console.log(chalk.bold("\n  Current Platform Metrics\n"));
+    const agent = new TelemetryAgentV2({ projectRoot });
+    const metrics = await agent.getMetrics();
+    if (!metrics) {
+        console.log(chalk.yellow("  Could not fetch metrics from platform."));
+        console.log(chalk.gray("  Check JFL_PLATFORM_URL and network connectivity.\n"));
+        return;
+    }
+    const format = (value, isPercent = false) => {
+        if (isPercent)
+            return `${(value * 100).toFixed(1)}%`;
+        return value.toFixed(4);
+    };
+    console.log(chalk.cyan("  Health Metrics:"));
+    console.log(chalk.gray(`    Command Success Rate:  ${format(metrics.command_success_rate, true)}`));
+    console.log(chalk.gray(`    Session Crash Rate:    ${format(metrics.session_crash_rate, true)}`));
+    console.log(chalk.gray(`    Hub Crash Rate:        ${format(metrics.hub_crash_rate, true)}`));
+    console.log(chalk.gray(`    Flow Completion Rate:  ${format(metrics.flow_completion_rate, true)}`));
+    console.log();
+    console.log(chalk.cyan("  Performance Metrics:"));
+    console.log(chalk.gray(`    Command P90 Latency:   ${metrics.command_p90_latency_ms}ms`));
+    console.log(chalk.gray(`    MCP Avg Latency:       ${metrics.mcp_avg_latency_ms.toFixed(1)}ms`));
+    console.log();
+    console.log(chalk.cyan("  Usage Metrics:"));
+    console.log(chalk.gray(`    Active Installs:       ${metrics.active_installs}`));
+    console.log(chalk.gray(`    Error Clusters:        ${metrics.error_cluster_count}`));
+    console.log(chalk.gray(`    Hook Hit Rate:         ${format(metrics.hook_hit_rate, true)}`));
+    console.log();
+    console.log(chalk.cyan("  Cost Metrics:"));
+    console.log(chalk.gray(`    Cost Per Session:      $${metrics.cost_per_session_usd.toFixed(4)}`));
+    console.log();
+}
+async function runDailyLoop(projectRoot) {
+    const { MetaOrchestrator } = await import("../lib/meta-orchestrator.js");
+    const { loadAllAgentConfigs } = await import("../lib/agent-config.js");
+    console.log(chalk.bold("\n  Peter Parker - Daily RL Agent Loop\n"));
+    const orchestrator = new MetaOrchestrator(projectRoot);
+    const agents = orchestrator.getAgents();
+    if (agents.length === 0) {
+        console.log(chalk.yellow("  No RL agents configured."));
+        console.log(chalk.gray("  Run: jfl onboard <service-path> to discover metrics"));
+        console.log(chalk.gray("  Or:  jfl peter agent create\n"));
+        return;
+    }
+    console.log(chalk.gray(`  Found ${agents.length} RL agent(s):\n`));
+    for (const agent of agents) {
+        console.log(chalk.gray(`    • ${agent.name} (${agent.metric}, ${agent.direction})`));
+    }
+    console.log();
+    // Read training buffer to check for stale agents
+    const tb = new TrainingBuffer(projectRoot);
+    const entries = tb.read();
+    const now = Date.now();
+    const staleThreshold = 24 * 60 * 60 * 1000; // 24 hours
+    const staleAgents = [];
+    const activeAgents = [];
+    for (const agent of agents) {
+        const agentEntries = entries.filter(e => e.agent === agent.name);
+        const latestEntry = agentEntries.sort((a, b) => b.ts.localeCompare(a.ts))[0];
+        if (!latestEntry) {
+            staleAgents.push(agent.name);
+            console.log(chalk.yellow(`  ⚠ ${agent.name}: No training data (never run)`));
+        }
+        else {
+            const lastRun = new Date(latestEntry.ts).getTime();
+            if (now - lastRun > staleThreshold) {
+                staleAgents.push(agent.name);
+                const hoursAgo = Math.floor((now - lastRun) / (60 * 60 * 1000));
+                console.log(chalk.yellow(`  ⚠ ${agent.name}: Stale (${hoursAgo}h since last training)`));
+            }
+            else {
+                activeAgents.push(agent.name);
+                console.log(chalk.green(`  ✓ ${agent.name}: Recent training data`));
+            }
+        }
+    }
+    console.log();
+    // ── Pre-flight: Mine tuples + Synthesize product context ──
+    console.log(chalk.cyan("  Pre-flight: Mining tuples from journals...\n"));
+    try {
+        const { mineAll } = await import("../lib/tuple-miner.js");
+        const { tuples: minedTuples, stats: mineStats } = mineAll({ all: true });
+        if (minedTuples.length > 0) {
+            const existing = new Set(entries.map(e => e.id));
+            let newCount = 0;
+            for (const tuple of minedTuples) {
+                const id = `tb_${Buffer.from(JSON.stringify(tuple.state) + JSON.stringify(tuple.action)).toString("base64").slice(0, 12)}`;
+                if (!existing.has(id)) {
+                    tb.append({ ...tuple, id, v: "1", ts: new Date().toISOString() });
+                    newCount++;
+                }
+            }
+            console.log(chalk.gray(`    Mined ${mineStats.totalMined} tuples, ${newCount} new → buffer total: ${entries.length + newCount}`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.yellow(`    Tuple mining failed: ${err.message}`));
+    }
+    console.log(chalk.cyan("\n  Pre-flight: Synthesizing product context...\n"));
+    try {
+        await runSynthesis(projectRoot);
+    }
+    catch (err) {
+        console.log(chalk.yellow(`    Synthesis failed: ${err.message}`));
+    }
+    // ── Layer 3: Strategic reasoning ──
+    console.log(chalk.cyan("\n  Layer 3: Strategic reasoning...\n"));
+    try {
+        const { StratusClient } = await import("../lib/stratus-client.js");
+        const stratus = new StratusClient();
+        const productContextPath = path.join(projectRoot, ".jfl", "product-context.md");
+        const productCtx = fs.existsSync(productContextPath) ? fs.readFileSync(productContextPath, "utf-8").slice(0, 2000) : "No product context yet.";
+        // Get recent results per agent
+        const agentSummaries = agents.map(a => {
+            const agentEntries = entries.filter(e => e.agent === a.name).slice(-5);
+            const improved = agentEntries.filter(e => e.reward?.improved).length;
+            return `${a.name} (${a.metric}, ${a.direction}): ${agentEntries.length} recent tuples, ${improved} improved`;
+        }).join("\n");
+        const strategicPrompt = `You are Peter Parker, a strategic agent orchestrator. Based on the product context and agent performance, decide:
+1. Which agents should run tonight (and why)
+2. Which agents to skip (and why)  
+3. Any priority shifts or new metric suggestions
+
+Product context:
+${productCtx}
+
+Agent performance:
+${agentSummaries}
+
+Stale agents (haven't run in 24h): ${staleAgents.join(", ") || "none"}
+
+Be concise. Output a JSON object: { "run": ["agent1", "agent2"], "skip": ["agent3"], "reasoning": "brief explanation", "suggestions": "any new metrics or priority changes" }`;
+        const response = await stratus.reason(strategicPrompt, { maxTokens: 500, temperature: 0.3 });
+        const strategicText = response?.choices?.[0]?.message?.content || "";
+        console.log(chalk.gray(`    Strategic reasoning:\n    ${strategicText.slice(0, 500)}`));
+        // Try to parse JSON from response
+        try {
+            const jsonMatch = strategicText.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const strategic = JSON.parse(jsonMatch[0]);
+                if (strategic.reasoning) {
+                    console.log(chalk.cyan(`\n    Reasoning: ${strategic.reasoning}`));
+                }
+                if (strategic.suggestions) {
+                    console.log(chalk.gray(`    Suggestions: ${strategic.suggestions}`));
+                }
+                // Write strategic decision to journal
+                const journalPath = path.join(projectRoot, ".jfl", "journal");
+                if (fs.existsSync(journalPath)) {
+                    const entry = {
+                        v: 2, ts: new Date().toISOString(), session: "peter-parker",
+                        type: "decision", status: "complete",
+                        title: "Layer 3: Strategic reasoning",
+                        summary: strategic.reasoning || strategicText.slice(0, 200),
+                        detail: strategicText,
+                    };
+                    const files = fs.readdirSync(journalPath).filter(f => f.endsWith(".jsonl")).sort();
+                    const latestJournal = files[files.length - 1];
+                    if (latestJournal) {
+                        fs.appendFileSync(path.join(journalPath, latestJournal), "\n" + JSON.stringify(entry));
+                    }
+                }
+            }
+        }
+        catch { /* non-JSON response, that's fine */ }
+    }
+    catch (err) {
+        console.log(chalk.yellow(`    Strategic reasoning failed: ${err.message}`));
+    }
+    console.log();
+    // Check for scope:impact events that should trigger downstream agents
+    const impactTriggered = orchestrator.getImpactTriggeredAgents();
+    if (impactTriggered.length > 0) {
+        console.log(chalk.cyan("  Scope impact events detected:"));
+        for (const { agent, impactPattern } of impactTriggered) {
+            console.log(chalk.gray(`    • ${agent.name} should react to: ${impactPattern}`));
+        }
+        console.log();
+    }
+    // Schedule next agent using meta-orchestrator
+    const decision = orchestrator.scheduleNext();
+    if (!decision) {
+        console.log(chalk.yellow("  No agent available to schedule."));
+        return;
+    }
+    console.log(chalk.bold(`  Scheduled: ${decision.agent.name}`));
+    console.log(chalk.gray(`  Reason: ${decision.reason}`));
+    if (decision.impactPattern) {
+        console.log(chalk.gray(`  Triggered by: ${decision.impactPattern}`));
+    }
+    if (decision.emaReward !== undefined) {
+        console.log(chalk.gray(`  EMA Reward: ${decision.emaReward.toFixed(4)}`));
+    }
+    console.log();
+    // Run autoresearch for stale agents
+    if (staleAgents.length > 0) {
+        console.log(chalk.cyan(`  Running autoresearch for ${staleAgents.length} stale agent(s)...\n`));
+        for (const agentName of staleAgents) {
+            console.log(chalk.bold(`\n  ── ${agentName} ${"─".repeat(45)}\n`));
+            await agentRun(projectRoot, agentName); // Use config.rounds (default 50)
+        }
+    }
+    // Post summary event
+    await postHubEvent(projectRoot, "peter:daily-complete", {
+        total_agents: agents.length,
+        stale_agents: staleAgents,
+        active_agents: activeAgents,
+        impact_triggered: impactTriggered.map(t => t.agent.name),
+        scheduled: decision.agent.name,
+        reason: decision.reason,
+    });
+    console.log(chalk.green("\n  Daily loop complete.\n"));
+}
+async function agentSwarm(projectRoot, rounds) {
+    const { MetaOrchestrator } = await import("../lib/meta-orchestrator.js");
+    const orchestrator = new MetaOrchestrator(projectRoot);
+    const agents = orchestrator.getAgents();
+    if (agents.length === 0) {
+        console.log(chalk.yellow("\n  No agents configured."));
+        console.log(chalk.gray("  Run: jfl peter agent create\n"));
+        return;
+    }
+    console.log(chalk.bold(`\n  Agent Swarm: ${agents.length} agents, ${rounds} rounds total\n`));
+    for (const agent of agents) {
+        console.log(chalk.gray(`    - ${agent.name} (${agent.metric})`));
+    }
+    console.log();
+    const result = await orchestrator.runSwarm(rounds, (agent, round, reward, reason) => {
+        const emoji = reward > 0 ? chalk.green("+") : reward < 0 ? chalk.red("-") : chalk.gray("=");
+        console.log(chalk.gray(`  [${round}/${rounds}] ${agent} → ${emoji}${Math.abs(reward).toFixed(4)} (${reason})`));
+    });
+    console.log(chalk.bold(`\n  ── Swarm Complete ${"─".repeat(38)}\n`));
+    const stats = orchestrator.getStats();
+    console.log(chalk.gray(`  Total rounds: ${stats.totalRounds}`));
+    console.log(chalk.gray(`  Avg EMA reward: ${stats.avgEmaReward.toFixed(4)}`));
+    console.log(chalk.gray(`  Overall win rate: ${(stats.overallWinRate * 100).toFixed(1)}%`));
+    if (stats.bestAgent) {
+        console.log(chalk.green(`  Best agent: ${stats.bestAgent.name} (EMA: ${stats.bestAgent.emaReward.toFixed(4)})`));
+    }
+    console.log(chalk.bold("\n  Per-Agent Results:\n"));
+    for (const [name, data] of Object.entries(result.perAgent)) {
+        console.log(chalk.cyan(`    ${name}: ${data.rounds} rounds, total delta: ${data.totalReward > 0 ? "+" : ""}${data.totalReward.toFixed(4)}`));
+    }
+    console.log();
+}
+// ============================================================================
+// Synthesis — distill journals + events into product context for agents
+// ============================================================================
+async function runSynthesis(projectRoot) {
+    console.log(chalk.bold("\n  Peter Parker - Product Context Synthesis\n"));
+    const { StratusClient } = await import("../lib/stratus-client.js");
+    const stratus = process.env.STRATUS_API_KEY
+        ? new StratusClient({ apiKey: process.env.STRATUS_API_KEY })
+        : null;
+    if (!stratus) {
+        console.log(chalk.red("  STRATUS_API_KEY required for synthesis"));
+        return;
+    }
+    // 1. Read recent journals (last 7 days)
+    const journalDir = path.join(projectRoot, ".jfl", "journal");
+    let journalEntries = [];
+    if (fs.existsSync(journalDir)) {
+        const files = fs.readdirSync(journalDir).filter(f => f.endsWith(".jsonl"));
+        for (const file of files.slice(-10)) { // Last 10 journal files
+            const content = fs.readFileSync(path.join(journalDir, file), "utf-8").trim();
+            if (content)
+                journalEntries.push(...content.split("\n").slice(-20)); // Last 20 entries per file
+        }
+    }
+    console.log(chalk.gray(`  Read ${journalEntries.length} journal entries`));
+    // 2. Read recent events
+    const eventsPath = path.join(projectRoot, ".jfl", "service-events.jsonl");
+    let events = [];
+    if (fs.existsSync(eventsPath)) {
+        events = fs.readFileSync(eventsPath, "utf-8").trim().split("\n").slice(-30); // Last 30 events
+    }
+    console.log(chalk.gray(`  Read ${events.length} events`));
+    // 3. Read agent results from training buffer
+    const bufferPath = path.join(projectRoot, ".jfl", "training-buffer.jsonl");
+    let tuples = [];
+    if (fs.existsSync(bufferPath)) {
+        tuples = fs.readFileSync(bufferPath, "utf-8").trim().split("\n").slice(-20);
+    }
+    console.log(chalk.gray(`  Read ${tuples.length} training tuples`));
+    // 4. Read current agent configs
+    const { listAgentConfigs, loadAgentConfig } = await import("../lib/agent-config.js");
+    const agentNames = listAgentConfigs(projectRoot);
+    const configs = agentNames.map(name => { try {
+        return loadAgentConfig(projectRoot, name);
+    }
+    catch {
+        return null;
+    } }).filter(Boolean);
+    const agentSummary = configs.map((c) => `${c.name}: ${c.metric} (${c.direction}), target: ${c.target_repo || "self"}`).join("\n");
+    // 5. Send to Stratus for synthesis
+    console.log(chalk.gray("\n  Synthesizing with Stratus...\n"));
+    const prompt = `You are Peter Parker, the orchestrator for a software product portfolio.
+
+Your job: read the recent activity (journals, events, experiment results) and produce a PRODUCT CONTEXT document that tells scoped RL agents what the product is, what's been happening, and what to focus on.
+
+## Current Agents
+${agentSummary}
+
+## Recent Journal Entries (last 7 days)
+${journalEntries.slice(-15).map(e => e.slice(0, 200)).join("\n")}
+
+## Recent Events
+${events.slice(-15).join("\n")}
+
+## Recent Experiment Results
+${tuples.slice(-10).join("\n")}
+
+---
+
+Produce a concise product-context.md with these sections:
+1. **Product State** — what is this product, what's working, what's broken
+2. **Recent Activity** — what the team has been building/fixing (distilled from journals)
+3. **Agent Guidance** — for each active agent, specific guidance based on recent context (e.g. "cli-speed: startup is already fast, focus on subcommand latency")
+4. **Priority Shifts** — any metrics that should be deprioritized or new metrics to consider
+5. **Open Questions** — things that need human input
+
+Be concise. This document is consumed by agents, not humans. Skip fluff.`;
+    try {
+        const response = await stratus.reason(prompt, { maxTokens: 1500, temperature: 0.3 });
+        const synthesis = response.choices[0]?.message?.content || "";
+        if (synthesis) {
+            const outputPath = path.join(projectRoot, ".jfl", "product-context.md");
+            fs.writeFileSync(outputPath, `# Product Context\n\n_Synthesized by Peter Parker at ${new Date().toISOString()}_\n\n${synthesis}\n`);
+            console.log(chalk.green(`  ✓ Product context written to .jfl/product-context.md`));
+            console.log(chalk.gray(`  (${synthesis.length} chars)\n`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`  Synthesis failed: ${err.message}`));
+    }
+}
+// ============================================================================
+// Review — check autoresearch branches, audit with Stratus, prepare PRs
+// ============================================================================
+async function runReview(projectRoot) {
+    console.log(chalk.bold("\n  Peter Parker - Autoresearch Review\n"));
+    const { spawnSync } = await import("child_process");
+    // Find session branches on remote
+    const result = spawnSync("git", ["branch", "-r", "--list", "origin/session/*"], { cwd: projectRoot, encoding: "utf-8" });
+    const branches = (result.stdout || "").trim().split("\n").map(b => b.trim()).filter(Boolean);
+    if (branches.length === 0) {
+        console.log(chalk.yellow("  No autoresearch branches found.\n"));
+        return;
+    }
+    console.log(chalk.gray(`  Found ${branches.length} session branch(es):\n`));
+    for (const branch of branches) {
+        const shortBranch = branch.replace("origin/", "");
+        // Get diff stats
+        const diffStat = spawnSync("git", ["diff", "--stat", `origin/main...${branch}`], { cwd: projectRoot, encoding: "utf-8" });
+        const logResult = spawnSync("git", ["log", "--oneline", `origin/main..${branch}`], { cwd: projectRoot, encoding: "utf-8" });
+        const commits = (logResult.stdout || "").trim().split("\n").filter(Boolean);
+        console.log(chalk.cyan(`  ${shortBranch}`));
+        console.log(chalk.gray(`    ${commits.length} commits`));
+        if (diffStat.stdout) {
+            const lastLine = diffStat.stdout.trim().split("\n").pop() || "";
+            console.log(chalk.gray(`    ${lastLine.trim()}`));
+        }
+        console.log();
+    }
+    console.log(chalk.gray("  To create PRs from these branches:"));
+    console.log(chalk.gray("    gh pr create --base main --head <branch> --title '...'\n"));
+}
 export async function peterCommand(action, options = {}) {
     const projectRoot = process.cwd();
+    // Handle "agent" subcommand
+    if (action === "agent") {
+        const subAction = options.name || options.task; // name is the subcommand, task might be agent name
+        if (subAction === "create") {
+            await agentCreate(projectRoot);
+            return;
+        }
+        else if (subAction === "list") {
+            await agentList(projectRoot);
+            return;
+        }
+        else if (subAction === "run") {
+            // jfl peter agent run <name> --rounds N
+            // The agent name would be in a different position
+            console.log(chalk.yellow("\n  Usage: jfl peter agent run <name> --rounds N\n"));
+            return;
+        }
+        else if (subAction === "swarm") {
+            const rounds = parseInt(options.rounds || "20", 10);
+            await agentSwarm(projectRoot, rounds);
+            return;
+        }
+        else if (subAction) {
+            // Assume it's an agent name for "run"
+            // Use CLI override if provided, otherwise use config.rounds (default 50)
+            const roundsOverride = options.rounds ? parseInt(options.rounds, 10) : undefined;
+            await agentRun(projectRoot, subAction, roundsOverride);
+            return;
+        }
+        // Show agent help
+        console.log(chalk.bold("\n  Peter Parker - Scoped Agent Commands\n"));
+        console.log(chalk.gray("  Commands:"));
+        console.log("    jfl peter agent create                    Interactive agent creation");
+        console.log("    jfl peter agent list                      List configured agents");
+        console.log("    jfl peter agent run <name> [--rounds N]   Run a specific agent");
+        console.log("    jfl peter agent swarm [--rounds N]        Run all agents with meta-orchestrator");
+        console.log();
+        return;
+    }
     switch (action) {
         case "setup": {
             let profile = "balanced";
@@ -592,7 +1755,47 @@ export async function peterCommand(action, options = {}) {
             break;
         }
         case "experiment": {
-            await runExperiment(projectRoot);
+            if (options.mode === "autoresearch") {
+                const rounds = parseInt(options.rounds || "5", 10);
+                await runAutoresearch(projectRoot, rounds);
+            }
+            else {
+                await runExperiment(projectRoot);
+            }
+            break;
+        }
+        case "autoresearch": {
+            const rounds = parseInt(options.rounds || "5", 10);
+            await runAutoresearch(projectRoot, rounds);
+            break;
+        }
+        case "telemetry": {
+            await runTelemetryAgent(projectRoot);
+            break;
+        }
+        case "sentinel": {
+            await runSentinelReview(projectRoot);
+            break;
+        }
+        case "metrics": {
+            await showMetrics(projectRoot);
+            break;
+        }
+        case "daily": {
+            await runDailyLoop(projectRoot);
+            break;
+        }
+        case "nightly": {
+            // Alias for daily
+            await runDailyLoop(projectRoot);
+            break;
+        }
+        case "synthesize": {
+            await runSynthesis(projectRoot);
+            break;
+        }
+        case "review": {
+            await runReview(projectRoot);
             break;
         }
         default: {
@@ -602,9 +1805,22 @@ export async function peterCommand(action, options = {}) {
             console.log("    jfl peter run [--task <task>]                  Run orchestrator");
             console.log("    jfl peter pr --task <task>                     Run + branch + PR");
             console.log("    jfl peter experiment                           Proactive: pick + execute next experiment");
+            console.log("    jfl peter autoresearch [--rounds N]            Shortcut for autoresearch mode");
             console.log("    jfl peter status                               Show status + recent events");
             console.log("    jfl peter dashboard                            Live event stream dashboard");
             console.log();
+            console.log(chalk.bold("  Telemetry & RL:\n"));
+            console.log("    jfl peter telemetry                       Run telemetry agent (platform digest)");
+            console.log("    jfl peter sentinel                        Run Sentinel nightly review");
+            console.log("    jfl peter metrics                         Show current platform metrics");
+            console.log("    jfl peter daily                           Daily RL loop (check stale agents, schedule next)");
+            console.log();
+            console.log(chalk.bold("  Scoped Agents:\n"));
+            console.log("    jfl peter agent create                    Interactive agent creation");
+            console.log("    jfl peter agent list                      List configured agents");
+            console.log("    jfl peter agent run <name> [--rounds N]   Run a specific scoped agent");
+            console.log("    jfl peter agent swarm [--rounds N]        Run all agents with orchestrator");
+            console.log();
         }
     }
 }