jfl 0.9.1 → 0.9.2

package/packages/pi/extensions/peter-parker.ts

@@ -12,6 +12,7 @@ import { spawn } from "child_process"
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
 import { emitCustomEvent, hubUrl, authToken } from "./map-bridge.js"
 
 interface ReviewTask {
@@ -38,7 +39,7 @@ let activeIterations = new Map<string, PeterIteration>()
 async function getPredictor(root: string) {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { Predictor } = await import("../../src/lib/predictor.js")
+    const { Predictor } = await jflImport("predictor")
     return new Predictor(root)
   } catch {
     return null

package/packages/pi/extensions/policy-head-tool.ts

@@ -14,6 +14,7 @@
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
 import { emitCustomEvent } from "./map-bridge.js"
 
 let projectRoot = ""
@@ -40,7 +41,7 @@ function getWeightsInfo(): PolicyWeights | null {
 async function getPolicyHead(): Promise<any> {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { PolicyHeadInference } = await import("../../src/lib/policy-head.js")
+    const { PolicyHeadInference } = await jflImport("policy-head")
     return new PolicyHeadInference(projectRoot)
   } catch {
     return null
@@ -50,7 +51,7 @@ async function getPolicyHead(): Promise<any> {
 async function getTrainingBuffer(): Promise<any> {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { TrainingBuffer } = await import("../../src/lib/training-buffer.js")
+    const { TrainingBuffer } = await jflImport("training-buffer")
     return new TrainingBuffer(projectRoot)
   } catch {
     return null

package/packages/pi/extensions/portfolio-bridge.ts

@@ -11,6 +11,7 @@ import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig } from "./types.js"
 import { emitCustomEvent } from "./map-bridge.js"
+import { jflImport } from "./jfl-resolve.js"
 
 let projectRoot = ""
 let portfolioParent: string | null = null
@@ -19,8 +20,7 @@ async function phoneHome(ctx: PiContext): Promise<void> {
   if (!portfolioParent || !existsSync(portfolioParent)) return
 
   try {
-    // @ts-ignore — resolved from jfl package at runtime
-    const { phoneHomeToPortfolio } = await import("../../src/lib/service-gtm.js")
+    const { phoneHomeToPortfolio } = await jflImport("service-gtm")
     await phoneHomeToPortfolio(projectRoot)
     ctx.log("Portfolio phoneHome complete", "debug")
   } catch (err) {
@@ -32,8 +32,7 @@ async function syncJournalEntry(ctx: PiContext, entry: unknown): Promise<void> {
   if (!portfolioParent || !existsSync(portfolioParent)) return
 
   try {
-    // @ts-ignore — resolved from jfl package at runtime
-    const { writeSyncToParent } = await import("../../src/lib/service-gtm.js")
+    const { writeSyncToParent } = await jflImport("service-gtm")
     await (writeSyncToParent as (root: string, entry: unknown) => Promise<void>)(projectRoot, entry)
   } catch (err) {
     ctx.log(`Journal sync to parent failed: ${err}`, "debug")

package/packages/pi/extensions/session.ts

@@ -41,7 +41,7 @@ export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<
         ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
       },
       body: JSON.stringify({ runtime: "pi" }),
-      signal: AbortSignal.timeout(90000),
+      signal: AbortSignal.timeout(30000),
     })
 
     if (resp.ok) {
@@ -55,12 +55,16 @@ export async function setupSession(ctx: PiContext, _config: JflConfig): Promise<
       }
       ctx.log(`Session init via Hub: branch=${sessionBranch}, sync=${data.syncOk}`, "debug")
     } else {
-      ctx.log("Hub session init failed, falling back to local", "warn")
+      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
     }
-  } catch {
+  } catch (err) {
     // Hub not available — fall back to local branch detection
-    ctx.log("Hub unavailable for session init, using local branch", "debug")
+    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
   }
 
@@ -148,14 +152,38 @@ export async function pivot(ctx: PiContext, summary?: string): Promise<{
 
 export async function onShutdown(ctx: PiContext): Promise<void> {
   const root = ctx.session.projectRoot
+  const branch = getSessionBranch() || getCurrentBranch(root)
+
+  ctx.ui.notify("Shutting down session…", { level: "info" })
+
+  // ── 1. Journal check (parity with CC Stop hook) ──────────────────────
+  const journalPath = join(root, ".jfl", "journal", `${branch}.jsonl`)
+  const hasJournal = existsSync(journalPath) && readFileSync(journalPath, "utf-8").trim().length > 0
+  if (!hasJournal) {
+    ctx.ui.notify(
+      "⚠️  No journal entry for this session. Context will be lost.\n" +
+      `   File: .jfl/journal/${branch}.jsonl`,
+      { level: "warn" }
+    )
+  }
 
-  // Kill auto-commit daemon
+  // ── 2. Kill auto-commit daemon ───────────────────────────────────────
   if (autoCommitProcess) {
     try { autoCommitProcess.kill() } catch {}
     autoCommitProcess = null
+    ctx.ui.notify("  ✓ Auto-commit stopped", { level: "info" })
   }
 
-  // Call Hub session end — handles journal check + cleanup
+  // ── 3. Auto-commit any uncommitted changes ───────────────────────────
+  try {
+    const status = execSync("git status --porcelain", { cwd: root, timeout: 3000, encoding: "utf-8" }).trim()
+    if (status) {
+      execSync("git add -A && git commit -m 'auto: session-end save'", { cwd: root, timeout: 5000, stdio: "pipe" })
+      ctx.ui.notify("  ✓ Uncommitted changes saved", { level: "info" })
+    }
+  } catch {}
+
+  // ── 4. Call Hub session end ──────────────────────────────────────────
   try {
     await fetch(`${hubUrl}/api/session/end`, {
       method: "POST",
@@ -164,24 +192,72 @@ export async function onShutdown(ctx: PiContext): Promise<void> {
         ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
       },
       body: JSON.stringify({ runtime: "pi" }),
-      signal: AbortSignal.timeout(90000),
+      signal: AbortSignal.timeout(5000),
     })
-    ctx.log("Session ended via Hub", "debug")
+    ctx.ui.notify("  ✓ Hub session closed", { level: "info" })
   } catch {
-    // Fallback: run cleanup script directly
-    const cleanupScript = findScript(root, "session-cleanup.sh")
-    if (cleanupScript) {
+    ctx.log("Hub session end failed — running local cleanup", "debug")
+  }
+
+  // ── 5. Merge session branch back (parity with CC session-cleanup.sh) ─
+  if (branch.startsWith("session-")) {
+    try {
+      // Get working branch from config or default to main
+      let workingBranch = "main"
+      const configPath = join(root, ".jfl", "config.json")
+      if (existsSync(configPath)) {
+        try {
+          const config = JSON.parse(readFileSync(configPath, "utf-8"))
+          if (config.working_branch) workingBranch = config.working_branch
+        } catch {}
+      }
+
+      // Push session branch first
+      try {
+        execSync(`git push origin ${branch}`, { cwd: root, timeout: 15000, stdio: "pipe" })
+        ctx.ui.notify("  ✓ Session branch pushed", { level: "info" })
+      } catch {}
+
+      // Merge session into working branch
+      execSync(`git checkout ${workingBranch}`, { cwd: root, timeout: 5000, stdio: "pipe" })
+      execSync(`git merge ${branch} --no-edit`, { cwd: root, timeout: 10000, stdio: "pipe" })
+      ctx.ui.notify(`  ✓ Merged ${branch} → ${workingBranch}`, { level: "info" })
+
+      // Push merged working branch
       try {
-        execSync(`bash "${cleanupScript}"`, { cwd: root, stdio: "inherit" })
-      } catch (err) {
-        ctx.log(`session-cleanup.sh failed: ${err}`, "warn")
+        execSync(`git push origin ${workingBranch}`, { cwd: root, timeout: 15000, stdio: "pipe" })
+      } catch {}
+
+      // Delete session branch (local + remote)
+      try {
+        execSync(`git branch -d ${branch}`, { cwd: root, timeout: 5000, stdio: "pipe" })
+        execSync(`git push origin --delete ${branch}`, { cwd: root, timeout: 10000, stdio: "pipe" })
+        ctx.ui.notify("  ✓ Session branch cleaned up", { level: "info" })
+      } catch {}
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      if (msg.includes("CONFLICT") || msg.includes("conflict")) {
+        ctx.ui.notify(`  ⚠ Merge conflict — session branch ${branch} preserved`, { level: "warn" })
+        // Switch back to session branch so user can resolve
+        try { execSync(`git checkout ${branch}`, { cwd: root, timeout: 5000, stdio: "pipe" }) } catch {}
+      } else {
+        ctx.ui.notify(`  ⚠ Branch merge failed: ${msg.slice(0, 80)}`, { level: "warn" })
       }
     }
   }
 
+  // ── 6. Fallback cleanup script ───────────────────────────────────────
+  const cleanupScript = findScript(root, "session-cleanup.sh")
+  if (cleanupScript && !branch.startsWith("session-")) {
+    // Only run cleanup script if we didn't already handle merge above
+    try {
+      execSync(`bash "${cleanupScript}"`, { cwd: root, timeout: 10000, stdio: "pipe" })
+    } catch {}
+  }
+
   ctx.emit("hook:session-end", {
     session: ctx.session.id,
-    branch: ctx.session.branch,
+    branch,
     ts: new Date().toISOString(),
   })
 }

package/packages/pi/extensions/stratus-bridge.ts

@@ -11,6 +11,7 @@ import { existsSync, appendFileSync, mkdirSync } from "fs"
 import { join } from "path"
 import { homedir } from "os"
 import type { PiContext, AgentStartEvent, AgentEndEvent } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
 import { emitCustomEvent } from "./map-bridge.js"
 
 const TRAINING_BUFFER = join(homedir(), ".jfl", "training-buffer.jsonl")
@@ -30,7 +31,7 @@ function getTrainingBufferPath(): string {
 async function getPredictor(root: string) {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { Predictor } = await import("../../src/lib/predictor.js")
+    const { Predictor } = await jflImport("predictor")
     return new Predictor(root)
   } catch {
     return null

package/packages/pi/extensions/synopsis-tool.ts

@@ -48,7 +48,12 @@ export function setupSynopsisTool(ctx: PiContext): void {
       },
     },
     async handler(input) {
-      const { hours, author } = input as { hours?: number; author?: string }
+      const raw = input as { hours?: number | string; author?: string }
+      // Model sometimes passes "24h" or "48h" — strip the 'h' and parse
+      const hours = typeof raw.hours === "string"
+        ? parseInt(String(raw.hours).replace(/[^0-9]/g, ""), 10) || 24
+        : raw.hours
+      const author = raw.author
 
       const synopsisScript = findSynopsisScript(projectRoot)
       if (synopsisScript) {

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

@@ -14,6 +14,7 @@
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
 import type { PiContext, JflConfig, AgentEndEvent } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
 import { emitCustomEvent } from "./map-bridge.js"
 
 let projectRoot = ""
@@ -21,7 +22,7 @@ let projectRoot = ""
 async function getTrainingBuffer(): Promise<any> {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { TrainingBuffer } = await import("../../src/lib/training-buffer.js")
+    const { TrainingBuffer } = await jflImport("training-buffer")
     return new TrainingBuffer(projectRoot)
   } catch {
     return null
@@ -31,7 +32,7 @@ async function getTrainingBuffer(): Promise<any> {
 async function getTupleMiner(): Promise<any> {
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    return await import("../../src/lib/tuple-miner.js")
+    return await jflImport("tuple-miner")
   } catch {
     return null
   }

package/packages/pi/extensions/types.ts

@@ -115,6 +115,8 @@ export interface AgentEndEvent {
 export interface ToolExecutionEvent {
   toolName?: string
   tool?: string
+  input?: Record<string, any>
+  args?: Record<string, any>
   result?: unknown
   isError?: boolean
   duration?: number

package/packages/pi/package.json

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

package/packages/pi/skills/viz/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: viz
+description: Terminal data visualization via kuva — inline plots for agents and humans
+---
+
+# /viz — Terminal Visualization
+
+Pipe JFL data to kuva for inline terminal plots. Agents see results without leaving flow.
+
+## Prerequisites
+
+```bash
+cargo install kuva --features cli
+```
+
+If kuva is not installed, falls back to ASCII bar/sparkline rendering.
+
+## Commands
+
+```
+/viz events      # Event bus activity (bar chart by type, sankey of service flows)
+/viz sessions    # Session activity (line chart over time, duration box plot)
+/viz costs       # API costs (bar by model, pie by provider)
+/viz tools       # Tool usage frequency (bar chart)
+/viz flows       # Flow trigger rates (bar chart, sankey of trigger→action)
+/viz arena       # Arena leaderboard (composite bar chart, score trajectory)
+/viz learning    # Pattern confidence trends (line chart)
+/viz health      # Service health dashboard (cost sparklines, error bars, latency box)
+/viz <custom>    # Describe what you want to visualize
+```
+
+## How It Works
+
+Each `/viz` command:
+1. Reads the relevant data source (events, journals, telemetry, arena results)
+2. Transforms to TSV format
+3. Pipes to `kuva [plot-type] --terminal`
+4. Renders inline in the terminal
+
+## Implementation
+
+### /viz events
+
+Read `.jfl/service-events.jsonl` and `.jfl/map-events.jsonl`:
+
+```bash
+# Event type distribution
+cat .jfl/service-events.jsonl | \
+  jq -r '.type' | sort | uniq -c | sort -rn | \
+  awk '{print $2"\t"$1}' | \
+  kuva bar --label-col 0 --value-col 1 --title "Events by Type" --terminal
+
+# Service-to-service flow (sankey)
+cat .jfl/service-events.jsonl | \
+  jq -r '[.source // "unknown", .type, 1] | @tsv' | \
+  kuva sankey --source-col 0 --target-col 1 --value-col 2 --title "Event Flows" --terminal
+```
+
+Or use the programmatic API from `jfl-cli/src/lib/kuva.ts`:
+
+```typescript
+import { barChart, linePlot, sparkline } from 'jfl-cli/src/lib/kuva.js'
+
+const events = loadEvents()
+const byType = countBy(events, 'type')
+const chart = barChart(
+  Object.entries(byType).map(([label, value]) => ({ label, value })),
+  'Events by Type'
+)
+console.log(chart)
+```
+
+### /viz sessions
+
+```bash
+# Sessions over time (line)
+cat .jfl/journal/*.jsonl | \
+  jq -r 'select(.type == "session-end") | [.ts[:10], 1] | @tsv' | \
+  sort | uniq -c | awk '{print $2"\t"$1}' | \
+  kuva line --x 0 --y 1 --title "Sessions per Day" --terminal
+```
+
+### /viz costs
+
+```bash
+# Cost by model (bar)
+cat .jfl/telemetry-queue.jsonl | \
+  jq -r 'select(.event == "stratus:api_call") | [(.model_name // "unknown"), .estimated_cost_usd] | @tsv' | \
+  kuva bar --label-col 0 --value-col 1 --title "Cost by Model" --terminal
+```
+
+### /viz arena
+
+```bash
+# Run from arena directory
+cd /path/to/productrank-arena
+npm run arena -- leaderboard --all --plots
+```
+
+Or programmatically — arena's `formatLeaderboardPlots()` renders composite scores as kuva bar chart.
+
+### /viz flows
+
+```bash
+# Flow triggers (bar)
+cat .jfl/service-events.jsonl | \
+  jq -r 'select(.type == "flow:triggered") | .data.flow_name' | \
+  sort | uniq -c | sort -rn | awk '{print $2"\t"$1}' | \
+  kuva bar --label-col 0 --value-col 1 --title "Flow Triggers" --terminal
+
+# Flow trigger→action sankey
+cat .jfl/service-events.jsonl | \
+  jq -r 'select(.type == "flow:completed") | [.data.flow_name, .data.action_type, 1] | @tsv' | \
+  kuva sankey --source-col 0 --target-col 1 --value-col 2 --title "Flow Actions" --terminal
+```
+
+### /viz health
+
+Composite dashboard — renders multiple charts:
+
+```
+  Health Dashboard
+  ━━━━━━━━━━━━━━━━
+
+  API Costs (last 24h)
+  [kuva bar: cost by model]
+
+  Error Rate ▁▂▁▁▃▅▂▁▁▁  (sparkline)
+
+  Latency Distribution
+  [kuva box: latency by endpoint]
+
+  Session Duration
+  [kuva box: duration by session]
+```
+
+### /viz learning (RL / Training)
+
+For agents with reinforcement learning loops:
+
+```typescript
+// After each training epoch
+const rewards = epochs.map((e, i) => ({ ts: `epoch-${i}`, value: e.reward }))
+const chart = linePlot(rewards, 'Reward per Epoch')
+console.log(chart)
+
+// Action distribution
+const actions = countBy(episodes, 'action')
+const actionChart = barChart(
+  Object.entries(actions).map(([label, value]) => ({ label, value })),
+  'Action Frequency'
+)
+console.log(actionChart)
+```
+
+### /viz custom
+
+When user describes what they want to visualize, the agent:
+1. Identifies the data source
+2. Extracts/transforms to TSV
+3. Picks the right kuva plot type
+4. Renders with `--terminal`
+
+## Available Plot Types
+
+| kuva command | Best for | Key flags |
+|-------------|----------|-----------|
+| `bar` | Categorical comparisons | `--label-col`, `--value-col` |
+| `line` | Time series, trends | `--x`, `--y`, `--color-by` |
+| `scatter` | Correlations, clustering | `--x`, `--y`, `--color-by` |
+| `box` | Distributions, outliers | `--group-col`, `--value-col` |
+| `histogram` | Value distributions | `--value-col`, `--bins` |
+| `pie` | Proportions | `--label-col`, `--value-col`, `--donut` |
+| `sankey` | Flow routing, transitions | `--source-col`, `--target-col`, `--value-col` |
+| `heatmap` | Matrix data, correlations | First col = row labels |
+| `violin` | Distribution shape | `--group-col`, `--value-col` |
+
+## Design Principles
+
+1. **TSV is the universal interface** — any data source that can produce rows can generate kuva plots
+2. **Graceful degradation** — ASCII fallback (bars, sparklines) when kuva isn't installed
+3. **Agent-native** — inline terminal output, no browser needed, no context-switching
+4. **Composable** — pipe any JSONL through `jq -r @tsv` into kuva. Unix philosophy.
+5. **Zero coupling** — kuva is a standalone Rust binary. kuva.ts is a standalone module. Neither needs the other's internals.
+
+## Examples
+
+```
+User: "show me event activity"
+Agent: *runs /viz events*
+→ Bar chart of event types + sankey of service flows
+
+User: "what's our cost breakdown?"
+Agent: *runs /viz costs*
+→ Bar chart by model + pie chart by provider
+
+User: "how is the arena looking?"
+Agent: *runs /viz arena*
+→ Leaderboard table + composite score bar chart
+
+User: "plot my training rewards"
+Agent: *runs /viz learning with user's data*
+→ Line chart of reward per epoch + action frequency bars
+```