jfl 0.5.0 → 0.6.1

package/dist/commands/peter.js

@@ -18,6 +18,7 @@ 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" });
@@ -27,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)) {
@@ -194,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"));
@@ -612,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);
@@ -667,9 +811,26 @@ async function runAutoresearch(projectRoot, rounds) {
                 }))), 15);
                 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}
 
@@ -681,7 +842,7 @@ ${results.map(r => `- Round ${r.round}: "${r.task}" → delta=${r.delta > 0 ? "+
 
 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}
 
@@ -758,44 +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("claude", [
-                "--dangerously-skip-permissions",
-                "-p", proposal.task,
-                "--output-format", "text",
-            ], {
-                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",
@@ -961,6 +1134,14 @@ 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();
 }
 // ============================================================================
@@ -1060,7 +1241,8 @@ async function agentRun(projectRoot, agentName, roundsOverride) {
     // 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 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})`));
@@ -1091,7 +1273,8 @@ async function agentRun(projectRoot, agentName, roundsOverride) {
         ? 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 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`));
@@ -1757,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);
@@ -1766,7 +1950,8 @@ 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": {
@@ -1805,10 +1990,15 @@ 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 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");