jfl 0.9.1 → 0.9.3

package/packages/pi/extensions/onboarding-v2.ts

@@ -1,516 +1,369 @@
 /**
- * Onboarding V2 — CINEMATIC (Sator Square)
+ * Onboarding V2 — Cinematic boot sequence
  *
- * Full-screen animated onboarding sequence for the Tenet rebrand.
- * Progressive reveal: Sator Square -> subsystem awakening -> mission briefing.
- * Gold (#FFD700) on dark, theatrical pacing, mystery and gravitas.
+ * Visual-only startup overlay. Shows the SATOR square animation and
+ * live system probes, then dismisses. No project data — that comes
+ * from the startup briefing steer which fires after this overlay closes.
  *
- * @purpose Cinematic onboarding overlay — Sator Square, subsystem init, mission brief
+ * Flow: SATOR square → system probes → project name → dismiss
+ *
+ * The header (header.ts) owns persistent identity. This overlay owns
+ * the first-impression cinematic moment. The startup briefing (steer)
+ * owns the data-rich greeting that follows.
+ *
+ * @purpose Cinematic boot overlay — SATOR square + system health probes
  */
 
-import { existsSync, readFileSync, readdirSync, statSync } from "fs"
+import { existsSync, readFileSync, readdirSync } from "fs"
 import { join } from "path"
 import { execSync } from "child_process"
 import type { PiContext, PiTheme, JflConfig } from "./types.js"
+import { setHeaderHubStatus, setHeaderAutoCommit, refreshHeaderData } from "./header.js"
+
+// ─── Colors ──────────────────────────────────────────────────────────────────
 
 const GOLD = "warning"
