jfl 0.4.4 → 0.6.0

package/dist/commands/peter.js

@@ -16,6 +16,9 @@ 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";
+import { PiRpcBridge, CostMonitor, EventRouter } from "../lib/pi-sky/index.js";
 function hasRalphTui() {
     try {
         execSync("which ralph-tui", { stdio: "ignore" });
@@ -25,6 +28,15 @@ function hasRalphTui() {
         return false;
     }
 }
+function hasPi() {
+    try {
+        execSync("which pi", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function getAuthToken(projectRoot) {
     const tokenPath = path.join(projectRoot, ".jfl", "context-hub.token");
     if (fs.existsSync(tokenPath)) {
@@ -192,6 +204,108 @@ async function postHubEvent(projectRoot, eventType, data) {
         console.log(chalk.gray("  PP: Warning - could not post event to hub"));
     }
 }
+async function initPiRuntime(projectRoot, options) {
+    const state = {
+        bridge: null,
+        costMonitor: null,
+        eventRouter: null,
+    };
+    // Check if Pi should be used
+    const shouldUsePi = options.usePi === true || (options.usePi !== false && hasPi());
+    if (!shouldUsePi) {
+        return state;
+    }
+    console.log(chalk.cyan("  Initializing Pi runtime..."));
+    // Create Pi RPC bridge
+    state.bridge = new PiRpcBridge({
+        cwd: projectRoot,
+        yolo: true,
+        noSession: true,
+    });
+    // Initialize cost monitor if budget is set
+    if (options.budget) {
+        const costConfig = {
+            maxCost: options.budget,
+            downgradeModel: { provider: "anthropic", modelId: "claude-haiku-4-5-20251001" },
+            downgradeThinkingLevel: "low",
+            upgradeModel: { provider: "anthropic", modelId: "claude-sonnet-4-20250514" },
+            upgradeThinkingLevel: "medium",
+            criticalKeywords: ["security", "auth", "payment", "migration", "deploy", "production"],
+        };
+        state.costMonitor = new CostMonitor(costConfig);
+        state.costMonitor.on("downgrade", (data) => {
+            console.log(chalk.yellow(`  CostMonitor: Downgrading ${data.agent} to ${data.model} (budget: $${data.totalCost.toFixed(2)}/$${data.budget.toFixed(2)})`));
+        });
+        state.costMonitor.on("upgrade", (data) => {
+            console.log(chalk.cyan(`  CostMonitor: Upgrading ${data.agent} to ${data.model} (critical path: ${data.reason})`));
+        });
+        state.costMonitor.on("cost_update", (data) => {
+            if (data.remaining < data.totalCost * 0.2) {
+                console.log(chalk.yellow(`  CostMonitor: Budget low — $${data.remaining.toFixed(2)} remaining`));
+            }
+        });
+    }
+    // Initialize event router for Context Hub SSE
+    const hubUrl = getProjectHubUrl(projectRoot);
+    state.eventRouter = new EventRouter({
+        hubUrl,
+        routes: [
+            {
+                pattern: "eval:scored",
+                action: "steer",
+                messageTemplate: "SYSTEM EVENT: Eval regression detected. Agent={{data.agent}}, delta={{data.delta}}. Investigate what caused this before continuing.",
+                condition: (e) => Number(e.data?.delta ?? 0) < -0.01,
+            },
+            {
+                pattern: "scope:impact",
+                action: "follow_up",
+                messageTemplate: "SYSTEM EVENT: Scope impact from {{data.agent}} on {{data.pattern}}. Consider if this affects your current work.",
+            },
+        ],
+    });
+    state.eventRouter.on("route", (data) => {
+        console.log(chalk.gray(`  EventRouter: ${data.event.type} → ${data.route.action}`));
+    });
+    state.eventRouter.on("error", (err) => {
+        // Silent — hub may not be running
+    });
+    return state;
+}
+async function runTaskWithPi(bridge, task, costMonitor, timeout = 300000) {
+    if (!bridge.started) {
+        await bridge.start();
+    }
+    // Check critical path for model upgrade if cost monitor is active
+    if (costMonitor) {
+        await costMonitor.checkCriticalPath("experiment", task);
+    }
+    // Create a promise that resolves when agent is done
+    const agentDone = new Promise((resolve) => {
+        bridge.once("agent_end", () => resolve());
+    });
+    // Send prompt
+    await bridge.prompt(task);
+    // Wait for completion with timeout
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Pi task timeout")), timeout);
+    });
+    try {
+        await Promise.race([agentDone, timeoutPromise]);
+    }
+    catch {
+        await bridge.abort().catch(() => { });
+    }
+    // Update cost tracking
+    if (costMonitor) {
+        await costMonitor.checkCost("experiment");
+    }
+}
+async function shutdownPiRuntime(state) {
+    state.eventRouter?.stop();
+    if (state.bridge && !state.bridge.exited) {
+        await state.bridge.shutdown().catch(() => { });
+    }
+}
 async function runWithPR(projectRoot, task) {
     if (!task) {
         console.log(chalk.yellow("\n  --task is required for pr mode"));
@@ -374,6 +488,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 +643,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,20 +724,52 @@ 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) {
+async function runAutoresearch(projectRoot, options) {
+    const { rounds, budget, usePi } = options;
     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("  Only the winning experiment gets a PR."));
+    if (budget) {
+        console.log(chalk.gray(`  Budget: $${budget.toFixed(2)}`));
+    }
+    if (usePi || (usePi !== false && hasPi())) {
+        console.log(chalk.cyan("  Runtime: Pi (RPC)"));
+    }
+    else {
+        console.log(chalk.gray("  Runtime: claude CLI"));
+    }
+    console.log();
+    // Initialize Pi runtime if available
+    const piState = await initPiRuntime(projectRoot, { budget, usePi });
+    const usePiRuntime = piState.bridge !== null;
+    // Start event router to listen for eval regressions
+    if (piState.eventRouter && piState.bridge) {
+        piState.eventRouter.registerBridge("experiment", piState.bridge);
+        try {
+            await piState.eventRouter.startSse();
+        }
+        catch {
+            // Fall back to polling if SSE not available
+            await piState.eventRouter.startPolling(5000);
+        }
+    }
+    // Register bridge with cost monitor
+    if (piState.costMonitor && piState.bridge) {
+        piState.costMonitor.registerBridge("experiment", piState.bridge);
+    }
+    // Only require ralph-tui if not using Pi
+    if (!usePiRuntime && !hasRalphTui()) {
+        console.log(chalk.yellow("  ralph-tui is not installed (and Pi not available)"));
         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;
+    if (!usePiRuntime) {
+        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);
@@ -582,9 +778,11 @@ async function runAutoresearch(projectRoot, rounds) {
         return;
     }
     const baseBranch = "main";
-    const baselineScore = evals
-        .sort((a, b) => b.ts.localeCompare(a.ts))[0]?.composite ?? 0;
-    console.log(chalk.gray(`  Baseline composite: ${baselineScore.toFixed(4)}`));
+    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++) {
@@ -611,8 +809,40 @@ async function runAutoresearch(projectRoot, rounds) {
                     metrics: { composite: r.score }, composite: r.score,
                     model_version: `round-${r.round}`,
                 }))), 15);
-                const prompt = `Autoresearch round ${round}/${rounds}. Suggest ONE specific improvement.
+                const policyHead = new PolicyHeadInference(projectRoot);
+                const useMultiProposal = policyHead.isLoaded;
+                // v2 policy head: get recommended action type before generating proposals
+                let actionGuidance = "";
+                if (policyHead.isLoaded && policyHead.version >= 2) {
+                    try {
+                        const rlState = buildRLState(evals, round, results.slice(-5).map(r => r.delta));
+                        const selection = await policyHead.selectAction(rlState, "Improve codebase quality");
+                        actionGuidance = `\nPolicy head recommends action type: "${selection.action}" (confidence: ${(selection.confidence * 100).toFixed(0)}%).`;
+                        if (selection.alternatives.length > 0) {
+                            actionGuidance += ` Alternatives: ${selection.alternatives.map(a => `${a.action}(${(a.confidence * 100).toFixed(0)}%)`).join(", ")}.`;
+                        }
+                        actionGuidance += `\nFavor proposals that align with the "${selection.action}" action type.`;
+                        console.log(chalk.magenta(`  Policy head v2 recommends: ${selection.action} (${(selection.confidence * 100).toFixed(0)}%)`));
+                    }
+                    catch {
+                        // v2 not available, continue without guidance
+                    }
+                }
+                const prompt = useMultiProposal
+                    ? `Autoresearch round ${round}/${rounds}. Suggest 3 specific improvements ranked by expected impact.
+${actionGuidance}
+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.
+${actionGuidance}
 Eval history:
 ${evalSummary}
 
@@ -626,13 +856,25 @@ 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: 500,
+                    maxTokens: useMultiProposal ? 1500 : 500,
                     featureContext: "autoresearch",
                 });
                 const content = response.choices[0]?.message?.content || "";
