jfl 0.9.1 → 0.9.3

package/packages/pi/extensions/context.ts

@@ -1,11 +1,12 @@
 /**
  * Context Extension
  *
- * Ensures Context Hub is running, injects CLAUDE.md + recent context before
- * each agent turn via POST /api/prompt, and registers the jfl_context tool.
- * Hub is the single source of truth — no local CLAUDE.md reading.
+ * Ensures Context Hub is running and registers the jfl_context tool.
+ * On first turn, injects a small amount of recent journal context so
+ * the model's greeting is contextual. The model reads CLAUDE.md itself
+ * via AGENTS.md instructions — no 45K system prompt injection needed.
  *
- * @purpose Context Hub + system prompt injection via Hub API (parity with Claude Code)
+ * @purpose Context Hub startup + jfl_context tool registration
  */
 
 import { existsSync, readFileSync } from "fs"
@@ -18,7 +19,11 @@ import { readHubUrl, readToken } from "./hub-resolver.js"
 let hubBaseUrl = "http://localhost:4242"
 let hubToken: string | null = null
 let projectRoot = ""
-let cachedPrompt: string | null = null
+let promptInjected = false
+
+export function resetPromptInjected(): void {
+  promptInjected = false
+}
 
 function refreshHubUrl(): void {
   hubBaseUrl = readHubUrl(projectRoot)
@@ -28,10 +33,6 @@ function refreshHubUrl(): void {
 async function fetchContext(query?: string, limit = 10): Promise<string> {
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const params = new URLSearchParams()
-      if (query) params.set("query", query)
-      params.set("limit", String(limit))
-
       const body: Record<string, unknown> = { maxItems: limit }
       if (query) body.query = query
 
@@ -67,81 +68,12 @@ async function fetchContext(query?: string, limit = 10): Promise<string> {
   return ""
 }
 
-/**
- * Strip Claude-Code-specific instructions from CLAUDE.md prompt.
- * Pi handles these via extensions (session.ts, map-bridge.ts, journal.ts)
- * so the LLM shouldn't be told to do them manually.
- */
-function stripClaudeCodeInstructions(prompt: string): string {
-  let cleaned = prompt
-
-  // Strip "Session Sync" section — Pi's session.ts handles via Hub API
-  cleaned = cleaned.replace(
-    /## CRITICAL: Session Sync[\s\S]*?(?=\n## (?!.*Session Sync))/,
-    "## Session Management\n\nSession sync, doctor checks, and branch management are handled automatically by Pi extensions. No manual action needed.\n\n"
-  )
-
-  // Strip MCP tool references — Pi has native tools instead
-  cleaned = cleaned.replace(/Call:\s*mcp__jfl-context__\w+/g, "Use the jfl_context tool")
-  cleaned = cleaned.replace(/mcp__jfl-context__context_get/g, "jfl_context")
-  cleaned = cleaned.replace(/mcp__jfl-context__context_search/g, "jfl_context (with query)")
-  cleaned = cleaned.replace(/mcp__jfl-context__memory_search/g, "jfl_memory_search")
-
-  // Strip .claude/settings.json references — Pi uses extensions
-  cleaned = cleaned.replace(/Hooks in `\.claude\/settings\.json`[^\n]*/g, "Hooks are managed by Pi extensions automatically.")
-  cleaned = cleaned.replace(/`\.claude\/settings\.json`[^`\n]*hooks[^.\n]*/gi, "Pi extension hooks")
-
-  // Strip session-sync.sh and jfl-doctor.sh instructions — session.ts handles
-  cleaned = cleaned.replace(/\n.*session-sync\.sh.*/g, "")
-  cleaned = cleaned.replace(/\n.*jfl-doctor\.sh.*/g, "")
-  cleaned = cleaned.replace(/\.\/scripts\/session\/session-sync\.sh/g, "(handled automatically)")
-  cleaned = cleaned.replace(/\.\/scripts\/session\/jfl-doctor\.sh/g, "(handled automatically)")
-
-  // Strip "Path B" sections (Claude Code manual startup)
-  const pathBPatterns = [
-    /### Path B: Claude Code \/ No Extension[\s\S]*?(?=\n### (?!.*Path B))/,
-    /### How to Tell Which Path You're On[\s\S]*?(?=\n###? )/,
-  ]
-  for (const pattern of pathBPatterns) {
-    cleaned = cleaned.replace(pattern, "")
-  }
-
-  // Strip file structure references to .claude/
-  cleaned = cleaned.replace(/├── \.claude\/settings\.json[^\n]*/g, "")
-  cleaned = cleaned.replace(/- `\.claude\/settings\.json`[^\n]*/g, "")
-  cleaned = cleaned.replace(/- `\.claude\/skills\/`[^\n]*/g, "")
-
-  return cleaned
-}
-
-async function fetchPrompt(taskType?: string): Promise<string> {
-  try {
-    const resp = await fetch(`${hubBaseUrl}/api/prompt`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...(hubToken ? { Authorization: `Bearer ${hubToken}` } : {}),
-      },
-      body: JSON.stringify({ taskType: taskType ?? "general", maxItems: 20 }),
-      signal: AbortSignal.timeout(10000),
-    })
-
-    if (!resp.ok) return ""
-    const data = await resp.json() as { prompt?: string }
-    const raw = data.prompt ?? ""
-
-    // Clean CC-specific instructions — Pi handles these via extensions
-    return stripClaudeCodeInstructions(raw)
-  } catch {
-    return ""
-  }
-}
-
 export async function setupContext(ctx: PiContext, _config: JflConfig): Promise<void> {
   const root = ctx.session.projectRoot
   projectRoot = root
+  promptInjected = false // reset on each new session
 
-  // Start Context Hub FIRST, then read the port it wrote
+  // Start Context Hub
   try {
     execSync("jfl context-hub ensure", { cwd: root, stdio: "pipe", timeout: 15000 })
     ctx.log("Context Hub ensured", "debug")
@@ -150,15 +82,20 @@ export async function setupContext(ctx: PiContext, _config: JflConfig): Promise<
     ctx.log(`Context Hub ensure failed: ${msg}`, "debug")
   }
 
-  // Now read the port (hub may have written .jfl/context-hub.port during ensure)
+  // Read the port hub wrote
   hubBaseUrl = readHubUrl(root)
   hubToken = readToken(root)
   ctx.log(`Context Hub URL: ${hubBaseUrl}`, "debug")
 
-  // Pre-fetch prompt for first turn (cache it)
-  cachedPrompt = await fetchPrompt("general")
-  if (cachedPrompt) {
-    ctx.log(`System prompt loaded via Hub (${cachedPrompt.length} chars)`, "debug")
+  // Wait for hub to actually accept connections (startDaemon only waits 800ms —
+  // not enough for the HTTP server to bind. Without this, session/init races and
+  // falls back to ctx.session.branch = "main".)
+  for (let i = 0; i < 20; i++) {
+    try {
+      const resp = await fetch(`${hubBaseUrl}/health`, { signal: AbortSignal.timeout(500) })
+      if (resp.ok) { ctx.log("Context Hub ready", "debug"); break }
+    } catch {}
+    await new Promise(resolve => setTimeout(resolve, 300))
   }
 
   ctx.registerTool({
@@ -189,15 +126,7 @@ export async function setupContext(ctx: PiContext, _config: JflConfig): Promise<
       },
     },
     async handler(input) {
-      const { query, limit, taskType } = input as { query?: string; limit?: number; taskType?: string }
-
-      // If asking for general context with no query, use the prompt endpoint
-      if (!query && taskType) {
-        const prompt = await fetchPrompt(taskType)
-        return prompt || "No context available."
-      }
-
-      // Otherwise use the search endpoint
+      const { query, limit } = input as { query?: string; limit?: number; taskType?: string }
       const result = await fetchContext(query, limit ?? 30)
       return result || "No relevant context found."
     },
@@ -210,25 +139,20 @@ export async function injectContext(
   _ctx: PiContext,
   _event: AgentStartEvent
 ): Promise<{ systemPromptAddition?: string } | void> {
-  // Use cached prompt from setup, or fetch fresh
-  const prompt = cachedPrompt || await fetchPrompt("general")
-
-  // Clear cache after first use — subsequent turns get fresh context
-  cachedPrompt = null
-
-  if (!prompt) {
-    // Fallback: just inject recent context
-    const context = await fetchContext(undefined, 10)
-    if (!context) return
-    return {
-      systemPromptAddition: [
-        "## JFL Project Context",
-        "(Recent journal entries and project knowledge)",
-        "",
-        context,
-      ].join("\n"),
-    }
+  // Only on first turn — inject recent journal context so greeting is contextual.
+  // The model reads CLAUDE.md itself (AGENTS.md tells it to). No 45K dump needed.
+  if (promptInjected) return
+  promptInjected = true
+
+  const context = await fetchContext(undefined, 10)
+  if (!context) return
+
+  return {
+    systemPromptAddition: [
+      "## JFL Project Context",
+      "(Recent journal entries and project knowledge)",
+      "",
+      context,
+    ].join("\n"),
   }
-
-  return { systemPromptAddition: prompt }
 }

package/packages/pi/extensions/eval.ts

@@ -9,6 +9,7 @@
 
 import { randomUUID } from "crypto"
 import type { PiContext, JflConfig, AgentEndEvent } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
 import { emitCustomEvent } from "./map-bridge.js"
 
 interface EvalEntry {
@@ -50,7 +51,7 @@ export async function onAgentEnd(ctx: PiContext, event: AgentEndEvent): Promise<
 
   try {
     // @ts-ignore — resolved from jfl package at runtime
-    const { appendEval } = await import("../../src/lib/eval-store.js")
+    const { appendEval } = await jflImport("eval-store")
     appendEval(entry as Parameters<typeof appendEval>[0], projectRoot)
   } catch {
     // eval-store may not be available in all contexts — non-fatal

package/packages/pi/extensions/header.ts

@@ -0,0 +1,171 @@
+/**
+ * TENET Header
+ *
+ * Replaces Pi's default startup header (logo + keybinding hints) with a
+ * branded TENET identity line. Shows project name, branch, and key system
+ * indicators in a single compact row. This owns "above the fold" —
+ * everything the user sees before any messages.
+ *
+ * @purpose Branded header replacing Pi's default — owns above-the-fold identity
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import type { PiContext, PiTheme, JflConfig } from "./types.js"
+
+// ─── Cached state ────────────────────────────────────────────────────────────
+
+let projectRoot = ""
+let projectName = ""
+let branch = ""
+let journalCount = 0
+let tupleCount = 0
+let sessionCount = 0
+let hubOnline = false
+let autoCommitRunning = false
+let evalScore: string | null = null
+
+// ─── Data helpers ────────────────────────────────────────────────────────────
+
+function countJournals(root: string): { entries: number; sessions: number } {
+  const dir = join(root, ".jfl", "journal")
+  if (!existsSync(dir)) return { entries: 0, sessions: 0 }
+  try {
+    const files = readdirSync(dir).filter(f => f.endsWith(".jsonl"))
+    let entries = 0
+    for (const f of files) {
+      entries += readFileSync(join(dir, f), "utf-8").trim().split("\n").filter(Boolean).length
+    }
+    return { entries, sessions: files.length }
+  } catch {
+    return { entries: 0, sessions: 0 }
+  }
+}
+
+function countTuples(root: string): number {
+  const p = join(root, ".jfl", "training-buffer.jsonl")
+  if (!existsSync(p)) return 0
+  try {
+    return readFileSync(p, "utf-8").trim().split("\n").filter(Boolean).length
+  } catch {
+    return 0
+  }
+}
+
+function getLatestEval(root: string): string | null {
+  try {
+    const p = join(root, ".jfl", "eval.jsonl")
+    if (!existsSync(p)) return null
+    const lines = readFileSync(p, "utf-8").trim().split("\n").filter(Boolean)
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - 20); i--) {
+      try {
+        const e = JSON.parse(lines[i])
+        const s = e.composite ?? e.score
+        if (s != null) return Number(s).toFixed(2)
+      } catch {}
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+// ─── Refresh on-demand (called from onboarding probes or session_start) ──────
+
+export function refreshHeaderData(root: string, config: JflConfig): void {
+  projectRoot = root
+  projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  const { entries, sessions } = countJournals(root)
+  journalCount = entries
+  sessionCount = sessions
+  tupleCount = countTuples(root)
+  evalScore = getLatestEval(root)
+}
+
+export function setHeaderHubStatus(online: boolean): void {
+  hubOnline = online
+}
+
+export function setHeaderAutoCommit(running: boolean): void {
+  autoCommitRunning = running
+}
+
+export function setHeaderBranch(b: string): void {
+  branch = b
+}
+
+// ─── ANSI helpers ────────────────────────────────────────────────────────────
+
+function visLen(s: string): number {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length
+}
+
+function truncAnsi(s: string, max: number): string {
+  let vis = 0
+  let i = 0
+  while (i < s.length && vis < max) {
+    if (s[i] === "\x1b") {
+      const end = s.indexOf("m", i)
+      if (end !== -1) { i = end + 1; continue }
+    }
+    vis++
+    i++
+  }
+  return vis >= max ? s.slice(0, i) : s
+}
+
+// ─── Render ──────────────────────────────────────────────────────────────────
+
+function renderHeader(width: number, theme: PiTheme): string[] {
+  // Line 1: ◆ TENET · project-name · branch
+  const diamond = theme.fg("warning", "◆")
+  const brand = theme.bold(theme.fg("accent", "TENET"))
+  const name = theme.fg("text", projectName)
+  const branchStr = theme.fg("muted", branch || "main")
+
+  // Line 2: compact system indicators
+  const hubIcon = hubOnline
+    ? theme.fg("success", "✓") + theme.fg("dim", " Hub")
+    : theme.fg("error", "✗") + theme.fg("dim", " Hub")
+
+  const acIcon = autoCommitRunning
+    ? theme.fg("success", "✓") + theme.fg("dim", " Auto-commit")
+    : theme.fg("dim", "– Auto-commit")
+
+  const parts: string[] = [hubIcon, acIcon]
+
+  if (journalCount > 0) {
+    parts.push(theme.fg("dim", `${journalCount} entries · ${sessionCount} sessions`))
+  }
+  if (tupleCount > 0) {
+    parts.push(theme.fg("dim", `${tupleCount} tuples`))
+  }
+  if (evalScore) {
+    parts.push(theme.fg("warning", evalScore) + theme.fg("dim", " eval"))
+  }
+
+  const sep = theme.fg("dim", " · ")
+  const line1 = truncAnsi(` ${diamond} ${brand}${sep}${name}${sep}${branchStr}`, width)
+  const line2 = truncAnsi(`   ${parts.join(theme.fg("dim", "  │  "))}`, width)
+
+  return [line1, line2]
+}
+
+// ─── Setup ───────────────────────────────────────────────────────────────────
+
+export function setupHeader(ctx: PiContext, config: JflConfig): void {
+  if (!ctx.ui.hasUI) return
+
+  projectRoot = ctx.session.projectRoot
+  branch = ctx.session.branch
+  refreshHeaderData(projectRoot, config)
+
+  // Use the raw Pi setHeader API (available on latestPiCtx.ui)
+  // We access it through the shim's setHeader if available
+  ctx.ui.setHeader?.((tui: any, theme: PiTheme) => ({
+    render(width: number): string[] {
+      return renderHeader(width, theme)
+    },
+    invalidate() {},
+  }))
+}

package/packages/pi/extensions/hub-tools.ts

@@ -12,22 +12,42 @@
 
 import type { PiContext, JflConfig } from "./types.js"
 import { hubUrl, authToken } from "./map-bridge.js"
+import { readHubUrl, readToken } from "./hub-resolver.js"
+
+let projectRoot = ""
 
 async function hubFetch(path: string, method: "GET" | "POST" = "GET", body?: unknown): Promise<any> {
-  const resp = await fetch(`${hubUrl}${path}`, {
-    method,
-    headers: {
-      "Content-Type": "application/json",
-      ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
-    },
-    ...(body ? { body: JSON.stringify(body) } : {}),
-    signal: AbortSignal.timeout(5000),
-  })
-  if (!resp.ok) throw new Error(`Hub ${path}: ${resp.status}`)
-  return resp.json()
+  // Try current hubUrl, then fall back to fresh port file read
+  const urls = [hubUrl]
+  if (projectRoot) {
+    const fresh = readHubUrl(projectRoot)
+    if (fresh && fresh !== hubUrl) urls.push(fresh)
+  }
+
+  let lastErr: Error | null = null
+  for (const url of urls) {
+    const token = url === hubUrl ? authToken : (projectRoot ? readToken(projectRoot) : authToken)
+    try {
+      const resp = await fetch(`${url}${path}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+        signal: AbortSignal.timeout(5000),
+      })
+      if (!resp.ok) throw new Error(`Hub ${path}: ${resp.status}`)
+      return await resp.json()
+    } catch (err) {
+      lastErr = err as Error
+    }
+  }
+  throw lastErr ?? new Error(`Hub ${path}: unreachable`)
 }
 
 export async function setupHubTools(ctx: PiContext, _config: JflConfig): Promise<void> {
+  projectRoot = ctx.session.projectRoot
 
   // ─── jfl_events_publish ──────────────────────────────────────────────────
   ctx.registerTool({