jfl 0.9.9 → 0.9.11

package/dist/commands/peter.js

@@ -324,22 +324,14 @@ async function shutdownPiRuntime(state) {
     }
 }
 /**
- * Run an agent task using pi in non-interactive mode.
- *
- * Pi automatically picks up project context:
- * - AGENTS.md / CLAUDE.md — project instructions, skills, commands
- * - JFL custom tools — jfl_context, jfl_memory_search, jfl_eval_status, etc.
- * - Skills — eval, context, react-best-practices, etc.
- *
- * No lock files, no session management — just runs the task and exits.
+ * Run an agent task using claude CLI directly (~50MB vs ~500MB for Pi).
+ * Karpathy pattern: all context in the prompt, agent reads/edits/exits.
+ * Use JFL_AGENT_USE_PI=1 to force Pi runtime for debugging.
  */
 async function runAgentWithPi(projectRoot, task) {
-    // Minimal append — pi already loads AGENTS.md and project context.
-    // Just add PP-specific guardrails.
-    const appendPrompt = [
-        "You are Peter Parker (PP), an autonomous agent in the JFL self-driving loop.",
-        "You are fixing an issue that was auto-picked from the backlog.",
-        "Rules:",
+    const ppGuardrails = [
+        "",
+        "RULES:",
         "- Make minimal, focused changes. Don't refactor unrelated code.",
         "- Run the build (npm run build) and check for type errors before finishing.",
         "- If tests exist for the area you're changing, run them.",
@@ -347,29 +339,76 @@ async function runAgentWithPi(projectRoot, task) {
         "- Do NOT modify files outside the scope of the task.",
         "- When done, stop immediately. Do not ask for confirmation.",
     ].join("\n");
-    console.log(chalk.cyan("  PP: Using pi agent (headless, with full JFL context)"));
-    await new Promise((resolve) => {
-        const env = { ...process.env };
-        // Prevent pi from detecting it's inside another agent
-        delete env.CLAUDECODE;
-        delete env.CLAUDE_CODE;
-        const child = spawn("pi", [
-            "--print", task,
-            "--append-system-prompt", appendPrompt,
-            "--no-session", // Ephemeral — no lock files, no session state
-        ], {
-            cwd: projectRoot,
-            stdio: "inherit",
-            env,
-        });
-        child.on("error", (error) => {
-            console.error(chalk.red(`  PP: Failed to start pi: ${error.message}`));
-            resolve();
+    const fullTask = task + ppGuardrails;
+    // API-based runtime: zero memory churn. No process spawning.
+    // Falls back to claude CLI spawn only if ANTHROPIC_API_KEY is missing.
+    if ((process.env.ANTHROPIC_API_KEY || process.env.OPENROUTER_API_KEY) && !process.env.JFL_AGENT_USE_SPAWN) {
+        console.log(chalk.cyan("  PP: Using API runtime (zero memory churn)"));
+        try {
+            const { runAgentViaAPI } = await import("../lib/agent-runtime-api.js");
+            await runAgentViaAPI({ task: fullTask, cwd: projectRoot, timeoutMs: 300_000 });
+            return;
+        }
+        catch (err) {
+            console.error(chalk.yellow(`  PP: API runtime failed: ${err.message} — falling back to spawn`));
+        }
+    }
+    // Legacy spawn fallback — each call creates a ~300MB process.
+    // macOS compresses dead pages, unreclaimable without reboot.
+    // Set ANTHROPIC_API_KEY to use API runtime instead.
+    const forceSpawnPi = !!process.env.JFL_AGENT_USE_PI;
+    if (forceSpawnPi) {
+        console.log(chalk.cyan("  PP: Using pi agent (heavy — JFL_AGENT_USE_PI=1)"));
+        await new Promise((resolve) => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.CLAUDE_CODE;
+            env.JFL_AGENT_MODE = "1";
+            env.JFL_PP_SPAWNED = "1";
+            const child = spawn("pi", [
+                "--print", fullTask,
+                "--no-session",
+                "--no-skills",
+                "--no-prompt-templates",
+                "--no-themes",
+            ], {
+                cwd: projectRoot,
+                stdio: "inherit",
+                env,
+            });
+            child.on("error", (error) => {
+                console.error(chalk.red(`  PP: Failed to start pi: ${error.message}`));
+                resolve();
+            });
+            child.on("exit", () => {
+                resolve();
+            });
         });
-        child.on("exit", () => {
-            resolve();
+    }
+    else {
+        console.log(chalk.yellow("  PP: Using claude CLI spawn (⚠ memory churn — set ANTHROPIC_API_KEY for API runtime)"));
+        await new Promise((resolve) => {
+            const env = { ...process.env };
+            delete env.CLAUDECODE;
+            delete env.CLAUDE_CODE;
+            const child = spawn("claude", [
+                "--dangerously-skip-permissions",
+                "-p", fullTask,
+                "--output-format", "text",
+            ], {
+                cwd: projectRoot,
+                stdio: "inherit",
+                env,
+            });
+            child.on("error", (error) => {
+                console.error(chalk.red(`  PP: Failed to start claude: ${error.message}`));
+                resolve();
+            });
+            child.on("exit", () => {
+                resolve();
+            });
         });
-    });
+    }
 }
 /**
  * Run an agent task using ralph-tui (legacy fallback).
@@ -1729,6 +1768,31 @@ async function agentRun(projectRoot, agentName, roundsOverride) {
         console.log();
         return;
     }
+    // Pre-flight guards — verify environment before starting session
+    const { runGuards } = await import("../lib/agent-guards.js");
+    const guardSummary = await runGuards(projectRoot, agentName, config);
+    // Log guard results
+    for (const result of guardSummary.results) {
+        if (result.passed) {
+            console.log(chalk.green(`  ✓ Guard: ${result.name}`));
+        }
+        else if (result.critical) {
+            console.log(chalk.red(`  ✗ Guard: ${result.name} — ${result.reason}`));
+        }
+        else {
+            console.log(chalk.yellow(`  ⚠ Guard: ${result.name} — ${result.reason}`));
+        }
+    }
+    if (!guardSummary.proceed) {
+        console.log(chalk.red(`\n  Blocked by ${guardSummary.blockers.length} critical guard(s). Fix the issues above and retry.\n`));
+        return;
+    }
+    if (guardSummary.warnings.length > 0) {
+        console.log(chalk.yellow(`\n  ${guardSummary.warnings.length} warning(s) — proceeding anyway.\n`));
+    }
+    else {
+        console.log();
+    }
     // Use config.rounds as default (Karpathy: ~50 experiments per session)
     // Allow override via CLI for debugging/testing
     const rounds = roundsOverride ?? config.rounds ?? 50;
@@ -1905,6 +1969,19 @@ Based on the failing queries/tests and the actual code, suggest ONE concrete cha
     }
     // End session
     const summary = await endSession(session, transitions);
+    // Post eval:scored to hub event bus — triggers auto-merge, flag-regression, training flows
+    await postHubEvent(projectRoot, "eval:scored", {
+        agent: agentName,
+        metric: config.metric,
+        baseline: (summary.baseline).toFixed(4),
+        composite: (summary.finalMetric).toFixed(4),
+        delta: summary.totalDelta.toFixed(4),
+        improved: String(summary.improvedRounds > 0),
+        rounds: summary.rounds,
+        kept: summary.improvedRounds,
+        branch: session.branch,
+        pr_number: summary.prUrl ? summary.prUrl.split("/").pop() : "",
+    });
     console.log(chalk.bold(`\n  ── Session Complete ${"─".repeat(35)}\n`));
     console.log(chalk.gray(`  Rounds: ${summary.rounds}`));
     console.log(chalk.gray(`  Improved: ${summary.improvedRounds}`));