-                const jsonMatch = content.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    proposal = JSON.parse(jsonMatch[0]);
+                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) {
@@ -677,40 +919,56 @@ Suggest the SINGLE highest-value change. JSON format:
             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("ralph-tui", ["run", "--listen", "--prd", prdPath, "--headless"], {
-                cwd: projectRoot, stdio: "inherit", env,
-            });
-            child.on("error", () => { try {
-                fs.unlinkSync(prdPath);
+        // Run the task using Pi runtime or claude CLI
+        if (usePiRuntime && piState.bridge) {
+            try {
+                await runTaskWithPi(piState.bridge, proposal.task, piState.costMonitor, 300000);
             }
-            catch { } resolve(); });
-            child.on("exit", () => { try {
-                fs.unlinkSync(prdPath);
+            catch (err) {
+                console.log(chalk.yellow(`  Pi task failed: ${err.message}`));
             }
-            catch { } resolve(); });
-        });
+        }
+        else {
+            // Fall back to claude CLI
+            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",
@@ -735,7 +993,9 @@ Suggest the SINGLE highest-value change. JSON format:
             total = json.numTotalTests || 1;
         }
         catch { }
-        const score = total > 0 ? passing / total : 0;
+        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,
@@ -749,8 +1009,8 @@ Suggest the SINGLE highest-value change. JSON format:
         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}`));
-        if (!bestResult || result.score > bestResult.score) {
+        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})`));
         }
