@10et/cli 1.0.0

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

@@ -0,0 +1,686 @@
+/**
+ * Onboarding V3 — Mission Control
+ *
+ * Dashboard-first boot screen. Every subsystem initializes simultaneously
+ * with live progress bars. Dense, data-rich, box-drawn panels showing
+ * runtime info, system status, context summary, and active agents.
+ * Collapses to compact footer when all systems report green.
+ *
+ * @purpose VARIANT 3: Mission Control onboarding — dashboard boot with live system checks
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, JflConfig, PiTheme } from "./types.js"
+import { readHubUrl, readToken } from "./hub-resolver.js"
+import { getMeshClient, isStandaloneSubwayLoaded } from "./subway-mesh.js"
+
+// ─── Subsystem status tracking ──────────────────────────────────────────────
+
+type SystemStatus = "booting" | "ready" | "connecting" | "warning" | "error"
+
+interface Subsystem {
+  name: string
+  status: SystemStatus
+  progress: number
+  detail: string
+  startTime: number
+}
+
+interface ContextData {
+  lastJournalTitle: string
+  phase: string
+  serviceCount: number
+  evalScore: string | null
+  evalDelta: string | null
+}
+
+interface AgentInfo {
+  name: string
+  status: "online" | "idle" | "offline"
+  detail: string
+}
+
+interface BootState {
+  systems: Map<string, Subsystem>
+  context: ContextData
+  agents: AgentInfo[]
+  projectName: string
+  projectType: string
+  version: string
+  model: string
+  branch: string
+  allGreen: boolean
+  bootComplete: boolean
+  bootStartTime: number
+}
+
+// ─── Data collection helpers ────────────────────────────────────────────────
+
+function getJflVersion(): string {
+  try {
+    const result = execSync("jfl --version 2>/dev/null || echo 0.7.3", {
+      encoding: "utf-8",
+      timeout: 2000,
+    }).trim()
+    const match = result.match(/(\d+\.\d+\.\d+)/)
+    return match ? match[1] : "0.7.3"
+  } catch {
+    return "0.7.3"
+  }
+}
+
+function getPiVersion(root: string): string {
+  try {
+    const pkgPath = join(root, "node_modules", "@jfl", "pi", "package.json")
+    if (!existsSync(pkgPath)) {
+      const localPkg = join(__dirname, "..", "package.json")
+      if (existsSync(localPkg)) {
+        const pkg = JSON.parse(readFileSync(localPkg, "utf-8"))
+        return pkg.version ?? "0.1.0"
+      }
+      return "0.1.0"
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+    return pkg.version ?? "0.1.0"
+  } catch {
+    return "0.1.0"
+  }
+}
+
+function countJournalEntries(root: string): number {
+  try {
+    const journalDir = join(root, ".jfl", "journal")
+    if (!existsSync(journalDir)) return 0
+    let count = 0
+    for (const f of readdirSync(journalDir).filter(f => f.endsWith(".jsonl"))) {
+      const content = readFileSync(join(journalDir, f), "utf-8").trim()
+      count += content.split("\n").filter(Boolean).length
+    }
+    return count
+  } catch {
+    return 0
+  }
+}
+
+function getLastJournalTitle(root: string): string {
+  try {
+    const journalDir = join(root, ".jfl", "journal")
+    if (!existsSync(journalDir)) return "No journal entries"
+    const files = readdirSync(journalDir)
+      .filter(f => f.endsWith(".jsonl"))
+      .map(f => ({ name: f, mtime: statSync(join(journalDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime)
+    if (files.length === 0) return "No journal entries"
+    const content = readFileSync(join(journalDir, files[0].name), "utf-8").trim()
+    const lines = content.split("\n").filter(Boolean)
+    if (lines.length === 0) return "No journal entries"
+    const last = JSON.parse(lines[lines.length - 1])
+    return last.title ?? last.summary ?? "Untitled entry"
+  } catch {
+    return "No journal entries"
+  }
+}
+
+function getCurrentPhase(root: string): string {
+  try {
+    const roadmapPath = join(root, "knowledge", "ROADMAP.md")
+    if (!existsSync(roadmapPath)) return "Unknown"
+    const content = readFileSync(roadmapPath, "utf-8")
+    const phaseMatch = content.match(/##\s+(?:Current\s+)?Phase[:\s]+(.+)/i)
+      ?? content.match(/\*\*Current[:\s]+(.+?)\*\*/i)
+      ?? content.match(/Phase\s+\d+[:\s]+(.+)/m)
+    return phaseMatch ? phaseMatch[1].trim().slice(0, 40) : "Active"
+  } catch {
+    return "Active"
+  }
+}
+
+function getServiceCount(root: string): number {
+  try {
+    const configPath = join(root, ".jfl", "config.json")
+    if (!existsSync(configPath)) return 0
+    const config = JSON.parse(readFileSync(configPath, "utf-8"))
+    return config.registered_services?.length ?? 0
+  } catch {
+    return 0
+  }
+}
+
+function getEvalData(root: string): { score: string | null; delta: string | null } {
+  try {
+    const evalPath = join(root, ".jfl", "eval-store.jsonl")
+    if (!existsSync(evalPath)) return { score: null, delta: null }
+    const lines = readFileSync(evalPath, "utf-8").trim().split("\n").filter(Boolean)
+    if (lines.length === 0) return { score: null, delta: null }
+    const last = JSON.parse(lines[lines.length - 1])
+    if (last.composite === undefined) return { score: null, delta: null }
+    const score = last.composite.toFixed(2)
+    if (lines.length >= 2) {
+      const prev = JSON.parse(lines[lines.length - 2])
+      if (prev.composite !== undefined) {
+        const diff = last.composite - prev.composite
+        const sign = diff >= 0 ? "+" : ""
+        return { score, delta: `${sign}${diff.toFixed(2)}` }
+      }
+    }
+    return { score, delta: null }
+  } catch {
+    return { score: null, delta: null }
+  }
+}
+
+function getActiveAgents(root: string): AgentInfo[] {
+  const agents: AgentInfo[] = []
+  try {
+    const journalDir = join(root, ".jfl", "journal")
+    if (!existsSync(journalDir)) return agents
+    const now = Date.now()
+    const files = readdirSync(journalDir)
+      .filter(f => f.startsWith("session-") && f.endsWith(".jsonl"))
+      .map(f => ({
+        name: f.replace("session-", "").replace(".jsonl", ""),
+        mtime: statSync(join(journalDir, f)).mtimeMs,
+      }))
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, 6)
+
+    for (const f of files) {
+      const age = now - f.mtime
+      const nameParts = f.name.split("-")
+      const displayName = nameParts[0] ?? f.name
+      if (age < 120000) {
+        agents.push({ name: displayName, status: "online", detail: "active" })
+      } else if (age < 600000) {
+        agents.push({ name: displayName, status: "idle", detail: "idle" })
+      } else {
+        const ageStr = age < 3600000 ? `${Math.floor(age / 60000)}m ago` : `${Math.floor(age / 3600000)}h ago`
+        agents.push({ name: displayName, status: "offline", detail: `last: ${ageStr}` })
+      }
+    }
+  } catch {}
+
+  if (agents.length === 0) {
+    agents.push({ name: "No active sessions", status: "offline", detail: "" })
+  }
+  return agents
+}
+
+function countMemories(root: string): number {
+  try {
+    const dbPath = join(root, ".jfl", "memory.db")
+    if (!existsSync(dbPath)) return 0
+    const result = execSync(
+      `sqlite3 "${dbPath}" "SELECT COUNT(*) FROM memories;" 2>/dev/null`,
+      { encoding: "utf-8", timeout: 2000 },
+    ).trim()
+    return parseInt(result, 10) || 0
+  } catch {
+    return countJournalEntries(root)
+  }
+}
+
+function isAutoCommitRunning(root: string): boolean {
+  try {
+    const pidFile = join(root, ".jfl", "auto-commit.pid")
+    if (!existsSync(pidFile)) return false
+    const pid = readFileSync(pidFile, "utf-8").trim()
+    execSync(`kill -0 ${pid} 2>/dev/null`, { timeout: 1000 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ─── Rendering helpers ──────────────────────────────────────────────────────
+
+function progressBar(progress: number, width: number, theme: PiTheme, status: SystemStatus): string {
+  const filled = Math.round(progress * width)
+  const empty = width - filled
+
+  const filledChar = "\u25A0"
+  const emptyChar = "\u2591"
+
+  const color = status === "ready" ? "success"
+    : status === "connecting" ? "warning"
+    : status === "error" ? "error"
+    : "accent"
+
+  const filledStr = theme.fg(color, filledChar.repeat(filled))
+  const emptyStr = theme.fg("dim", emptyChar.repeat(empty))
+  return `[${filledStr}${emptyStr}]`
+}
+
+function truncate(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str
+  return str.slice(0, maxLen - 1) + "\u2026"
+}
+
+function padRight(str: string, len: number): string {
+  if (str.length >= len) return str.slice(0, len)
+  return str + " ".repeat(len - str.length)
+}
+
+// ─── Main boot screen renderer ─────────────────────────────────────────────
+
+function renderBootScreen(state: BootState, width: number, theme: PiTheme): string[] {
+  const w = Math.min(width, 60)
+  const inner = w - 4
+  const lines: string[] = []
+  const hr = "\u2500".repeat(w - 2)
+
+  const statusIcon = (s: SystemStatus): string => {
+    if (s === "ready") return theme.fg("success", "\u25CF")
+    if (s === "connecting") return theme.fg("warning", "\u25CB")
+    if (s === "error") return theme.fg("error", "\u2717")
+    return theme.fg("dim", "\u25CB")
+  }
+
+  // ─── Header ─────────────────────────────────────────────────────────
+  lines.push("")
+  lines.push(`  ${theme.fg("border", "\u250C\u2500")} ${theme.bold(theme.fg("accent", "TENET"))} ${theme.fg("border", "\u2500".repeat(w - 12) + "\u2510")}`)
+
+  const runtimeLine = `Runtime: Pi v${getPiVersion(state.systems.get("hub")?.detail.split(":")[1]?.trim() ?? "")} + Tenet v${state.version}`
+  const modelLine = `Model:   ${state.model || "detecting..."}`
+  const branchLine = `Branch:  ${truncate(state.branch, inner - 10)}`
+
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("dim", padRight(runtimeLine, inner))} ${theme.fg("border", "\u2502")}`)
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("dim", padRight(modelLine, inner))} ${theme.fg("border", "\u2502")}`)
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("dim", padRight(branchLine, inner))} ${theme.fg("border", "\u2502")}`)
+
+  // ─── Systems panel ──────────────────────────────────────────────────
+  lines.push(`  ${theme.fg("border", "\u251C\u2500")} ${theme.fg("muted", "SYSTEMS")} ${theme.fg("border", "\u2500".repeat(w - 14) + "\u2524")}`)
+
+  const barWidth = 10
+  const systemOrder = ["hub", "memory", "subway", "autocommit", "journal"]
+
+  for (const key of systemOrder) {
+    const sys = state.systems.get(key)
+    if (!sys) continue
+
+    const bar = progressBar(sys.progress, barWidth, theme, sys.status)
+    const nameStr = padRight(sys.name, 12)
+    const statusStr = sys.status === "ready"
+      ? theme.fg("success", "ready")
+      : sys.status === "connecting"
+        ? theme.fg("warning", "connecting...")
+        : sys.status === "error"
+          ? theme.fg("error", "error")
+          : theme.fg("dim", "booting")
+
+    const detailStr = sys.detail ? theme.fg("dim", ` ${truncate(sys.detail, inner - 40)}`) : ""
+    const lineContent = ` ${bar} ${nameStr} ${statusStr}${detailStr}`
+    lines.push(`  ${theme.fg("border", "\u2502")}${padRight(lineContent, inner + 1)}${theme.fg("border", "\u2502")}`)
+  }
+
+  // ─── Context panel ──────────────────────────────────────────────────
+  lines.push(`  ${theme.fg("border", "\u251C\u2500")} ${theme.fg("muted", "CONTEXT")} ${theme.fg("border", "\u2500".repeat(w - 14) + "\u2524")}`)
+
+  const ctx = state.context
+  const lastLine = `Last: ${truncate(ctx.lastJournalTitle, inner - 8)}`
+  const phaseLine = `Phase: ${truncate(ctx.phase, inner - 9)}`
+  const svcLine = `Services: ${ctx.serviceCount} registered`
+  let evalLine = "Eval: "
+  if (ctx.evalScore) {
+    evalLine += `${ctx.evalScore} composite`
+    if (ctx.evalDelta) evalLine += ` (${ctx.evalDelta})`
+  } else {
+    evalLine += "no data"
+  }
+
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("text", padRight(lastLine, inner))} ${theme.fg("border", "\u2502")}`)
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("text", padRight(phaseLine, inner))} ${theme.fg("border", "\u2502")}`)
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("text", padRight(svcLine, inner))} ${theme.fg("border", "\u2502")}`)
+  lines.push(`  ${theme.fg("border", "\u2502")} ${theme.fg("text", padRight(evalLine, inner))} ${theme.fg("border", "\u2502")}`)
+
+  // ─── Agents panel ───────────────────────────────────────────────────
+  lines.push(`  ${theme.fg("border", "\u251C\u2500")} ${theme.fg("muted", "AGENTS")} ${theme.fg("border", "\u2500".repeat(w - 13) + "\u2524")}`)
+
+  for (const agent of state.agents.slice(0, 5)) {
+    const icon = agent.status === "online" ? theme.fg("success", "\u25CF")
+      : agent.status === "idle" ? theme.fg("warning", "\u25CB")
+      : theme.fg("dim", "\u25CB")
+    const nameStr = padRight(agent.name, 16)
+    const detailStr = agent.detail ? theme.fg("dim", agent.detail) : ""
+    const agentLine = ` ${icon} ${nameStr} ${detailStr}`
+    lines.push(`  ${theme.fg("border", "\u2502")}${padRight(agentLine, inner + 1)}${theme.fg("border", "\u2502")}`)
+  }
+
+  // ─── Footer ─────────────────────────────────────────────────────────
+  lines.push(`  ${theme.fg("border", "\u2514" + "\u2500".repeat(w - 2) + "\u2518")}`)
+
+  if (state.allGreen) {
+    const elapsed = Date.now() - state.bootStartTime
+    const elapsedStr = `${(elapsed / 1000).toFixed(1)}s`
+    lines.push(`  ${theme.fg("success", "\u25CF All systems nominal")} ${theme.fg("dim", `(${elapsedStr})`)}`)
+  } else {
+    const readyCount = Array.from(state.systems.values()).filter(s => s.status === "ready").length
+    const totalCount = state.systems.size
+    lines.push(`  ${theme.fg("dim", `Initializing... ${readyCount}/${totalCount} systems ready`)}`)
+  }
+
+  lines.push("")
+  return lines
+}
+
+// ─── System check runners ───────────────────────────────────────────────────
+
+async function checkHub(
+  root: string,
+  sys: Subsystem,
+  onUpdate: () => void,
+): Promise<void> {
+  sys.progress = 0.2
+  sys.status = "connecting"
+  sys.detail = ""
+  onUpdate()
+
+  const hubBaseUrl = readHubUrl(root)
+  const token = readToken(root)
+
+  try {
+    sys.progress = 0.5
+    onUpdate()
+
+    const resp = await fetch(`${hubBaseUrl}/api/status`, {
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+      signal: AbortSignal.timeout(3000),
+    })
+
+    if (resp.ok) {
+      const data = await resp.json() as { port?: number; uptime?: number }
+      const port = data.port ?? hubBaseUrl.split(":").pop()
+      sys.progress = 1
+      sys.status = "ready"
+      sys.detail = `:${port}`
+      onUpdate()
+    } else {
+      sys.progress = 0.7
+      sys.status = "connecting"
+      sys.detail = "starting..."
+      onUpdate()
+
+      try {
+        execSync("jfl context-hub ensure", { cwd: root, stdio: "pipe", timeout: 10000 })
+        sys.progress = 1
+        sys.status = "ready"
+        const port = hubBaseUrl.split(":").pop()
+        sys.detail = `:${port}`
+      } catch {
+        sys.progress = 1
+        sys.status = "warning"
+        sys.detail = "fallback"
+      }
+      onUpdate()
+    }
+  } catch {
+    sys.progress = 0.7
+    sys.status = "connecting"
+    sys.detail = "starting..."
+    onUpdate()
+
+    try {
+      execSync("jfl context-hub ensure", { cwd: root, stdio: "pipe", timeout: 10000 })
+      sys.progress = 1
+      sys.status = "ready"
+      const port = hubBaseUrl.split(":").pop()
+      sys.detail = `:${port}`
+    } catch {
+      sys.progress = 1
+      sys.status = "error"
+      sys.detail = "unreachable"
+    }
+    onUpdate()
+  }
+}
+
+async function checkMemory(
+  root: string,
+  sys: Subsystem,
+  onUpdate: () => void,
+): Promise<number> {
+  sys.progress = 0.3
+  sys.status = "booting"
+  onUpdate()
+
+  await new Promise(r => setTimeout(r, 100))
+
+  const count = countMemories(root)
+  sys.progress = 1
+  sys.status = "ready"
+  sys.detail = `${count} indexed`
+  onUpdate()
+  return count
+}
+
+async function checkSubway(
+  _root: string,
+  sys: Subsystem,
+  onUpdate: () => void,
+): Promise<void> {
+  sys.progress = 0.2
+  sys.status = "connecting"
+  onUpdate()
+
+  if (isStandaloneSubwayLoaded()) {
+    // Standalone extension is handling mesh — report as ready
+    sys.progress = 1
+    sys.status = "ready"
+    sys.detail = "standalone ext"
+    onUpdate()
+    return
+  }
+
+  const client = getMeshClient()
+  if (!client) {
+    sys.progress = 1
+    sys.status = "warning"
+    sys.detail = "not initialized"
+    onUpdate()
+    return
+  }
+
+  sys.progress = 0.5
+  onUpdate()
+
+  // Wait up to 3s for the mesh client to register
+  const deadline = Date.now() + 3000
+  while (Date.now() < deadline) {
+    if (client.registered) break
+    await new Promise(r => setTimeout(r, 100))
+  }
+
+  if (client.registered) {
+    sys.progress = 1
+    sys.status = "ready"
+    sys.detail = client.name
+    onUpdate()
+  } else {
+    sys.progress = 1
+    sys.status = "warning"
+    sys.detail = "offline"
+    onUpdate()
+  }
+}
+
+async function checkAutoCommit(
+  root: string,
+  sys: Subsystem,
+  onUpdate: () => void,
+): Promise<void> {
+  sys.progress = 0.5
+  sys.status = "booting"
+  onUpdate()
+
+  await new Promise(r => setTimeout(r, 50))
+
+  const running = isAutoCommitRunning(root)
+  sys.progress = 1
+  sys.status = running ? "ready" : "warning"
+  sys.detail = running ? "active (120s)" : "inactive"
+  onUpdate()
+}
+
+async function checkJournal(
+  root: string,
+  sys: Subsystem,
+  onUpdate: () => void,
+): Promise<number> {
+  sys.progress = 0.3
+  sys.status = "booting"
+  onUpdate()
+
+  await new Promise(r => setTimeout(r, 80))
+
+  const count = countJournalEntries(root)
+  sys.progress = 1
+  sys.status = "ready"
+  sys.detail = `${count} entries`
+  onUpdate()
+  return count
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+
+  const configPath = join(root, ".jfl", "config.json")
+  let projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  let projectType = config.type ?? "gtm"
+  if (!config.name && existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(configPath, "utf-8"))
+      projectName = cfg.name ?? projectName
+      projectType = cfg.type ?? projectType
+    } catch {}
+  }
+
+  const version = getJflVersion()
+  const branch = ctx.session.branch
+  const model = (ctx.pi.model?.id ?? "").split("/").pop() ?? "detecting..."
+
+  const bootState: BootState = {
+    systems: new Map([
+      ["hub", { name: "Hub", status: "booting", progress: 0, detail: "", startTime: Date.now() }],
+      ["memory", { name: "Memory", status: "booting", progress: 0, detail: "", startTime: Date.now() }],
+      ["subway", { name: "Subway", status: "booting", progress: 0, detail: "", startTime: Date.now() }],
+      ["autocommit", { name: "Auto-commit", status: "booting", progress: 0, detail: "", startTime: Date.now() }],
+      ["journal", { name: "Journal", status: "booting", progress: 0, detail: "", startTime: Date.now() }],
+    ]),
+    context: {
+      lastJournalTitle: "Loading...",
+      phase: "Loading...",
+      serviceCount: 0,
+      evalScore: null,
+      evalDelta: null,
+    },
+    agents: [{ name: "Scanning...", status: "idle", detail: "" }],
+    projectName,
+    projectType,
+    version,
+    model,
+    branch,
+    allGreen: false,
+    bootComplete: false,
+    bootStartTime: Date.now(),
+  }
+
+  if (!ctx.ui.hasUI) {
+    await runChecksHeadless(root, ctx)
+    return
+  }
+
+  await ctx.ui.custom<void>((tui: any, theme: PiTheme, _kb: any, done: (r: void) => void) => {
+    let renderInterval: ReturnType<typeof setInterval> | null = null
+    let dismissed = false
+
+    function requestRender(): void {
+      if (dismissed) return
+      tui.requestRender()
+    }
+
+    renderInterval = setInterval(requestRender, 150)
+
+    const systemChecks = Promise.allSettled([
+      checkHub(root, bootState.systems.get("hub")!, requestRender),
+      checkMemory(root, bootState.systems.get("memory")!, requestRender),
+      checkSubway(root, bootState.systems.get("subway")!, requestRender),
+      checkAutoCommit(root, bootState.systems.get("autocommit")!, requestRender),
+      checkJournal(root, bootState.systems.get("journal")!, requestRender),
+    ])
+
+    const contextLoad = Promise.resolve().then(() => {
+      bootState.context.lastJournalTitle = getLastJournalTitle(root)
+      bootState.context.phase = getCurrentPhase(root)
+      bootState.context.serviceCount = getServiceCount(root)
+      const evalData = getEvalData(root)
+      bootState.context.evalScore = evalData.score
+      bootState.context.evalDelta = evalData.delta
+      bootState.agents = getActiveAgents(root)
+      requestRender()
+    })
+
+    Promise.all([systemChecks, contextLoad]).then(() => {
+      const allReady = Array.from(bootState.systems.values()).every(
+        s => s.status === "ready" || s.status === "warning"
+      )
+      bootState.allGreen = allReady
+      bootState.bootComplete = true
+      requestRender()
+
+      setTimeout(() => {
+        if (!dismissed) {
+          dismissed = true
+          if (renderInterval) clearInterval(renderInterval)
+          done(undefined)
+        }
+      }, 1200)
+    })
+
+    return {
+      handleInput(key: string) {
+        if (key === "\x1b" || key === "q" || key === "\r" || key === " ") {
+          if (bootState.bootComplete) {
+            dismissed = true
+            if (renderInterval) clearInterval(renderInterval)
+            done(undefined)
+          }
+        }
+      },
+
+      render(width: number): string[] {
+        return renderBootScreen(bootState, width, theme)
+      },
+
+      dispose() {
+        dismissed = true
+        if (renderInterval) clearInterval(renderInterval)
+      },
+
+      invalidate() {},
+    }
+  }, {
+    overlay: true,
+    overlayOptions: { dismissOnEsc: false },
+  })
+
+  const readyCount = Array.from(bootState.systems.values()).filter(s => s.status === "ready").length
+  const totalCount = bootState.systems.size
+  const elapsed = ((Date.now() - bootState.bootStartTime) / 1000).toFixed(1)
+  ctx.log(`Mission Control: ${readyCount}/${totalCount} systems ready in ${elapsed}s`, "debug")
+}
+
+async function runChecksHeadless(root: string, ctx: PiContext): Promise<void> {
+  const noop = () => {}
+  const hubSys: Subsystem = { name: "Hub", status: "booting", progress: 0, detail: "", startTime: Date.now() }
+  const memSys: Subsystem = { name: "Memory", status: "booting", progress: 0, detail: "", startTime: Date.now() }
+
+  await Promise.allSettled([
+    checkHub(root, hubSys, noop),
+    checkMemory(root, memSys, noop),
+  ])
+
+  ctx.log(`Hub: ${hubSys.status} ${hubSys.detail} | Memory: ${memSys.status} ${memSys.detail}`, "debug")
+}