jfl 0.8.1 → 0.9.1

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

@@ -0,0 +1,247 @@
+/**
+ * Hub Tools Extension
+ *
+ * Registers tools for direct Context Hub interaction that were previously
+ * only available via MCP: events_publish, events_recent, context_status,
+ * context_sessions, query_experiment_history.
+ *
+ * Closes the parity gap between Claude Code (MCP) and Pi (extensions).
+ *
+ * @purpose Hub API tools — events, status, sessions, experiments (MCP parity)
+ */
+
+import type { PiContext, JflConfig } from "./types.js"
+import { hubUrl, authToken } from "./map-bridge.js"
+
+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()
+}
+
+export async function setupHubTools(ctx: PiContext, _config: JflConfig): Promise<void> {
+
+  // ─── jfl_events_publish ──────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_events_publish",
+    description: "Publish an event to the MAP event bus. Use to signal state changes, completions, or trigger flows.",
+    promptSnippet: "Publish event to MAP bus",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Event type (e.g. 'task:completed', 'eval:scored', 'custom:my-event')",
+        },
+        data: {
+          type: "string",
+          description: "Event data as JSON string",
+        },
+      },
+      required: ["type"],
+    },
+    async handler(input) {
+      const { type, data } = input as { type: string; data?: string }
+      try {
+        let eventData: unknown = {}
+        if (data) {
+          try { eventData = JSON.parse(data) } catch { eventData = { message: data } }
+        }
+
+        await hubFetch("/api/events", "POST", {
+          type,
+          source: `pi:${ctx.session.id}`,
+          data: eventData,
+          ts: new Date().toISOString(),
+        })
+        return `Event published: ${type}`
+      } catch {
+        return "Event publish failed — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── jfl_events_recent ──────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_events_recent",
+    description: "Get recent events from the MAP event bus. Check what happened in the system — agent actions, eval results, flow triggers.",
+    promptSnippet: "View recent MAP events",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of events to return (default: 20)",
+        },
+        type: {
+          type: "string",
+          description: "Filter by event type prefix (e.g. 'eval:', 'hook:', 'task:')",
+        },
+      },
+    },
+    async handler(input) {
+      const { limit, type } = input as { limit?: number; type?: string }
+      try {
+        const params = new URLSearchParams()
+        if (limit) params.set("limit", String(limit))
+        if (type) params.set("type", type)
+
+        const data = await hubFetch(`/api/events?${params}`)
+        const events = data.events ?? data ?? []
+
+        if (!Array.isArray(events) || events.length === 0) return "No recent events."
+
+        return events
+          .slice(0, limit ?? 20)
+          .map((e: any) => {
+            const ts = e.ts ? new Date(e.ts).toLocaleTimeString() : "?"
+            const src = e.source ?? "?"
+            return `[${ts}] ${e.type} (${src})${e.data ? " — " + JSON.stringify(e.data).slice(0, 100) : ""}`
+          })
+          .join("\n")
+      } catch {
+        return "Events unavailable — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── jfl_context_status ─────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_context_status",
+    description: "Check Context Hub status — available sources, memory index health, connected services.",
+    promptSnippet: "Check Context Hub health",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    async handler() {
+      try {
+        const data = await hubFetch("/api/context/status")
+
+        const lines: string[] = ["Context Hub Status:"]
+        for (const [k, v] of Object.entries(data)) {
+          if (typeof v === "object" && v !== null) {
+            lines.push(`  ${k}: ${JSON.stringify(v)}`)
+          } else {
+            lines.push(`  ${k}: ${v}`)
+          }
+        }
+        return lines.join("\n")
+      } catch {
+        return "Context Hub status unavailable."
+      }
+    },
+  })
+
+  // ─── jfl_context_sessions ────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_context_sessions",
+    description: "See activity from other sessions — what other agents/users are working on. Informational only.",
+    promptSnippet: "View other session activity",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of sessions to return (default: 5)",
+        },
+      },
+    },
+    async handler(input) {
+      const { limit } = input as { limit?: number }
+      try {
+        // Try the sessions endpoint
+        const data = await hubFetch(`/api/context/sessions?limit=${limit ?? 5}`)
+        const sessions = data.sessions ?? data ?? []
+
+        if (!Array.isArray(sessions) || sessions.length === 0) return "No other sessions found."
+
+        return sessions
+          .map((s: any) => {
+            const age = s.lastSeen ? `(${new Date(s.lastSeen).toLocaleString()})` : ""
+            return `${s.branch ?? s.id ?? "?"} ${age} — ${s.summary ?? s.status ?? "active"}`
+          })
+          .join("\n")
+      } catch {
+        // Fallback: read journal files to find other sessions
+        try {
+          const { execSync } = await import("child_process")
+          const journalDir = `${ctx.session.projectRoot}/.jfl/journal`
+          const files = execSync(`ls -t ${journalDir}/*.jsonl 2>/dev/null | head -5`, {
+            encoding: "utf-8",
+          }).trim()
+
+          if (!files) return "No other sessions found."
+
+          return files.split("\n")
+            .map(f => {
+              const branch = f.split("/").pop()?.replace(".jsonl", "") ?? "?"
+              return `Session: ${branch}`
+            })
+            .join("\n")
+        } catch {
+          return "Sessions unavailable."
+        }
+      }
+    },
+  })
+
+  // ─── jfl_experiment_history ─────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_experiment_history",
+    description: "Search past experiments, their outcomes, and what was learned. Useful for avoiding repeat experiments.",
+    promptSnippet: "Search experiment history",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query for experiment history",
+        },
+        limit: {
+          type: "number",
+          description: "Max results (default: 10)",
+        },
+      },
+      required: ["query"],
+    },
+    async handler(input) {
+      const { query, limit } = input as { query: string; limit?: number }
+      try {
+        const data = await hubFetch("/api/eval/trajectory", "GET")
+        const entries = data.entries ?? data ?? []
+
+        if (!Array.isArray(entries) || entries.length === 0) return "No experiment history found."
+
+        // Filter by query (simple text match)
+        const queryLower = query.toLowerCase()
+        const filtered = entries
+          .filter((e: any) => {
+            const text = JSON.stringify(e).toLowerCase()
+            return text.includes(queryLower)
+          })
+          .slice(0, limit ?? 10)
+
+        if (filtered.length === 0) return `No experiments matching "${query}".`
+
+        return filtered
+          .map((e: any) => {
+            const ts = e.ts ? new Date(e.ts).toLocaleDateString() : "?"
+            const score = e.composite != null ? ` (score: ${e.composite})` : ""
+            return `[${ts}]${score} ${e.label ?? e.summary ?? JSON.stringify(e).slice(0, 100)}`
+          })
+          .join("\n")
+      } catch {
+        return "Experiment history unavailable — Context Hub may not be running."
+      }
+    },
+  })
+}

