jfl 0.9.6 → 0.9.8

package/packages/pi/extensions/session.ts

@@ -10,7 +10,7 @@
  */
 
 import { execSync, spawn } from "child_process"
-import { existsSync, readFileSync } from "fs"
+import { existsSync, readFileSync, writeFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig } from "./types.js"
 import { hubUrl, authToken } from "./map-bridge.js"
@@ -18,6 +18,104 @@ import { hubUrl, authToken } from "./map-bridge.js"
 let autoCommitProcess: ReturnType<typeof spawn> | null = null
 let sessionBranch = ""
 
+/**
+ * Create a session branch locally without the Hub.
+ * Parity with scripts/session/session-init.sh:
+ * 1. Commit or stash dirty state
+ * 2. If on a stale session branch, try to switch to working branch
+ * 3. Create new session branch from clean base
+ * 4. Pop stash if needed
+ */
+function createSessionBranchLocally(root: string, ctx: { log: (msg: string, level?: "debug" | "info" | "warn" | "error") => void; ui: { notify: (msg: string, opts?: any) => void } }): string {
+  // Generate session branch name
+  const user = (() => {
+    try {
+      return execSync("git config user.name", { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+        .toString().trim().replace(/\s+/g, "-").toLowerCase().replace(/[^a-z0-9-]/g, "").slice(0, 30) || "user"
+    } catch { return "user" }
+  })()
+  const now = new Date()
+  const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "")
+  const timeStr = now.toISOString().slice(11, 16).replace(":", "")
+  const randomId = Math.random().toString(16).slice(2, 8)
+  const branchName = `session-${user}-${dateStr}-${timeStr}-${randomId}`
+
+  // Get working branch from config
+  let workingBranch = "main"
+  const configPath = join(root, ".jfl", "config.json")
+  if (existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(configPath, "utf-8"))
+      if (cfg.working_branch) workingBranch = cfg.working_branch
+    } catch {}
+  }
+
+  // Step 1: Commit or stash dirty state so checkout doesn't fail
+  let stashed = false
+  try {
+    const status = execSync("git status --porcelain", { cwd: root, timeout: 5000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim()
+    if (status) {
+      try {
+        execSync("git add -A && git commit -m 'auto: session-init save before branch switch' --no-verify", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+      } catch {
+        // Commit failed — stash instead
+        try {
+          execSync("git stash push -m 'jfl-session-init-stash' --include-untracked", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+          stashed = true
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // Step 2: If on a stale session branch, try to switch to working branch
+  const currentBranch = getCurrentBranch(root)
+  if (currentBranch.startsWith("session-")) {
+    try {
+      execSync(`git checkout "${workingBranch}"`, { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+      ctx.log(`Switched from stale session branch ${currentBranch} → ${workingBranch}`, "info")
+    } catch {
+      ctx.log(`Could not switch from ${currentBranch} — branching from it`, "warn")
+    }
+  }
+
+  // Step 3: Create new session branch
+  let finalBranch = branchName
+  try {
+    execSync(`git checkout -b "${branchName}"`, { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+    ctx.ui.notify(`Session branch: ${branchName}`, { level: "info" })
+  } catch {
+    // Branch name collision — retry with longer ID
+    const fallbackId = Math.random().toString(16).slice(2, 14)
+    const fallbackBranch = `session-${user}-${dateStr}-${timeStr}-${fallbackId}`
+    try {
+      execSync(`git checkout -b "${fallbackBranch}"`, { cwd: root, stdio: ["pipe", "pipe", "pipe"] })
+      finalBranch = fallbackBranch
+    } catch {
+      // Give up — use current branch
+      finalBranch = getCurrentBranch(root)
+      ctx.log(`Could not create session branch — using ${finalBranch}`, "warn")
+      ctx.ui.notify(`Branch creation failed — using ${finalBranch}`, { level: "warn" })
+    }
+  }
+
+  // Step 4: Pop stash if we stashed
+  if (stashed) {
+    try {
+      execSync("git stash pop", { cwd: root, timeout: 10000, stdio: ["pipe", "pipe", "pipe"] })
+    } catch {
+      ctx.log("Could not pop stash — run 'git stash pop' manually", "warn")
+    }
+  }
+
+  // Save session info
+  try {
+    const jflDir = join(root, ".jfl")
+    writeFileSync(join(jflDir, "current-session-branch.txt"), finalBranch)
+  } catch {}
+
+  return finalBranch
+}
+
 function findScript(root: string, scriptName: string): string | null {
   const candidates = [
     join(root, "scripts", "session", scriptName),
@@ -46,26 +144,35 @@ export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<
 
     if (resp.ok) {
       const data = await resp.json() as { branch?: string; syncOk?: boolean; warnings?: string[]; doctor?: { errors: number; warnings: number } }
-      sessionBranch = data.branch ?? ctx.session.branch
       if (data.warnings?.length) {
         for (const w of data.warnings) ctx.log(w, "warn")
       }
       if (data.doctor?.errors) {
         ctx.ui.notify(`Doctor: ${data.doctor.errors} errors`, { level: "warn" })
       }
-      ctx.log(`Session init via Hub: branch=${sessionBranch}, sync=${data.syncOk}`, "debug")
+
+      // Hub may return 200 OK but fail to create a branch (dirty state, etc).
+      // If branch is missing or is the working branch (main), fall back to local creation.
+      const hubBranch = data.branch ?? ""
+      if (hubBranch.startsWith("session-")) {
+        sessionBranch = hubBranch
+        ctx.log(`Session init via Hub: branch=${sessionBranch}, sync=${data.syncOk}`, "debug")
+      } else {
+        ctx.log(`Hub returned non-session branch "${hubBranch}" — creating locally`, "warn")
+        sessionBranch = createSessionBranchLocally(root, ctx)
+      }
     } else {
       const errText = await resp.text().catch(() => "unknown")
       ctx.log(`Hub session init failed (${resp.status}): ${errText}`, "warn")
-      ctx.ui.notify("Session init failed — working on current branch", { level: "warn" })
-      sessionBranch = ctx.session.branch
+      sessionBranch = createSessionBranchLocally(root, ctx)
     }
   } catch (err) {
-    // Hub not available — fall back to local branch detection
+    // Hub not available — create session branch locally (parity with session-init.sh)
     const msg = err instanceof Error ? err.message : String(err)
     ctx.log(`Hub unavailable for session init: ${msg}`, "warn")
-    ctx.ui.notify(`Hub unreachable (${hubUrl}) — no session branch created`, { level: "warn" })
-    sessionBranch = ctx.session.branch
+    ctx.ui.notify(`Hub unreachable — creating session branch locally`, { level: "warn" })
+
+    sessionBranch = createSessionBranchLocally(root, ctx)
   }
 
   // Start auto-commit daemon — must be local (detached process)

package/packages/pi/extensions/training-buffer-tool.ts

@@ -317,18 +317,23 @@ export async function onTrainingAgentEnd(
   event: AgentEndEvent
 ): Promise<void> {
   const turnCount = event.messages?.length ?? event.turnCount ?? 0
-  if (turnCount < 2) return
+  // Only log tuples when actual work happened (files changed).
+  // Previously this logged every session as "improved" with a fake +0.01 delta,
+  // polluting the training buffer with 187+ garbage noops.
+  const filesChanged = event.filesChanged || []
+  if (turnCount < 2 || filesChanged.length === 0) return
 
   const tb = await getTrainingBuffer()
   if (!tb) return
 
   const existing: any[] = tb.read()
-  const recentDeltas = existing.slice(-10).map((e: any) => e.reward.composite_delta)
-  const currentScore = existing.length > 0
-    ? existing[existing.length - 1].state.composite_score + existing[existing.length - 1].reward.composite_delta
+  // Safe access — reward or composite_delta may be missing on older entries
+  const recentDeltas = existing.slice(-10).map((e: any) => e.reward?.composite_delta ?? 0)
+  const lastEntry = existing.length > 0 ? existing[existing.length - 1] : null
+  const currentScore = lastEntry
+    ? (lastEntry.state?.composite_score ?? 0) + (lastEntry.reward?.composite_delta ?? 0)
     : 0
 
-  const filesChanged = event.filesChanged || []
   const exitReason = event.exitReason as string | undefined
   const isSuccess = exitReason !== "error" && exitReason !== "timeout"
 
@@ -353,11 +358,13 @@ export async function onTrainingAgentEnd(
       branch: ctx.session.branch,
     },
     reward: {
-      composite_delta: isSuccess ? 0.01 : -0.005,
+      // Don't fabricate deltas — use 0 to indicate "no eval ran".
+      // Real deltas come from the RL agent loop (peter daily), not session logging.
+      composite_delta: 0,
       dimension_deltas: {},
       tests_added: 0,
-      quality_score: isSuccess ? 0.7 : 0.3,
-      improved: isSuccess,
+      quality_score: isSuccess ? 0.5 : 0.3,
+      improved: false,  // Only the RL eval loop can determine improvement
     },
     metadata: {
       branch: ctx.session.branch,

package/packages/pi/extensions/types.ts

@@ -162,6 +162,7 @@ export interface JflConfig {
     disable_shortcuts?: boolean
     disable_notifications?: boolean
     disable_onboarding?: boolean
+    disable_briefing?: boolean
     onboarding_variant?: "v1" | "v2" | "v3"
     auto_start?: boolean
   }

package/packages/pi/package.json

@@ -37,9 +37,8 @@
     "typescript": "^5.3.3"
   },
   "pi": {
-
-    "entry": "dist/index.js",
-    "extensions": ["dist/index.js"],
+    "entry": "extensions/index.ts",
+    "extensions": ["extensions/index.ts"],
     "skills": "skills",
     "themes": "themes/jfl.theme.json",
     "teams": "teams"

package/scripts/postinstall.js

@@ -13,6 +13,13 @@ import { execSync, spawnSync } from "child_process";
 import { platform } from "os";
 
 const TOOLS = [
+  {
+    name: "pi",
+    package: "@mariozechner/pi-coding-agent",
+    description: "Pi coding agent runtime",
+    requiresBun: false,
+    minVersion: "0.57.0",
+  },
   {
     name: "ralph-tui",
     package: "ralph-tui",
@@ -50,6 +57,36 @@ function installWithBun(pkg) {
   }
 }
 
+function installWithNpm(pkg) {
+  try {
+    console.log(`  Installing ${pkg}...`);
+    execSync(`npm install -g ${pkg}`, { stdio: "inherit" });
+    return true;
+  } catch (error) {
+    console.error(`  Failed to install ${pkg}: ${error.message}`);
+    return false;
+  }
+}
+
+function getInstalledVersion(cmd) {
+  try {
+    return execSync(`${cmd} --version`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function isVersionSufficient(installed, minimum) {
+  if (!installed || !minimum) return true;
+  const iParts = installed.split(".").map(Number);
+  const mParts = minimum.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((iParts[i] || 0) > (mParts[i] || 0)) return true;
+    if ((iParts[i] || 0) < (mParts[i] || 0)) return false;
+  }
+  return true; // equal
+}
+
 function main() {
   console.log("\n🚀 JFL CLI - Setting up bundled tools...\n");
 
@@ -81,15 +118,23 @@ function main() {
 
     // Check if already installed
     if (hasCommand(tool.name)) {
-      console.log(`✅ ${tool.name} already installed`);
-      continue;
+      const version = getInstalledVersion(tool.name);
+      if (tool.minVersion && version && !isVersionSufficient(version, tool.minVersion)) {
+        console.log(`⬆️  ${tool.name} v${version} → updating (min: ${tool.minVersion})`);
+      } else {
+        console.log(`✅ ${tool.name} already installed${version ? ` (v${version})` : ""}`);
+        continue;
+      }
     }
 
     console.log(`📦 Installing ${tool.name} - ${tool.description}`);
-    const success = installWithBun(tool.package);
+    const success = tool.requiresBun
+      ? installWithBun(tool.package)
+      : installWithNpm(tool.package);
 
     if (success) {
-      console.log(`✅ ${tool.name} installed successfully\n`);
+      const version = getInstalledVersion(tool.name);
+      console.log(`✅ ${tool.name} installed${version ? ` (v${version})` : ""}\n`);
     } else {
       console.log(`⚠️  ${tool.name} installation failed (optional)\n`);
     }
@@ -98,6 +143,9 @@ function main() {
   console.log("🎉 JFL CLI setup complete!\n");
   console.log("Available tools:");
   console.log("  jfl          - Main CLI");
+  if (hasCommand("pi")) {
+    console.log("  pi           - Coding agent runtime");
+  }
   if (hasCommand("ralph-tui")) {
     console.log("  ralph-tui    - AI agent loop orchestrator");
   }