@@ -759,7 +1019,7 @@ Suggest the SINGLE highest-value change. JSON format:
             ts: new Date().toISOString(),
             session: "autoresearch",
             type: "experiment",
-            status: delta > 0 ? "complete" : "incomplete",
+            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`,
@@ -768,6 +1028,39 @@ Suggest the SINGLE highest-value change. JSON format:
             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`));
@@ -841,10 +1134,780 @@ Suggest the SINGLE highest-value change. JSON format:
         }
     }
     gitExec(["stash", "pop"], projectRoot);
+    // Shutdown Pi runtime
+    if (piState.bridge || piState.eventRouter) {
+        console.log(chalk.gray("  Shutting down Pi runtime..."));
+        await shutdownPiRuntime(piState);
+        if (piState.costMonitor) {
+            console.log(chalk.gray(`  Total cost: $${piState.costMonitor.totalCost.toFixed(4)}`));
+        }
+    }
     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 rawScopeFiles = config.constraints.scope_files || config.constraints.files_in_scope || [];
+    const displayScopeFiles = Array.isArray(rawScopeFiles) ? rawScopeFiles : [String(rawScopeFiles)];
+    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 rawScope = config.constraints.scope_files || config.constraints.files_in_scope || [];
+    const scopeFiles = Array.isArray(rawScope) ? rawScope : [String(rawScope)];
+    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";
@@ -877,7 +1940,8 @@ export async function peterCommand(action, options = {}) {
         case "experiment": {
             if (options.mode === "autoresearch") {
                 const rounds = parseInt(options.rounds || "5", 10);
-                await runAutoresearch(projectRoot, rounds);
+                const budget = options.budget ? parseFloat(options.budget) : undefined;
+                await runAutoresearch(projectRoot, { rounds, budget, usePi: options.pi });
             }
             else {
                 await runExperiment(projectRoot);
@@ -886,7 +1950,37 @@ export async function peterCommand(action, options = {}) {
         }
         case "autoresearch": {
             const rounds = parseInt(options.rounds || "5", 10);
-            await runAutoresearch(projectRoot, rounds);
+            const budget = options.budget ? parseFloat(options.budget) : undefined;
+            await runAutoresearch(projectRoot, { rounds, budget, usePi: options.pi });
+            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: {
@@ -896,11 +1990,27 @@ 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 experiment --mode autoresearch       Tight loop: N experiments, PR the winner");
-            console.log("    jfl peter autoresearch [--rounds N]            Shortcut for autoresearch mode");
+            console.log("    jfl peter autoresearch [--rounds N] [--budget $] [--pi]");
+            console.log("                                                   Autoresearch mode with Pi runtime");
             console.log("    jfl peter status                               Show status + recent events");
             console.log("    jfl peter dashboard                            Live event stream dashboard");
             console.log();
+            console.log(chalk.bold("  Pi-sky Runtime Options:\n"));
+            console.log("    --budget <amount>    Cost budget in USD (auto-downgrades model when exceeded)");
+            console.log("    --pi                 Force Pi runtime (default: auto-detect)");
+            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();
         }
     }
 }