package/packages/pi/extensions/index.ts

@@ -32,6 +32,8 @@ import { setupEvalTool } from "./eval-tool.js"
 import { setupPolicyHeadTool } from "./policy-head-tool.js"
 import { setupTrainingBufferTool, onTrainingAgentEnd } from "./training-buffer-tool.js"
 import { setupAutoresearch } from "./autoresearch.js"
+import { setupServiceSkills } from "./service-skills.js"
+import { setupHubTools } from "./hub-tools.js"
 import { setupFooter } from "./footer.js"
 import { setupShortcuts } from "./shortcuts.js"
 import { setupNotifications } from "./notifications.js"
@@ -319,6 +321,8 @@ export default async function jflExtension(pi: any): Promise<void> {
       await setupPolicyHeadTool(ctx, config)
       await setupTrainingBufferTool(ctx, config)
       await setupAutoresearch(ctx, config)
+      await setupServiceSkills(ctx, config)
+      await setupHubTools(ctx, config)
 
       initStratusBridge(projectCwd)
       initAgentNames(projectCwd)
@@ -347,15 +351,19 @@ export default async function jflExtension(pi: any): Promise<void> {
           content: [
             `JFL session ready: "${projectName}" on branch ${ctx.session.branch}.`,
             "",
-            "You have full project context injected in your system prompt (CLAUDE.md + recent journal + knowledge docs).",
-            "Tools available: jfl_context, jfl_memory_search, jfl_hud, jfl_journal.",
+            "Your system prompt already contains full project context: CLAUDE.md, recent journal entries, knowledge docs, and code headers.",
+            "Everything was loaded during the boot screen. You do NOT need to call any tools.",
             "",
-            "Greet the user naturally with a brief status:",
-            "- What was worked on recently (from your injected context)",
+            "DO NOT call jfl_context, jfl_hud, jfl_memory_search, or run any bash commands at startup.",
+            "DO NOT run session-sync.sh, jfl-doctor.sh, or read journal files.",
+            "All of that is already done and injected into your system prompt.",
+            "",
+            "Just greet the user naturally with a brief status (3-5 lines):",
+            "- What was worked on recently (from the journal entries in your system prompt)",
             "- Current phase and any blockers",
             "- A suggested next action",
             "",
-            "Keep it to 3-5 lines. No setup noise. Just be ready to work.",
+            "No tool calls. No setup noise. Just talk.",
             "Write journal entries as you work. Capture decisions immediately.",
           ].join("\n"),
           display: false,
@@ -380,7 +388,31 @@ export default async function jflExtension(pi: any): Promise<void> {
     latestPiCtx = piCtx
     const result = await injectContext(ctx, event)
     if (result?.systemPromptAddition) {
-      const current = piCtx.getSystemPrompt?.() ?? ""
+      let current = piCtx.getSystemPrompt?.() ?? ""
+
+      // Strip Path B (Claude Code manual startup) from system prompt.
+      // We're running in Pi with the extension — Path B instructions are
+      // noise that can confuse the LLM into running manual startup commands.
+      const pathBStart = "### Path B: Claude Code / No Extension"
+      const pathBEnd = "### How to Tell Which Path You're On"
+      const startIdx = current.indexOf(pathBStart)
+      const endIdx = current.indexOf(pathBEnd)
+      if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        current = current.slice(0, startIdx) + current.slice(endIdx)
+      }
+
+      // Also strip the "How to Tell" section — it references Path B
+      const howToTell = "### How to Tell Which Path You're On"
+      const howToTellIdx = current.indexOf(howToTell)
+      if (howToTellIdx !== -1) {
+        // Find the next ### or ## heading after it
+        const afterHowToTell = current.slice(howToTellIdx + howToTell.length)
+        const nextHeading = afterHowToTell.search(/\n###? /)
+        if (nextHeading !== -1) {
+          current = current.slice(0, howToTellIdx) + afterHowToTell.slice(nextHeading)
+        }
+      }
+
       return {
         systemPrompt: current
           ? `${current}\n\n${result.systemPromptAddition}`

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

@@ -1,11 +1,10 @@
 /**
  * Memory Tool Extension
  *
- * Registers jfl_memory_search tool with custom TUI rendering.
- * Queries Context Hub memory API and renders results with
- * type-colored headers and collapsible sections.
+ * Registers jfl_memory_search, jfl_memory_add, and jfl_memory_status tools.
+ * Full parity with the Context Hub MCP server's memory tools.
  *
- * @purpose jfl_memory_search tool — themed semantic memory search results
+ * @purpose Memory tools — search, add, and status for project memory
  */
 
 import type { PiContext } from "./types.js"
@@ -13,6 +12,7 @@ import { hubUrl, authToken } from "./map-bridge.js"
 import { memoryRenderCall, memoryRenderResult } from "./tool-renderers.js"
 
 export function setupMemoryTool(ctx: PiContext): void {
+  // ─── jfl_memory_search ───────────────────────────────────────────────────
   ctx.registerTool({
     name: "jfl_memory_search",
     description: "Search JFL project memory — find past decisions, learnings, and patterns across all sessions",
@@ -70,4 +70,84 @@ export function setupMemoryTool(ctx: PiContext): void {
     renderCall: memoryRenderCall,
     renderResult: memoryRenderResult,
   })
+
+  // ─── jfl_memory_add ──────────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_memory_add",
+    description: "Manually add a memory or note to the project memory system. Use to capture insights, decisions, or important context that should persist across sessions.",
+    promptSnippet: "Add a memory/note to project memory",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Title for the memory entry",
+        },
+        content: {
+          type: "string",
+          description: "Content of the memory — the insight, decision, or note",
+        },
+        type: {
+          type: "string",
+          description: "Type of memory entry",
+          enum: ["decision", "discovery", "insight", "note"],
+        },
+      },
+      required: ["title", "content"],
+    },
+    async handler(input) {
+      const { title, content, type } = input as { title: string; content: string; type?: string }
+
+      try {
+        const resp = await fetch(`${hubUrl}/api/memory/add`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+          },
+          body: JSON.stringify({ title, content, type: type ?? "note" }),
+          signal: AbortSignal.timeout(5000),
+        })
+
+        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"})`
+          : "Memory add returned unexpected response."
+      } catch {
+        return "Memory add unavailable — Context Hub may not be running."
+      }
+    },
+  })
+
+  // ─── jfl_memory_status ───────────────────────────────────────────────────
+  ctx.registerTool({
+    name: "jfl_memory_status",
+    description: "Get memory system statistics and health — total entries, indexed count, embedding status.",
+    promptSnippet: "Check memory system health and stats",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    async handler() {
+      try {
+        const resp = await fetch(`${hubUrl}/api/memory/status`, {
+          method: "GET",
+          headers: {
+            ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
+          },
+          signal: AbortSignal.timeout(5000),
+        })
+
+        if (!resp.ok) return "Memory status unavailable."
+        const data = await resp.json() as Record<string, unknown>
+
+        return Object.entries(data)
+          .map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`)
+          .join("\n")
+      } catch {
+        return "Memory status unavailable — Context Hub may not be running."
+      }
+    },
+  })
 }

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

@@ -0,0 +1,214 @@
+/**
+ * Service Skills Bridge
+ *
+ * Scans .claude/skills/ for service-type skills (generated during jfl init
+ * service onboarding) and registers them as Pi commands + tools.
+ * This gives Pi parity with Claude Code's service agent access.
+ *
+ * Service skills in .claude/skills/ have frontmatter `type: service` and
+ * include commands like status, logs, start, stop, restart, health.
+ *
+ * @purpose Bridge .claude/skills/ service agents into Pi sessions
+ */
+
+import { existsSync, readdirSync, readFileSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, JflConfig } from "./types.js"
+
+interface ServiceSkill {
+  name: string
+  description: string
+  servicePath: string
+  commands: string[]
+}
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!match) return {}
+  const fm: Record<string, string> = {}
+  for (const line of match[1].split("\n")) {
+    const [key, ...rest] = line.split(":")
+    if (key && rest.length) {
+      fm[key.trim()] = rest.join(":").trim()
+    }
+  }
+  return fm
+}
+
+function discoverServiceSkills(projectRoot: string): ServiceSkill[] {
+  const claudeSkillsDir = join(projectRoot, ".claude", "skills")
+  if (!existsSync(claudeSkillsDir)) return []
+
+  const skills: ServiceSkill[] = []
+
+  try {
+    const entries = readdirSync(claudeSkillsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const skillPath = join(claudeSkillsDir, entry.name, "SKILL.md")
+      if (!existsSync(skillPath)) continue
+
+      try {
+        const content = readFileSync(skillPath, "utf-8")
+        const fm = parseFrontmatter(content)
+
+        if (fm.type !== "service") continue
+
+        // Extract available commands from the markdown table
+        const commands: string[] = []
+        const cmdMatch = content.match(/\| `(\w+)` \|/g)
+        if (cmdMatch) {
+          for (const m of cmdMatch) {
+            const cmd = m.match(/`(\w+)`/)
+            if (cmd) commands.push(cmd[1])
+          }
+        }
+        // Fallback defaults
+        if (commands.length === 0) {
+          commands.push("status", "logs", "start", "stop", "restart", "health", "recent")
+        }
+
+        skills.push({
+          name: entry.name,
+          description: fm.description || `${entry.name} service agent`,
+          servicePath: fm.service_path || "",
+          commands,
+        })
+      } catch {
+        // Skip unparseable skills
+      }
+    }
+  } catch {
+    // .claude/skills not readable
+  }
+
+  return skills
+}
+
+function runServiceCommand(serviceName: string, command: string, servicePath: string, projectRoot: string): string {
+  // Try jfl service-agent first
+  try {
+    const result = execSync(
+      `jfl service-agent run ${serviceName} ${command}`,
+      { cwd: projectRoot, encoding: "utf-8", timeout: 15000, stdio: ["pipe", "pipe", "pipe"] }
+    )
+    return result.trim()
+  } catch {
+    // Fallback: direct execution based on command type
+  }
+
+  if (!servicePath || !existsSync(servicePath)) {
+    return `Service path not found: ${servicePath}`
+  }
+
+  try {
+    switch (command) {
+      case "status": {
+        const branch = execSync("git branch --show-current", { cwd: servicePath, encoding: "utf-8" }).trim()
+        const lastCommit = execSync("git log -1 --pretty='%h %s (%cr)'", { cwd: servicePath, encoding: "utf-8" }).trim()
+        const dirty = execSync("git status --porcelain", { cwd: servicePath, encoding: "utf-8" }).trim()
+        return [
+          `Service: ${serviceName}`,
+          `Path: ${servicePath}`,
+          `Branch: ${branch}`,
+          `Last commit: ${lastCommit}`,
+          `Working tree: ${dirty ? `${dirty.split("\n").length} changes` : "clean"}`,
+        ].join("\n")
+      }
+
+      case "logs": {
+        return execSync("git log --oneline -10", { cwd: servicePath, encoding: "utf-8" }).trim()
+      }
+
+      case "recent": {
+        const since = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString()
+        try {
+          return execSync(`git log --oneline --since="${since}"`, { cwd: servicePath, encoding: "utf-8" }).trim() || "No changes in last 24h"
+        } catch {
+          return "No changes in last 24h"
+        }
+      }
+
+      case "health": {
+        // Check if package.json exists and has a test script
+        const pkgPath = join(servicePath, "package.json")
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
+          const hasTests = !!pkg.scripts?.test
+          const hasBuild = !!pkg.scripts?.build
+          return [
+            `Service: ${serviceName}`,
+            `Has tests: ${hasTests ? "yes" : "no"}`,
+            `Has build: ${hasBuild ? "yes" : "no"}`,
+            `Dependencies: ${Object.keys(pkg.dependencies || {}).length}`,
+            `Dev dependencies: ${Object.keys(pkg.devDependencies || {}).length}`,
+          ].join("\n")
+        }
+        return `No package.json found at ${servicePath}`
+      }
+
+      default:
+        return `Unknown command: ${command}. Available: status, logs, recent, health`
+    }
+  } catch (err) {
+    return `Error running ${command} on ${serviceName}: ${err}`
+  }
+}
+
+export async function setupServiceSkills(ctx: PiContext, _config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+  const services = discoverServiceSkills(root)
+
+  if (services.length === 0) return
+
+  ctx.log(`Discovered ${services.length} service skill(s): ${services.map(s => s.name).join(", ")}`, "debug")
+
+  // Register a unified service tool
+  ctx.registerTool({
+    name: "jfl_service",
+    description: `Query registered service agents. Available services: ${services.map(s => s.name).join(", ")}. Commands: status, logs, recent, health, start, stop, restart.`,
+    promptSnippet: `Service agents: ${services.map(s => s.name).join(", ")}`,
+    promptGuidelines: [
+      `Use this tool to interact with registered services: ${services.map(s => s.name).join(", ")}`,
+      "Common commands: status (git info), logs (recent commits), recent (24h changes), health (package info)",
+    ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        service: {
+          type: "string",
+          description: `Service name: ${services.map(s => s.name).join(", ")}`,
+          enum: services.map(s => s.name),
+        },
+        command: {
+          type: "string",
+          description: "Command to run on the service",
+          enum: ["status", "logs", "recent", "health", "start", "stop", "restart"],
+        },
+      },
+      required: ["service", "command"],
+    },
+    async handler(input) {
+      const { service, command } = input as { service: string; command: string }
+      const svc = services.find(s => s.name === service)
+      if (!svc) return `Unknown service: ${service}. Available: ${services.map(s => s.name).join(", ")}`
+      return runServiceCommand(service, command, svc.servicePath, root)
+    },
+  })
+
+  // Register per-service commands (e.g., /jfl-cli status, /jfl-platform logs)
+  for (const svc of services) {
+    ctx.registerCommand({
+      name: svc.name,
+      description: `${svc.description} — commands: ${svc.commands.join(", ")}`,
+      async handler(args: string, _ctx: PiContext) {
+        const command = args.trim().split(/\s+/)[0] || "status"
+        const result = runServiceCommand(svc.name, command, svc.servicePath, root)
+        ctx.ui.notify(result, { level: "info" })
+      },
+    })
+  }
+}

package/scripts/telemetry-dashboard.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+
+# Physical-World Telemetry Dashboard
+# Quick overview of telemetry monitoring capabilities
+
+set -euo pipefail
+
+echo "🌍 Physical-World Telemetry Dashboard"
+echo "====================================="
+echo
+
+# Check if telemetry is enabled
+echo "📊 Telemetry Status:"
+jfl telemetry status
+echo
+
+# Generate some sample data if none exists
+echo "🧪 Generating sample data..."
+jfl telemetry test --count 3 --interval 100 --categories "command,performance"
+echo
+
+# Show current snapshot
+echo "📈 Current Physical-World Metrics:"
+jfl telemetry monitor --compact
+echo
+
+echo "🔍 Available Monitoring Options:"
+echo "  jfl telemetry monitor --live          # Real-time updates"
+echo "  jfl telemetry monitor --filter cpu    # Filter for CPU-related events"
+echo "  jfl telemetry monitor --compact       # Compact display"
+echo
+
+echo "💡 Physical-World Data Captured:"
+echo "  • System: CPU usage, memory, thermal state, system load"
+echo "  • Hardware: battery level, disk space, sensors"
+echo "  • Workflow: git branch, dirty files, terminal count, IDE"
+echo "  • Network: latency, connectivity, local dev servers"
+echo "  • Performance: build times, test durations, command timing"
+echo
+
+echo "🎯 Competitive Advantage:"
+echo "  This data is impossible for web UIs to access!"
+echo "  You own the edge - local machine context during live operations."
+echo