-const GOLD_DIM = "muted"
-const DARK_GOLD = "dim"
-const WARM_WHITE = "text"
-const CHARCOAL = "#1a1a1a"
-const EMBER = "error"
-
-const SATOR_SQUARE = [
-  ["S", "A", "T", "O", "R"],
-  ["A", "R", "E", "P", "O"],
-  ["T", "E", "N", "E", "T"],
-  ["O", "P", "E", "R", "A"],
-  ["R", "O", "T", "A", "S"],
+const DIM = "muted"
+const WARM = "text"
+const RED = "error"
+const GREEN = "success"
+
+// ─── Sator Square ────────────────────────────────────────────────────────────
+
+const SATOR = [
+  ["S","A","T","O","R"],
+  ["A","R","E","P","O"],
+  ["T","E","N","E","T"],
+  ["O","P","E","R","A"],
+  ["R","O","T","A","S"],
 ]
+const TENET_ROW = 2
 
-const TENET_POSITIONS = [
-  [2, 0], [2, 1], [2, 2], [2, 3], [2, 4],
-]
+// ─── Types ───────────────────────────────────────────────────────────────────
 
-interface SubsystemState {
+interface Sys {
   name: string
-  icon: string
-  status: "waiting" | "connecting" | "ready" | "error"
+  status: "wait" | "probe" | "ok" | "err"
   detail: string
 }
 
-interface MissionData {
-  lastSessionSummary: string[]
-  pendingDecisions: number
-  currentPhase: string
-  projectName: string
-  projectType: string
-  branch: string
-  journalCount: number
-  activeAgents: number
-}
-
-function gatherMissionData(root: string, config: JflConfig): MissionData {
-  const projectName = config.name ?? root.split("/").pop() ?? "TENET"
-  const projectType = config.type ?? "gtm"
-
-  let currentPhase = ""
-  const roadmapPath = join(root, "knowledge", "ROADMAP.md")
-  if (existsSync(roadmapPath)) {
-    try {
-      const content = readFileSync(roadmapPath, "utf-8")
-      const phaseMatch = content.match(/## (?:Phase|Current Phase)[:\s]*([^\n]+)/i)
-      if (phaseMatch) currentPhase = phaseMatch[1].trim()
-    } catch {}
-  }
+// ─── Probes ──────────────────────────────────────────────────────────────────
 
-  const lastSessionSummary: string[] = []
-  let journalCount = 0
-  const journalDir = join(root, ".jfl", "journal")
-  if (existsSync(journalDir)) {
+async function probeHub(root: string): Promise<{ok: boolean; detail: string}> {
+  const port = readPort(root)
+  for (let i = 0; i < 4; i++) {
     try {
-      const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort()
-      for (const f of files) {
-        try {
-          const lines = readFileSync(join(journalDir, f), "utf-8").trim().split("\n").filter(Boolean)
-          journalCount += lines.length
-          for (const l of lines.slice(-5)) {
-            try {
-              const e = JSON.parse(l)
-              lastSessionSummary.push(e.title ?? e.summary ?? "")
-            } catch {}
-          }
-        } catch {}
-      }
+      const r = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(2000) })
+      if (r.ok) { const d = await r.json() as any; if (d.status === "ok") return {ok:true, detail:`:${port}`} }
     } catch {}
+    if (i < 3) await sleep(700)
   }
+  return {ok:false, detail:"offline"}
+}
 
-  let pendingDecisions = 0
-  const tasksPath = join(root, "knowledge", "TASKS.md")
-  if (existsSync(tasksPath)) {
+async function probeContext(root: string): Promise<{ok: boolean; detail: string}> {
+  const port = readPort(root), token = readToken(root)
+  for (let i = 0; i < 3; i++) {
     try {
-      const content = readFileSync(tasksPath, "utf-8")
-      const pending = content.match(/\[ \]/g)
-      pendingDecisions = pending?.length ?? 0
+      const r = await fetch(`http://localhost:${port}/api/context`, {
+        method: "POST",
+        headers: {"Content-Type":"application/json", ...(token ? {Authorization:`Bearer ${token}`} : {})},
+        body: JSON.stringify({maxItems:1}),
+        signal: AbortSignal.timeout(2000),
+      })
+      if (r.ok) return {ok:true, detail:"loaded"}
     } catch {}
+    if (i < 2) await sleep(700)
   }
+  return {ok:false, detail:"waiting…"}
+}
 
-  let branch = "main"
+async function probeMemory(root: string): Promise<{ok: boolean; detail: string}> {
+  const dir = join(root, ".jfl", "journal")
+  if (!existsSync(dir)) return {ok:false, detail:"none"}
   try {
-    branch = execSync("git branch --show-current", { cwd: root, stdio: ["pipe", "pipe", "ignore"] })
-      .toString().trim() || "main"
-  } catch {}
+    let n = 0
+    for (const f of readdirSync(dir).filter(f => f.endsWith(".jsonl")))
+      n += readFileSync(join(dir, f), "utf-8").trim().split("\n").filter(Boolean).length
+    return {ok:true, detail:`${n} entries`}
+  } catch { return {ok:false, detail:"err"} }
+}
 
-  let activeAgents = 0
-  if (existsSync(journalDir)) {
-    const now = Date.now()
+async function probeAutoCommit(): Promise<{ok: boolean; detail: string}> {
+  for (let i = 0; i < 4; i++) {
     try {
-      for (const f of readdirSync(journalDir)) {
-        if (!f.startsWith("session-") || !f.endsWith(".jsonl")) continue
-        try {
-          const stat = statSync(join(journalDir, f))
-          if (now - stat.mtimeMs < 300000) activeAgents++
-        } catch {}
-      }
+      if (execSync("ps aux", {timeout:2000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]}).includes("auto-commit.sh"))
+        return {ok:true, detail:"watching"}
     } catch {}
+    if (i < 3) await sleep(1000)
   }
-
-  return {
-    lastSessionSummary: lastSessionSummary.slice(-4),
-    pendingDecisions,
-    currentPhase,
-    projectName,
-    projectType,
-    branch,
-    journalCount,
-    activeAgents,
-  }
+  return {ok:false, detail:"–"}
 }
 
-async function probeSubsystem(
-  name: string,
-  probeFn: () => Promise<string>
-): Promise<{ ok: boolean; detail: string }> {
+async function probeEval(root: string): Promise<{ok: boolean; detail: string}> {
+  const p = join(root, ".jfl", "eval.jsonl")
+  if (!existsSync(p)) return {ok:false, detail:"—"}
   try {
-    const detail = await probeFn()
-    return { ok: true, detail }
-  } catch {
-    return { ok: false, detail: "offline" }
-  }
+    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 {ok:true, detail:Number(s).toFixed(2)} } catch {}
+    }
+    return {ok:true, detail:`${lines.length} runs`}
+  } catch { return {ok:false, detail:"err"} }
 }
 
-async function probeContextHub(root: string): Promise<string> {
-  const portFile = join(root, ".jfl", "context-hub.port")
-  if (!existsSync(portFile)) return "not found"
-  const port = readFileSync(portFile, "utf-8").trim()
-  const resp = await fetch(`http://localhost:${port}/api/health`, {
-    signal: AbortSignal.timeout(2000),
-  })
-  if (!resp.ok) throw new Error("unhealthy")
-  const data = await resp.json() as { status?: string; itemCount?: number }
-  const count = data.itemCount ?? 0
-  return count > 0 ? `${count} items` : "ready"
+async function probeTraining(root: string): Promise<{ok: boolean; detail: string}> {
+  const p = join(root, ".jfl", "training-buffer.jsonl")
+  if (!existsSync(p)) return {ok:false, detail:"—"}
+  try {
+    return {ok:true, detail:`${readFileSync(p,"utf-8").trim().split("\n").filter(Boolean).length} tuples`}
+  } catch { return {ok:false, detail:"err"} }
 }
 
-async function probeMemory(root: string): Promise<string> {
-  const dbPath = join(root, ".jfl", "memory.db")
-  if (!existsSync(dbPath)) return "no database"
-  const journalDir = join(root, ".jfl", "journal")
-  if (!existsSync(journalDir)) return "0 memories"
-  let count = 0
-  for (const f of readdirSync(journalDir).filter(f => f.endsWith(".jsonl"))) {
-    try {
-      count += readFileSync(join(journalDir, f), "utf-8").trim().split("\n").filter(Boolean).length
-    } catch {}
-  }
-  return `${count} memories`
+function readPort(root: string): string {
+  const f = join(root, ".jfl", "context-hub.port")
+  return existsSync(f) ? readFileSync(f, "utf-8").trim() : "4360"
 }
-
-async function probeSubway(root: string): Promise<string> {
-  const envPath = join(root, ".env")
-  if (!existsSync(envPath)) return "no key"
-  try {
-    const env = readFileSync(envPath, "utf-8")
-    if (env.includes("STRATUS_API_KEY") || env.includes("stratus_sk")) {
-      return "relay online"
-    }
-  } catch {}
-  return "no relay"
+function readToken(root: string): string {
+  const f = join(root, ".jfl", "context-hub.token")
+  return existsSync(f) ? readFileSync(f, "utf-8").trim() : ""
 }
+function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)) }
+
+// ─── Main ────────────────────────────────────────────────────────────────────
 
 export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promise<void> {
   const root = ctx.session.projectRoot
+  if (!ctx.ui.hasUI) return
 
-  if (!ctx.ui.hasUI) {
-    ctx.log("Onboarding v2: no TUI, skipping cinematic", "debug")
-    return
-  }
-
-  const mission = gatherMissionData(root, config)
-
-  const subsystemProbes = await Promise.allSettled([
-    probeSubsystem("Context Hub", () => probeContextHub(root)),
-    probeSubsystem("Memory", () => probeMemory(root)),
-    probeSubsystem("Subway", () => probeSubway(root)),
-  ])
-
-  const subsystems: SubsystemState[] = [
-    {
-      name: "Context Hub",
-      icon: "◆",
-      status: "waiting",
-      detail: "",
-    },
-    {
-      name: "Memory",
-      icon: "◆",
-      status: "waiting",
-      detail: "",
-    },
-    {
-      name: "Subway",
-      icon: "◆",
-      status: "waiting",
-      detail: "",
-    },
+  const projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  const branch = ctx.session.branch
+
+  const systems: Sys[] = [
+    {name:"Hub",         status:"wait", detail:""},
+    {name:"Context",     status:"wait", detail:""},
+    {name:"Memory",      status:"wait", detail:""},
+    {name:"Auto-commit", status:"wait", detail:""},
+    {name:"Eval",        status:"wait", detail:""},
+    {name:"Training",    status:"wait", detail:""},
   ]
 
-  const probeResults = subsystemProbes.map(p =>
-    p.status === "fulfilled" ? p.value : { ok: false, detail: "probe failed" }
-  )
+  const probes = [
+    () => probeHub(root),
+    () => probeContext(root),
+    () => probeMemory(root),
+    () => probeAutoCommit(),
+    () => probeEval(root),
+    () => probeTraining(root),
+  ]
 
   await ctx.ui.custom<void>((tui: any, theme: PiTheme, _kb: any, done: (r: void) => void) => {
-    let phase: "square" | "subsystems" | "briefing" | "ready" = "square"
-    let squareProgress = 0
-    let tenetGlow = false
-    let subsystemIndex = -1
-    let briefingRevealed = 0
-    let readyFade = 0
-    let frameTimer: ReturnType<typeof setTimeout> | null = null
-    let disposed = false
-
-    const TOTAL_CELLS = 25
-    const SQUARE_FRAME_MS = 50
-    const SUBSYSTEM_FRAME_MS = 300
-    const BRIEFING_FRAME_MS = 200
-    const READY_DELAY_MS = 600
-    const TENET_GLOW_DELAY_MS = 400
-
-    function scheduleNext(fn: () => void, ms: number) {
-      if (disposed) return
-      frameTimer = setTimeout(() => {
-        if (disposed) return
-        fn()
-        tui.requestRender()
-      }, ms)
+    let phase: "square"|"glow"|"systems"|"ready" = "square"
+    let sqProg = 0
+    let glow = false
+    let sysRevealed = 0
+    let readyTick = 0
+    let timer: ReturnType<typeof setTimeout>|null = null
+    let dead = false
+
+    // ── Timing ──
+    const SQ_MS    = 40       // per letter (faster)
+    const GLOW_MS  = 500      // hold after square
+    const GLW2SYS  = 300      // glow → systems
+    const SYS_MS   = 180      // per system row reveal
+    const SETTLE   = 150      // probe settle poll
+    const RDY_HOLD = 1200     // show ready then auto-dismiss
+
+    function tick(fn: () => void, ms: number) {
+      if (dead) return
+      timer = setTimeout(() => { if (!dead) { fn(); tui.requestRender() } }, ms)
     }
 
-    function advanceSquare() {
-      if (squareProgress < TOTAL_CELLS) {
-        squareProgress++
-        scheduleNext(advanceSquare, SQUARE_FRAME_MS)
-      } else if (!tenetGlow) {
-        scheduleNext(() => {
-          tenetGlow = true
-          scheduleNext(startSubsystems, TENET_GLOW_DELAY_MS)
-        }, TENET_GLOW_DELAY_MS)
-      }
+    // ── Color helpers ──
+    const g  = (s: string) => theme.fg(GOLD, s)
+    const d  = (s: string) => theme.fg(DIM, s)
+    const w  = (s: string) => theme.fg(WARM, s)
+    const gr = (s: string) => theme.fg(GREEN, s)
+    const rd = (s: string) => theme.fg(RED, s)
+
+    // ── ANSI helpers ──
+    function stripLen(s: string) { return s.replace(/\x1b\[[0-9;]*m/g, "").length }
+    function pad(line: string, width: number) {
+      return line + " ".repeat(Math.max(0, width - stripLen(line)))
     }
-
-    function startSubsystems() {
-      phase = "subsystems"
-      subsystemIndex = 0
-      advanceSubsystem()
+    function center(text: string, width: number) {
+      const vis = stripLen(text)
+      const left = Math.max(0, Math.floor((width - vis) / 2))
+      return " ".repeat(left) + text
     }
 
-    function advanceSubsystem() {
-      if (subsystemIndex < subsystems.length) {
-        const result = probeResults[subsystemIndex]
-        subsystems[subsystemIndex].status = result.ok ? "ready" : "error"
-        subsystems[subsystemIndex].detail = result.detail
-        subsystemIndex++
-        if (subsystemIndex < subsystems.length) {
-          scheduleNext(advanceSubsystem, SUBSYSTEM_FRAME_MS)
-        } else {
-          scheduleNext(startBriefing, SUBSYSTEM_FRAME_MS)
-        }
-      }
+    // ── Phase: Square ──
+    function doSquare() {
+      if (sqProg < 25) { sqProg++; tick(doSquare, SQ_MS) }
+      else tick(() => { glow = true; phase = "glow"; tick(doSystems, GLW2SYS) }, GLOW_MS)
     }
 
-    function startBriefing() {
-      phase = "briefing"
-      briefingRevealed = 0
-      advanceBriefing()
+    // ── Phase: Systems ──
+    function doSystems() {
+      phase = "systems"
+      // Fire all probes in parallel
+      systems.forEach((s, i) => {
+        s.status = "probe"
+        probes[i]().then(r => {
+          s.status = r.ok ? "ok" : "err"
+          s.detail = r.detail
+          // Feed results back to the persistent header
+          if (i === 0) setHeaderHubStatus(r.ok)       // Hub
+          if (i === 3) setHeaderAutoCommit(r.ok)       // Auto-commit
+          tui.requestRender()
+        }).catch(() => {
+          s.status = "err"
+          s.detail = "timeout"
+          tui.requestRender()
+        })
+      })
+      revealSys()
     }
 
-    function advanceBriefing() {
-      const totalLines = getBriefingLines().length
-      if (briefingRevealed < totalLines) {
-        briefingRevealed++
-        scheduleNext(advanceBriefing, BRIEFING_FRAME_MS)
-      } else {
-        scheduleNext(startReady, READY_DELAY_MS)
-      }
+    function revealSys() {
+      if (sysRevealed < systems.length) { sysRevealed++; tick(revealSys, SYS_MS) }
+      else waitProbes()
     }
 
-    function getBriefingLines(): string[] {
-      const lines: string[] = []
-      if (mission.lastSessionSummary.length > 0) {
-        for (const s of mission.lastSessionSummary.slice(-3)) {
-          if (s.trim()) lines.push(s.trim())
-        }
+    function waitProbes() {
+      if (systems.some(s => s.status === "probe")) tick(waitProbes, SETTLE)
+      else {
+        // Refresh header with final probe data
+        refreshHeaderData(root, config)
+        tick(doReady, 200)
       }
-      if (mission.pendingDecisions > 0) {
-        lines.push(`${mission.pendingDecisions} tasks pending`)
-      }
-      if (mission.currentPhase) {
-        lines.push(mission.currentPhase)
-      }
-      if (lines.length === 0) {
-        lines.push("First session. No prior context.")
-      }
-      return lines
     }
 
-    function startReady() {
+    // ── Phase: Ready ──
+    function doReady() {
       phase = "ready"
-      readyFade = 0
-      scheduleNext(() => {
-        readyFade = 1
-        scheduleNext(() => {
-          if (!disposed) done(undefined)
-        }, 500)
-      }, 300)
+      readyTick = 0
+      tickReady()
     }
-
-    scheduleNext(advanceSquare, 300)
-
-    function gold(t: PiTheme, text: string): string {
-      return t.fg(GOLD, text)
-    }
-    function dimGold(t: PiTheme, text: string): string {
-      return t.fg(GOLD_DIM, text)
-    }
-    function darkGold(t: PiTheme, text: string): string {
-      return t.fg(DARK_GOLD, text)
-    }
-    function warm(t: PiTheme, text: string): string {
-      return t.fg(WARM_WHITE, text)
+    function tickReady() {
+      if (readyTick < 3) { readyTick++; tick(tickReady, 250) }
+      else tick(() => { if (!dead) done(undefined) }, RDY_HOLD)
     }
 
-    function renderSquare(theme: PiTheme, width: number): string[] {
-      const lines: string[] = []
-      const squareWidth = 5 * 4 - 1
-      const leftPad = Math.max(0, Math.floor((width - squareWidth) / 2))
-      const pad = " ".repeat(leftPad)
+    // Kick off
+    tick(doSquare, 100)
 
-      for (let row = 0; row < 5; row++) {
+    // ── Renderers ──
+
+    function renderSquare(W: number): string[] {
+      const out: string[] = []
+      const cw = 5 * 4 - 1 // "S   A   T   O   R"
+      const lp = " ".repeat(Math.max(0, Math.floor((W - cw) / 2)))
+      for (let r = 0; r < 5; r++) {
         let line = ""
-        for (let col = 0; col < 5; col++) {
-          const cellIndex = row * 5 + col
-          const char = SATOR_SQUARE[row][col]
-          const isTenet = TENET_POSITIONS.some(([r, c]) => r === row && c === col)
-
-          if (cellIndex < squareProgress) {
-            if (tenetGlow && isTenet) {
-              line += theme.bold(gold(theme, char))
-            } else if (tenetGlow) {
-              line += darkGold(theme, char)
-            } else {
-              line += dimGold(theme, char)
-            }
+        for (let c = 0; c < 5; c++) {
+          const idx = r * 5 + c
+          const ch = SATOR[r][c]
+          if (idx < sqProg) {
+            if (glow && r === TENET_ROW) line += theme.bold(g(ch))
+            else if (glow) line += d(ch)
+            else line += d(ch)
           } else {
-            line += darkGold(theme, ".")
+            line += d("·")
           }
-
-          if (col < 4) line += "   "
-        }
-        lines.push(pad + line)
-        if (row < 4) lines.push("")
-      }
-
-      return lines
-    }
-
-    function renderSubsystems(theme: PiTheme, width: number): string[] {
-      const lines: string[] = []
-      const innerWidth = Math.min(width - 8, 50)
-      const leftPad = Math.max(0, Math.floor((width - innerWidth) / 2))
-      const pad = " ".repeat(leftPad)
-
-      for (let i = 0; i < subsystems.length; i++) {
-        const sys = subsystems[i]
-        let icon: string
-        let nameStr: string
-        let detailStr: string
-
-        if (i > subsystemIndex - 1 && i !== subsystemIndex) {
-          icon = darkGold(theme, "○")
-          nameStr = darkGold(theme, sys.name)
-          detailStr = darkGold(theme, "waiting...")
-        } else if (sys.status === "ready") {
-          icon = gold(theme, "●")
-          nameStr = warm(theme, sys.name)
-          detailStr = gold(theme, sys.detail)
-        } else if (sys.status === "error") {
-          icon = theme.fg(EMBER, "●")
-          nameStr = theme.fg(EMBER, sys.name)
-          detailStr = theme.fg(EMBER, sys.detail)
-        } else {
-          icon = dimGold(theme, "◌")
-          nameStr = dimGold(theme, sys.name)
-          detailStr = dimGold(theme, "connecting...")
-        }
-
-        const namePadded = (sys.name + " ".repeat(Math.max(0, 16 - sys.name.length)))
-        if (sys.status === "ready") {
-          lines.push(pad + `${icon}  ${warm(theme, namePadded)} ${detailStr}`)
-        } else if (sys.status === "error") {
-          lines.push(pad + `${icon}  ${theme.fg(EMBER, namePadded)} ${detailStr}`)
-        } else if (i > subsystemIndex - 1) {
-          lines.push(pad + `${icon}  ${darkGold(theme, namePadded)} ${detailStr}`)
-        } else {
-          lines.push(pad + `${icon}  ${dimGold(theme, namePadded)} ${detailStr}`)
+          if (c < 4) line += "   "
         }
+        out.push(lp + line)
+        if (r < 4) out.push("") // spacing between rows
       }
-
-      return lines
+      return out
     }
 
-    function renderBriefing(theme: PiTheme, width: number): string[] {
-      const lines: string[] = []
-      const innerWidth = Math.min(width - 8, 56)
-      const leftPad = Math.max(0, Math.floor((width - innerWidth) / 2))
-      const pad = " ".repeat(leftPad)
-
-      const divider = darkGold(theme, "───") + dimGold(theme, " Last Session ") + darkGold(theme, "─".repeat(Math.max(0, innerWidth - 17)))
-      lines.push(pad + divider)
-      lines.push("")
-
-      const briefingLines = getBriefingLines()
-      for (let i = 0; i < briefingLines.length; i++) {
-        if (i < briefingRevealed) {
-          lines.push(pad + "  " + warm(theme, briefingLines[i]))
-        }
+    function renderSystems(W: number): string[] {
+      const out: string[] = []
+      const inner = Math.min(W - 4, 48)
+      const lp = " ".repeat(Math.max(0, Math.floor((W - inner) / 2)))
+
+      for (let i = 0; i < Math.min(sysRevealed, systems.length); i++) {
+        const s = systems[i]
+        const nm = s.name.padEnd(13)
+        let icon: string, name: string, det: string
+        if (s.status === "ok")         { icon = gr("✓"); name = w(nm); det = d(s.detail) }
+        else if (s.status === "err")   { icon = rd("✗"); name = rd(nm); det = rd(s.detail) }
+        else if (s.status === "probe") { icon = d("◌"); name = d(nm); det = d("…") }
+        else                           { icon = d("○"); name = d(nm); det = d("") }
+        out.push(`${lp}  ${icon}  ${name} ${det}`)
       }
-
-      return lines
+      return out
     }
 
-    function renderReady(theme: PiTheme, width: number): string[] {
-      const lines: string[] = []
-      const leftPad = Math.max(0, Math.floor((width - 20) / 2))
-      const pad = " ".repeat(leftPad)
-
-      if (readyFade >= 1) {
-        lines.push(pad + theme.bold(gold(theme, mission.projectName)))
-        lines.push(pad + dimGold(theme, `${mission.projectType} · ${mission.branch}`))
-      } else {
-        lines.push(pad + darkGold(theme, mission.projectName))
+    function renderReady(W: number): string[] {
+      const out: string[] = []
+      const sep = d(" · ")
+      out.push("")
+      if (readyTick >= 1) out.push(center(theme.bold(g(projectName.toUpperCase())), W))
+      if (readyTick >= 2) out.push(center(d(branch), W))
+      if (readyTick >= 3) {
+        // Count how many probes passed
+        const ok = systems.filter(s => s.status === "ok").length
+        const total = systems.length
+        const allGood = ok === total
+        const statusText = allGood
+          ? gr("all systems nominal")
+          : g(`${ok}/${total} systems`)
+        out.push(center(statusText, W))
       }
-
-      return lines
+      return out
     }
 
+    // ── Main render ──
     return {
       handleInput(key: string) {
         if (key === "\x1b" || key === "q" || key === " " || key === "\r") {
-          if (frameTimer) clearTimeout(frameTimer)
-          disposed = true
+          if (timer) clearTimeout(timer)
+          dead = true
           done(undefined)
         }
       },
 
       render(width: number): string[] {
-        const lines: string[] = []
-        const w = Math.min(width, 80)
-
-        lines.push("")
-        lines.push("")
+        const W = width
+        const H = process.stdout?.rows || 40
+        const content: string[] = []
 
-        if (phase === "square" || phase === "subsystems" || phase === "briefing" || phase === "ready") {
-          const squareLines = renderSquare(theme, w)
-          lines.push(...squareLines)
-        }
-
-        lines.push("")
-
-        if (phase === "subsystems" || phase === "briefing" || phase === "ready") {
-          const sysLines = renderSubsystems(theme, w)
-          lines.push(...sysLines)
-          lines.push("")
-        }
+        // Square
+        content.push(...renderSquare(W))
+        if (phase !== "square" && phase !== "glow") content.push("")
 
-        if (phase === "briefing" || phase === "ready") {
-          const briefLines = renderBriefing(theme, w)
-          lines.push(...briefLines)
-          lines.push("")
+        // Systems
+        if (phase === "systems" || phase === "ready") {
+          content.push(...renderSystems(W))
         }
 
+        // Ready
         if (phase === "ready") {
-          const readyLines = renderReady(theme, w)
-          lines.push(...readyLines)
-          lines.push("")
+          content.push(...renderReady(W))
         }
 
-        if (phase !== "ready") {
-          const hint = darkGold(theme, "Esc to skip")
-          const hintPad = " ".repeat(Math.max(0, Math.floor((w - 11) / 2)))
-          lines.push("")
-          lines.push(hintPad + hint)
+        // Skip hint (during animation only)
+        if (phase === "square" || phase === "glow" || phase === "systems") {
+          content.push("", center(d("press any key to skip"), W))
         }
 
-        lines.push("")
+        // Vertically center, fill everything with blanks (covers Pi startup)
+        const topPad = Math.max(1, Math.floor((H - content.length) / 2))
+        const out: string[] = []
+        for (let i = 0; i < topPad; i++) out.push(" ".repeat(W))
+        for (const line of content) out.push(pad(line, W))
+        while (out.length < H) out.push(" ".repeat(W))
 
-        return lines
+        return out
       },
 
       invalidate() {},
     }
   }, {
     overlay: true,
-    overlayOptions: {
-      dismissOnEscape: false,
-    },
+    overlayOptions: { dismissOnEscape: false },
   })
 }