jfl 0.9.2 → 0.9.4

package/packages/pi/extensions/index.ts

@@ -38,6 +38,9 @@ import { setupFooter } from "./footer.js"
 import { setupShortcuts } from "./shortcuts.js"
 import { setupNotifications } from "./notifications.js"
 import { setupBookmarks } from "./bookmarks.js"
+import { setupSubwayMesh, injectMeshContext, onMeshShutdown } from "./subway-mesh.js"
+import { fireStartupBriefing } from "./startup-briefing.js"
+import { setupHeader, setHeaderHubStatus, setHeaderAutoCommit, setHeaderBranch, refreshHeaderData } from "./header.js"
 import { setupOnboarding as setupOnboardingV1 } from "./onboarding-v1.js"
 import { setupOnboarding as setupOnboardingV2 } from "./onboarding-v2.js"
 import { setupOnboarding as setupOnboardingV3 } from "./onboarding-v3.js"
@@ -82,9 +85,24 @@ function getCurrentBranch(root: string): string {
   }
 }
 
+// ─── Dedup guard ─────────────────────────────────────────────────────────────
+// When developing jfl-cli locally, Pi discovers the extension from BOTH the
+// local packages/pi/ AND the global npm-installed jfl package. Both run as
+// separate factory calls in the same process. This guard ensures only the
+// first one initializes — which is the local dev version (Pi loads project-
+// local extensions before global packages).
+
+const JFL_LOADED = Symbol.for("jfl-pi-extension-loaded")
+
 // ─── Pi extension factory function ───────────────────────────────────────────
 
 export default async function jflExtension(pi: any): Promise<void> {
+  // Skip if already loaded from another source (dedup)
+  if ((globalThis as any)[JFL_LOADED]) {
+    return
+  }
+  (globalThis as any)[JFL_LOADED] = true
+
   let projectCwd = process.cwd()
   let latestPiCtx: any = null
 
@@ -235,6 +253,10 @@ export default async function jflExtension(pi: any): Promise<void> {
         if (latestPiCtx?.ui?.setFooter) latestPiCtx.ui.setFooter(factory)
       },
 
+      setHeader: (factory: any) => {
+        if (latestPiCtx?.ui?.setHeader) latestPiCtx.ui.setHeader(factory)
+      },
+
       setEditorText: (text: string) => {
         if (latestPiCtx?.ui?.setEditorText) latestPiCtx.ui.setEditorText(text)
       },
@@ -307,6 +329,9 @@ export default async function jflExtension(pi: any): Promise<void> {
 
     pi.setSessionName(`JFL: ${projectName}`)
 
+    // ─── Header first — replace Pi's default before anything renders ──
+    setupHeader(ctx, config)
+
     // ─── Hub first, then animation + tools in parallel ─────────────
     // Hub must be up before onboarding probes fire.
     // setupContext starts hub + registers jfl_context tool.
@@ -331,6 +356,8 @@ export default async function jflExtension(pi: any): Promise<void> {
       await setupServiceSkills(ctx, config)
       await setupHubTools(ctx, config)
 
+      await setupSubwayMesh(ctx, config)
+
       initStratusBridge(projectCwd)
       initAgentNames(projectCwd)
       await setupPeterParker(ctx, config)
@@ -350,10 +377,17 @@ export default async function jflExtension(pi: any): Promise<void> {
     ])
 
     ctx.log(`JFL: ${projectName} — session ready`)
+
+    // Fire startup briefing — gathers synopsis, PRs, team activity, next actions
+    // and steers the model to produce a concise "here's where things stand" greeting
+    if (config.pi?.auto_start !== false) {
+      await fireStartupBriefing(ctx, config)
+    }
   })
 
   pi.on("session_shutdown", async (_event: unknown, piCtx: any) => {
     latestPiCtx = piCtx
+    onMeshShutdown()
     await onPortfolioShutdown(ctx)
     await onShutdown(ctx)
     await onMapBridgeShutdown(ctx)
@@ -366,12 +400,18 @@ export default async function jflExtension(pi: any): Promise<void> {
 
   pi.on("before_agent_start", async (event: any, _piCtx: any) => {
     const result = await injectContext(ctx, event)
-    if (result?.systemPromptAddition) {
+    const meshState = injectMeshContext()
+    const additions = [
+      result?.systemPromptAddition,
+      meshState,
+    ].filter(Boolean).join("\n\n")
+
+    if (additions) {
       const current = (event.systemPrompt as string) ?? ""
       return {
         systemPrompt: current
-          ? `${current}\n\n${result.systemPromptAddition}`
-          : result.systemPromptAddition,
+          ? `${current}\n\n${additions}`
+          : additions,
       }
     }
   })

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

@@ -110,9 +110,9 @@ export function setupMemoryTool(ctx: PiContext): void {
         })
 
         if (!resp.ok) return "Failed to add memory — hub returned error."
-        const data = await resp.json() as { ok?: boolean; id?: string }
-        return data.ok
-          ? `Memory added: "${title}" (${type ?? "note"})`
+        const data = await resp.json() as { ok?: boolean; id?: string | number }
+        return (data.ok || data.id)
+          ? `Memory added: "${title}" (${type ?? "note"})${data.id ? ` [id: ${data.id}]` : ""}`
           : "Memory add returned unexpected response."
       } catch {
         return "Memory add unavailable — Context Hub may not be running."

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

@@ -1,17 +1,24 @@
 /**
- * Onboarding V2 — Full-screen cinematic startup
+ * Onboarding V2 — Cinematic boot sequence
  *
- * Owns the entire terminal. Covers Pi's startup noise with full-width blanking.
- * Flow: TENET square → system probes → mission brief → ready
- * The overlay IS the greeting — no model auto-trigger needed.
+ * 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 Full-screen startup overlay with live probes and mission briefing
+ * 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 } 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 ──────────────────────────────────────────────────────────────────
 
@@ -40,25 +47,6 @@ interface Sys {
   detail: string
 }
 
-interface Brief {
-  label: string
-  value: string
-  color: "gold" | "warm" | "dim" | "green" | "red"
-}
-
-interface Mission {
-  name: string
-  branch: string
-  recentWork: string[]
-  issuesActive: string[]
-  issuesBacklog: string[]
-  policyHead: string
-  training: string
-  journals: number
-  sessions: number
-  warnings: string[]
-}
-
 // ─── Probes ──────────────────────────────────────────────────────────────────
 
 async function probeHub(root: string): Promise<{ok: boolean; detail: string}> {
@@ -109,7 +97,7 @@ async function probeAutoCommit(): Promise<{ok: boolean; detail: string}> {
     } catch {}
     if (i < 3) await sleep(1000)
   }
-  return {ok:false, detail:"starting…"}
+  return {ok:false, detail:"–"}
 }
 
 async function probeEval(root: string): Promise<{ok: boolean; detail: string}> {
@@ -142,89 +130,14 @@ function readToken(root: string): string {
 }
 function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)) }
 
-// ─── Mission data ────────────────────────────────────────────────────────────
-
-function gather(root: string, config: JflConfig): Mission {
-  const name = config.name ?? root.split("/").pop() ?? "project"
-
-  let branch = "main"
-  try { branch = execSync("git branch --show-current", {cwd:root, stdio:["pipe","pipe","ignore"]}).toString().trim() || "main" } catch {}
-
-  const recentWork: string[] = []
-  let journals = 0, sessions = 0
-  const jDir = join(root, ".jfl", "journal")
-  if (existsSync(jDir)) {
-    const files = readdirSync(jDir).filter(f => f.endsWith(".jsonl"))
-    sessions = files.length
-    const all: Array<{ts:string,title:string}> = []
-    for (const f of files) {
-      try {
-        const lines = readFileSync(join(jDir, f), "utf-8").trim().split("\n").filter(Boolean)
-        journals += lines.length
-        for (const l of lines) { try { const e = JSON.parse(l); if (e.title) all.push({ts:e.ts||"",title:e.title}) } catch {} }
-      } catch {}
-    }
-    all.sort((a,b) => b.ts.localeCompare(a.ts))
-    for (const e of all.slice(0,4)) recentWork.push(e.title.length > 55 ? e.title.slice(0,52)+"…" : e.title)
-  }
-
-  const issuesActive: string[] = [], issuesBacklog: string[] = []
-  try {
-    const r = execSync('gh issue list --label jfl/in-progress --limit 3 --json number,title 2>/dev/null', {cwd:root, timeout:5000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]})
-    for (const i of JSON.parse(r||"[]") as any[]) issuesActive.push(`#${i.number} ${i.title}`)
-  } catch {}
-  try {
-    const r = execSync('gh issue list --label jfl/backlog --limit 3 --json number,title 2>/dev/null', {cwd:root, timeout:5000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]})
-    for (const i of JSON.parse(r||"[]") as any[]) issuesBacklog.push(`#${i.number} ${i.title}`)
-  } catch {}
-
-  let policyHead = ""
-  try {
-    const p = join(root, ".jfl", "checkpoints", "policy-head-v2.json")
-    if (existsSync(p)) { const d = JSON.parse(readFileSync(p,"utf-8")); policyHead = `${((d.val_accuracy||0)*100).toFixed(1)}% · ${d.training_examples||"?"} examples` }
-  } catch {}
-
-  let training = ""
-  try {
-    const p = join(root, ".jfl", "training-buffer.jsonl")
-    if (existsSync(p)) training = `${readFileSync(p,"utf-8").trim().split("\n").filter(Boolean).length} tuples`
-  } catch {}
-
-  const warnings: string[] = []
-  try {
-    const b = execSync("git branch", {cwd:root, timeout:3000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]})
-    const unmerged = b.split("\n").filter(l => l.trim().startsWith("session-")).length
-    if (unmerged > 0) warnings.push(`${unmerged} unmerged branches`)
-  } catch {}
-  try {
-    if (execSync("git status --porcelain", {cwd:root, timeout:3000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]}).trim())
-      warnings.push("uncommitted changes")
-  } catch {}
-
-  return { name, branch, recentWork, issuesActive, issuesBacklog, policyHead, training, journals, sessions, warnings }
-}
-
-/** Structured briefing for steer/context injection */
-export function buildStartupBriefing(mission: Mission): string {
-  const l: string[] = ["## Session Briefing",""]
-  if (mission.issuesActive.length) { l.push("IN PROGRESS:"); mission.issuesActive.forEach(i => l.push(`  ${i}`)); l.push("") }
-  if (mission.issuesBacklog.length) { l.push("BACKLOG:"); mission.issuesBacklog.forEach(i => l.push(`  ${i}`)); l.push("") }
-  if (mission.policyHead) l.push(`PolicyHead: ${mission.policyHead}`)
-  if (mission.training) l.push(`Training: ${mission.training}`)
-  if (mission.journals) l.push(`Journal: ${mission.journals} entries · ${mission.sessions} sessions`)
-  l.push("")
-  if (mission.recentWork.length) { l.push("RECENT:"); mission.recentWork.forEach(w => l.push(`  - ${w}`)); l.push("") }
-  if (mission.warnings.length) { l.push("WARNINGS:"); mission.warnings.forEach(w => l.push(`  ⚠ ${w}`)) }
-  return l.join("\n")
-}
-
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promise<void> {
   const root = ctx.session.projectRoot
   if (!ctx.ui.hasUI) return
 
-  const mission = gather(root, config)
+  const projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  const branch = ctx.session.branch
 
   const systems: Sys[] = [
     {name:"Hub",         status:"wait", detail:""},
@@ -244,35 +157,22 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
     () => probeTraining(root),
   ]
 
-  // Build brief lines
-  const brief: Brief[] = []
-  if (mission.policyHead) brief.push({label:"PolicyHead", value:mission.policyHead, color:"gold"})
-  if (mission.training) brief.push({label:"Training", value:mission.training, color:"gold"})
-  if (mission.journals) brief.push({label:"Journal", value:`${mission.journals} entries · ${mission.sessions} sessions`, color:"dim"})
-  for (const i of mission.issuesActive.slice(0,2)) brief.push({label:"▸ Active", value:i, color:"green"})
-  for (const i of mission.issuesBacklog.slice(0,2)) brief.push({label:"  Backlog", value:i, color:"dim"})
-  for (const w of mission.recentWork.slice(0,3)) brief.push({label:"", value:w, color:"warm"})
-  for (const w of mission.warnings) brief.push({label:"⚠", value:w, color:"red"})
-
   await ctx.ui.custom<void>((tui: any, theme: PiTheme, _kb: any, done: (r: void) => void) => {
-    let phase: "square"|"glow"|"systems"|"brief"|"ready" = "square"
+    let phase: "square"|"glow"|"systems"|"ready" = "square"
     let sqProg = 0
     let glow = false
     let sysRevealed = 0
-    let briefRevealed = 0
     let readyTick = 0
     let timer: ReturnType<typeof setTimeout>|null = null
     let dead = false
 
-    // Timing
-    const SQ_MS    = 50      // per letter
-    const GLOW_MS  = 700     // hold after square
-    const GLW2SYS  = 500     // glow → systems
-    const SYS_MS   = 250     // per system row
-    const SETTLE   = 200     // probe settle poll
-    const BRF_MS   = 100     // per brief line
-    const BRF2RDY  = 400     // brief → ready
-    const RDY_HOLD = 2000    // show ready then dismiss
+    // ── 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
@@ -287,12 +187,12 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
     const rd = (s: string) => theme.fg(RED, s)
 
     // ── ANSI helpers ──
-    function strip(s: string) { return s.replace(/\x1b\[[0-9;]*m/g, "") }
+    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 - strip(line).length))
+      return line + " ".repeat(Math.max(0, width - stripLen(line)))
     }
     function center(text: string, width: number) {
-      const vis = strip(text).length
+      const vis = stripLen(text)
       const left = Math.max(0, Math.floor((width - vis) / 2))
       return " ".repeat(left) + text
     }
@@ -306,32 +206,37 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
     // ── Phase: Systems ──
     function doSystems() {
       phase = "systems"
-      // Fire all probes
+      // 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; tui.requestRender() })
-          .catch(() => { s.status = "err"; s.detail = "timeout"; tui.requestRender() })
+        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 revealSys() {
       if (sysRevealed < systems.length) { sysRevealed++; tick(revealSys, SYS_MS) }
       else waitProbes()
     }
+
     function waitProbes() {
       if (systems.some(s => s.status === "probe")) tick(waitProbes, SETTLE)
-      else tick(doBrief, 300)
-    }
-
-    // ── Phase: Brief ──
-    function doBrief() {
-      phase = "brief"
-      briefRevealed = 0
-      tickBrief()
-    }
-    function tickBrief() {
-      if (briefRevealed < brief.length) { briefRevealed++; tick(tickBrief, BRF_MS) }
-      else tick(doReady, BRF2RDY)
+      else {
+        // Refresh header with final probe data
+        refreshHeaderData(root, config)
+        tick(doReady, 200)
+      }
     }
 
     // ── Phase: Ready ──
@@ -341,12 +246,12 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
       tickReady()
     }
     function tickReady() {
-      if (readyTick < 3) { readyTick++; tick(tickReady, 350) }
+      if (readyTick < 3) { readyTick++; tick(tickReady, 250) }
       else tick(() => { if (!dead) done(undefined) }, RDY_HOLD)
     }
 
-    // Kick
-    tick(doSquare, 150)
+    // Kick off
+    tick(doSquare, 100)
 
     // ── Renderers ──
 
@@ -376,46 +281,38 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
 
     function renderSystems(W: number): string[] {
       const out: string[] = []
-      const inner = Math.min(W - 4, 52)
+      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 = g(s.detail) }
-        else if (s.status === "err") { icon = rd("✗"); name = rd(nm); det = rd(s.detail) }
+        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("") }
+        else                           { icon = d("○"); name = d(nm); det = d("") }
         out.push(`${lp}  ${icon}  ${name} ${det}`)
       }
       return out
     }
 
-    function renderBrief(W: number): string[] {
-      const out: string[] = []
-      const inner = Math.min(W - 4, 52)
-      const lp = " ".repeat(Math.max(0, Math.floor((W - inner) / 2)))
-
-      // Divider
-      out.push(lp + d("─".repeat(Math.max(8, inner - 10))))
-      out.push("")
-
-      for (let i = 0; i < Math.min(briefRevealed, brief.length); i++) {
-        const b = brief[i]
-        const color = b.color === "gold" ? g : b.color === "green" ? gr : b.color === "red" ? rd : b.color === "warm" ? w : d
-        if (b.label) out.push(`${lp}  ${d(b.label.padEnd(12))} ${color(b.value)}`)
-        else out.push(`${lp}    ${color(b.value)}`)
-      }
-      return out
-    }
-
     function renderReady(W: number): string[] {
       const out: string[] = []
+      const sep = d(" · ")
       out.push("")
-      if (readyTick >= 1) out.push(center(theme.bold(g(mission.name.toUpperCase())), W))
-      if (readyTick >= 2) out.push(center(d(mission.branch), W))
-      if (readyTick >= 3) out.push(center(d("ready"), W))
+      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 out
     }
 
@@ -439,14 +336,8 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
         if (phase !== "square" && phase !== "glow") content.push("")
 
         // Systems
-        if (phase === "systems" || phase === "brief" || phase === "ready") {
+        if (phase === "systems" || phase === "ready") {
           content.push(...renderSystems(W))
-          content.push("")
-        }
-
-        // Brief
-        if (phase === "brief" || phase === "ready") {
-          content.push(...renderBrief(W))
         }
 
         // Ready
@@ -454,22 +345,16 @@ export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promis
           content.push(...renderReady(W))
         }
 
-        // Skip hint
-        if (phase !== "ready") {
+        // Skip hint (during animation only)
+        if (phase === "square" || phase === "glow" || phase === "systems") {
           content.push("", center(d("press any key to skip"), W))
         }
 
-        // Build full-screen output: vertically center content, fill everything else with blanks
+        // Vertically center, fill everything with blanks (covers Pi startup)
         const topPad = Math.max(1, Math.floor((H - content.length) / 2))
         const out: string[] = []
-
-        // Fill top with blank full-width lines (covers Pi startup text)
         for (let i = 0; i < topPad; i++) out.push(" ".repeat(W))
-
-        // Content lines, each padded to full width
         for (const line of content) out.push(pad(line, W))
-
-        // Fill bottom
         while (out.length < H) out.push(" ".repeat(W))
 
         return out

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

@@ -14,6 +14,7 @@ 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 ──────────────────────────────────────────────
 
@@ -454,7 +455,7 @@ async function checkMemory(
 }
 
 async function checkSubway(
-  root: string,
+  _root: string,
   sys: Subsystem,
   onUpdate: () => void,
 ): Promise<void> {
@@ -462,30 +463,40 @@ async function checkSubway(
   sys.status = "connecting"
   onUpdate()
 
-  const hubBaseUrl = readHubUrl(root)
-  const token = readToken(root)
+  if (isStandaloneSubwayLoaded()) {
+    // Standalone extension is handling mesh — report as ready
+    sys.progress = 1
+    sys.status = "ready"
+    sys.detail = "standalone ext"
+    onUpdate()
+    return
+  }
 
-  try {
-    sys.progress = 0.5
+  const client = getMeshClient()
+  if (!client) {
+    sys.progress = 1
+    sys.status = "warning"
+    sys.detail = "not initialized"
     onUpdate()
+    return
+  }
 
-    const resp = await fetch(`${hubBaseUrl}/api/events?pattern=*&limit=1`, {
-      headers: token ? { Authorization: `Bearer ${token}` } : {},
-      signal: AbortSignal.timeout(3000),
-    })
+  sys.progress = 0.5
+  onUpdate()
 
-    if (resp.ok) {
-      sys.progress = 1
-      sys.status = "ready"
-      sys.detail = "connected"
-      onUpdate()
-    } else {
-      sys.progress = 1
-      sys.status = "warning"
-      sys.detail = "degraded"
-      onUpdate()
-    }
-  } catch {
+  // 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"

package/packages/pi/extensions/service-skills.ts

@@ -199,8 +199,13 @@ export async function setupServiceSkills(ctx: PiContext, _config: JflConfig): Pr
     },
   })
 
-  // Register per-service commands (e.g., /jfl-cli status, /jfl-platform logs)
+  // Register per-service commands (e.g., /subclaw status, /subway-fe logs)
+  // Skip "subway" — /subway is owned by the mesh command (subway-mesh.ts or standalone ext).
+  // The jfl_service tool still covers all services including subway.
+  const reservedNames = new Set(["subway"])
+
   for (const svc of services) {
+    if (reservedNames.has(svc.name)) continue
     ctx.registerCommand({
       name: svc.name,
       description: `${svc.description} — commands: ${svc.commands.join(", ")}`,

package/packages/pi/extensions/session.ts

@@ -201,7 +201,13 @@ export async function onShutdown(ctx: PiContext): Promise<void> {
 
   // ── 5. Merge session branch back (parity with CC session-cleanup.sh) ─
   if (branch.startsWith("session-")) {
-    try {
+    // Guard: if git is already on a DIFFERENT branch (e.g. a new session started),
+    // don't merge — the old session branch may already be gone.
+    const currentGitBranch = getCurrentBranch(root)
+    if (currentGitBranch !== branch) {
+      ctx.log(`Skipping merge — git is on ${currentGitBranch}, not ${branch} (new session likely started)`, "debug")
+      ctx.ui.notify(`  ⚠ Skipped merge — already on ${currentGitBranch}`, { level: "info" })
+    } else try {
       // Get working branch from config or default to main
       let workingBranch = "main"
       const configPath = join(root, ".jfl", "config.json")