pi-shannon-statusline 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+<div align="center">
+
+<img src="shannon-statusline.png" alt="pi-shannon-statusline preview" width="100%" />
+
+# pi-shannon-statusline
+
+**Cyberpunk terminal HUD for [Pi](https://github.com/earendil-works/pi-coding-agent)**
+
+Ported from [shannon-statusline](https://github.com/RealAlexandreAI/shannon-statusline) (Claude Code).
+
+</div>
+
+---
+
+## What you get
+
+A live cyberpunk HUD rendered below every Pi response:
+
+```
+⌘ ~/D/project  │  ⎇ main* ↑2 !3 +1  │  ↺ loop ×12  │  ✦ 12m
+↑ deepseek / deepseek-v4-pro  │  ⊡ ████████░░░░ 65% (200k)  │  ↑ 36k
+※ ×3 AGENTS.md  │  ⊕ ×4 MCPs  │  ×5 skills
+─────────────────────────────────────────────────────────────
+✔ read ×12  │  ✔ edit ×7  │  ✔ bash ×4
+↻ bash: src/index.ts (3s)
+─────────────────────────────────────────────────────────────
+↻ agent (3s)  │  ✔ agent ×2
+```
+
+Matrix katakana rain on the left. Monokai Pro palette. No config, no commands — plug and play.
+
+---
+
+## Install
+
+```bash
+pi install npm:pi-shannon-statusline
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/RealAlexandreAI/pi-shannon-statusline.git
+cd pi-shannon-statusline && pi install .
+```
+
+---
+
+## Features
+
+| Section | Content |
+|---|---|
+| **Project + Git** | CWD (fish-style abbreviation), branch, dirty, ahead/behind, file changes |
+| **Turn count** | `↺ loop ×N` between git and duration |
+| **Model + Context** | Provider / model name, context bar with percentage, token count |
+| **Config counts** | AGENTS.md ×N, rules ×N, MCPs ×N, skills ×N |
+| **Tool activity** | Completed tool counts, running tools with elapsed time |
+| **Agent activity** | Running agent timer, completed agent count |
+| **Matrix rain** | 6-column animated katakana rain, always on |
+
+## Pi-native advantages
+
+- **Live context API** — reads `getContextUsage()` directly, no stdin parsing
+- **Widget rendering** — uses `ctx.ui.setWidget()` below the editor
+- **Session-aware** — resets on `/new`, `/resume`, `/fork`
+- **Model auto-detection** — updates on `model_select` event
+- **Tool/agent tracking** — hooks `tool_call`, `tool_result`, `agent_start`, `agent_end`
+- **Zero config** — install and go
+
+## Testing
+
+```bash
+node --test src/__tests__/hud.test.ts
+```
+
+## License
+
+MIT — based on [shannon-statusline](https://github.com/RealAlexandreAI/shannon-statusline) (MIT)

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "pi-shannon-statusline",
+  "version": "0.1.0",
+  "description": "Cyberpunk terminal HUD for Pi \u2014 ported from shannon-statusline for Claude Code",
+  "license": "MIT",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "repository": "github:RealAlexandreAI/pi-shannon-statusline",
+  "keywords": [
+    "pi-package",
+    "hud",
+    "statusline",
+    "cyberpunk"
+  ]
+}

package/src/__tests__/hud.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for pi-shannon-statusline HUD renderer.
+ * Run: node --test src/__tests__/hud.test.ts
+ */
+
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+
+// ═══════════════════════════════════════════════════════════════
+// Copy of production render logic (pure, no fs/child_process deps)
+// ═══════════════════════════════════════════════════════════════
+
+const R = "\x1b[0m";
+const D = "\x1b[2m";
+const COMMENT = "\x1b[38;5;243m";
+const GREEN = "\x1b[38;5;154m";
+const CYAN = "\x1b[38;5;123m";
+const PURPLE = "\x1b[38;5;141m";
+const YELLOW = "\x1b[38;5;221m";
+const I_RUN = "↻";
+
+function c(text: string, color: string) { return `${color}${text}${R}`; }
+
+function fmtDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const s = ms / 1000;
+  if (s < 60) return `${s.toFixed(0)}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${Math.round(s % 60)}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+
+function fmtTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+  return `${n}`;
+}
+
+interface ToolRecord {
+  name: string; status: "running" | "completed" | "error";
+  startTime: number; endTime?: number;
+}
+
+interface AgentRecord {
+  status: "running" | "completed";
+  startTime: number; endTime?: number;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Tool count rendering (extracted from buildHud)
+// ═══════════════════════════════════════════════════════════════
+
+function renderToolCounts(tools: ToolRecord[]): string[] {
+  const sep = `${COMMENT}│${R}`;
+  const completed = tools.filter(t => t.status === "completed");
+  const toolCounts = new Map<string, number>();
+  for (const t of completed) toolCounts.set(t.name, (toolCounts.get(t.name) ?? 0) + 1);
+
+  const parts: string[] = [];
+  for (const name of ["read", "edit", "write", "bash", "grep", "find", "ls"]) {
+    const count = toolCounts.get(name) ?? 0;
+    if (count > 0) parts.push(`${GREEN} ${c(name, R.replace("\x1b[0m", ""))}${count > 1 ? ` ${c(`×${count}`, COMMENT)}` : ""}`);
+  }
+
+  if (parts.length === 0) return [];
+
+  // stand-in for FG color
+  const FG = "\x1b[38;5;252m";
+  // rebuild with proper color
+  const rebuilt: string[] = [];
+  for (const name of ["read", "edit", "write", "bash", "grep", "find", "ls"]) {
+    const count = toolCounts.get(name) ?? 0;
+    if (count > 0) rebuilt.push(`${GREEN} ${c(name, FG)}${count > 1 ? ` ${c(`×${count}`, COMMENT)}` : ""}`);
+  }
+
+  return [`${COMMENT}${"─".repeat(67)}${R}`, rebuilt.join(` ${sep} `)];
+}
+
+function renderAgentActivity(agents: AgentRecord[]): string[] {
+  const sep = `${COMMENT}│${R}`;
+  const agentRunning = agents.filter(a => a.status === "running");
+  const agentCompleted = agents.filter(a => a.status === "completed");
+
+  if (agentRunning.length === 0 && agentCompleted.length === 0) return [];
+
+  const lines: string[] = [];
+  lines.push(`${COMMENT}${"─".repeat(67)}${R}`);
+
+  const parts: string[] = [];
+  for (const a of agentRunning) {
+    parts.push(`${c(I_RUN, YELLOW)} ${c("agent", PURPLE)} ${c(`(${fmtDuration(Date.now() - a.startTime)})`, COMMENT)}`);
+  }
+  if (agentCompleted.length > 0) {
+    parts.push(`${c("agent", PURPLE)} ${GREEN} ${c(`×${agentCompleted.length}`, COMMENT)}`);
+  }
+  lines.push(parts.join(` ${sep} `));
+  return lines;
+}
+
+// Strip ANSI for assertion readability
+function stripANSI(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════
+
+describe("fmtTokens", () => {
+  it("formats < 1000 as plain number", () => { assert.equal(fmtTokens(0), "0"); assert.equal(fmtTokens(999), "999"); });
+  it("formats k", () => { assert.equal(fmtTokens(1500), "1.5k"); assert.equal(fmtTokens(9999), "10.0k"); });
+  it("formats M", () => { assert.equal(fmtTokens(1_500_000), "1.5M"); });
+});
+
+describe("fmtDuration", () => {
+  it("formats ms", () => { assert.equal(fmtDuration(500), "500ms"); });
+  it("formats seconds", () => { assert.equal(fmtDuration(3500), "4s"); });
+  it("formats minutes", () => { assert.equal(fmtDuration(125000), "2m 5s"); });
+});
+
+describe("renderToolCounts", () => {
+  it("returns empty for no completed tools", () => {
+    assert.deepStrictEqual(renderToolCounts([]), []);
+  });
+
+  it("shows single tool without ×1", () => {
+    const lines = renderToolCounts([
+      { name: "read", status: "completed", startTime: 0 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("read"), `should include read: ${text}`);
+    assert.ok(!text.includes("×1"), `should not include ×1: ${text}`);
+  });
+
+  it("shows ×N for multiple uses", () => {
+    const lines = renderToolCounts([
+      { name: "read", status: "completed", startTime: 0 },
+      { name: "read", status: "completed", startTime: 1 },
+      { name: "bash", status: "completed", startTime: 2 },
+      { name: "bash", status: "completed", startTime: 3 },
+      { name: "bash", status: "completed", startTime: 4 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("×2"), `should have ×2: ${text}`);
+    assert.ok(text.includes("×3"), `should have ×3: ${text}`);
+  });
+
+  it("shows only completed, not running/error", () => {
+    const lines = renderToolCounts([
+      { name: "read", status: "completed", startTime: 0 },
+      { name: "bash", status: "running", startTime: 1 },
+      { name: "grep", status: "error", startTime: 2 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("read"), `should include completed read: ${text}`);
+    assert.ok(!text.includes("bash"), `should not include running bash: ${text}`);
+    assert.ok(!text.includes("grep"), `should not include error grep: ${text}`);
+  });
+
+  it("shows all tracked tool names in order", () => {
+    const lines = renderToolCounts([
+      { name: "read", status: "completed", startTime: 0 },
+      { name: "edit", status: "completed", startTime: 1 },
+      { name: "write", status: "completed", startTime: 2 },
+      { name: "bash", status: "completed", startTime: 3 },
+      { name: "grep", status: "completed", startTime: 4 },
+      { name: "find", status: "completed", startTime: 5 },
+      { name: "ls", status: "completed", startTime: 6 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    const names = ["read", "edit", "write", "bash", "grep", "find", "ls"];
+    let lastIdx = -1;
+    for (const name of names) {
+      const idx = text.indexOf(name);
+      assert.ok(idx > lastIdx, `${name} should appear after previous (${lastIdx}), got ${idx}\n${text}`);
+      lastIdx = idx;
+    }
+  });
+
+  it("separator is 67 chars", () => {
+    const lines = renderToolCounts([{ name: "read", status: "completed", startTime: 0 }]);
+    const sep = stripANSI(lines[0]!);
+    assert.equal(sep.length, 67, `separator should be 67 chars, got ${sep.length}: "${sep}"`);
+  });
+});
+
+describe("renderAgentActivity", () => {
+  it("returns empty for no agents", () => {
+    assert.deepStrictEqual(renderAgentActivity([]), []);
+  });
+
+  it("shows running agent with timer", () => {
+    const now = Date.now();
+    const lines = renderAgentActivity([
+      { status: "running", startTime: now - 3000 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("agent"), `should include agent: ${text}`);
+    assert.ok(text.includes("↻"), `should include spinner: ${text}`);
+  });
+
+  it("shows completed count with agent label", () => {
+    const lines = renderAgentActivity([
+      { status: "completed", startTime: 0, endTime: 1000 },
+      { status: "completed", startTime: 0, endTime: 2000 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("agent"), `should include agent label: ${text}`);
+    assert.ok(text.includes("×2"), `should include ×2: ${text}`);
+  });
+
+  it("shows agent label even when only completed (no running)", () => {
+    const lines = renderAgentActivity([
+      { status: "completed", startTime: 0 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    assert.ok(text.includes("agent"), `should include agent even with only completed: ${text}`);
+    assert.ok(text.includes("×1"), `should include ×1: ${text}`);
+  });
+
+  it("merges running + completed into one line", () => {
+    const now = Date.now();
+    const lines = renderAgentActivity([
+      { status: "running", startTime: now - 5000 },
+      { status: "completed", startTime: 0, endTime: 1000 },
+    ], "cyberpunk");
+    const text = lines.map(stripANSI).join("\n");
+    // All agent content should be in one line (after separator)
+    const dataLine = lines[1] ? stripANSI(lines[1]) : "";
+    assert.ok(dataLine.includes("agent"), "data line should include agent");
+    assert.ok(dataLine.includes("×1"), "data line should include ×1");
+    // Running agent text should be on same line
+    assert.ok(dataLine.includes("↻"), "data line should include running indicator");
+  });
+
+  it("separator is 67 chars for agent section", () => {
+    const lines = renderAgentActivity([{ status: "completed", startTime: 0 }]);
+    const sep = stripANSI(lines[0]!);
+    assert.equal(sep.length, 67, `separator should be 67 chars, got ${sep.length}`);
+  });
+});

package/src/index.ts

@@ -0,0 +1,505 @@
+/**
+ * pi-shannon-statusline — Cyberpunk HUD for Pi
+ * Ported from shannon-statusline (Claude Code).
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const execFileAsync = promisify(execFile);
+
+// ═══════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════
+
+interface GitStatus {
+  branch: string;
+  isDirty: boolean;
+  ahead: number;
+  behind: number;
+  modified: number;
+  added: number;
+  deleted: number;
+  untracked: number;
+}
+
+interface AgentRecord {
+  status: "running" | "completed";
+  startTime: number;
+  endTime?: number;
+}
+
+interface ToolRecord {
+  name: string;
+  target: string | null;
+  status: "running" | "completed" | "error";
+  startTime: number;
+  endTime?: number;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// State
+// ═══════════════════════════════════════════════════════════════
+
+let sessionStartTime = 0;
+let turnIndex = 0;
+let tools: ToolRecord[] = [];
+let agents: AgentRecord[] = [];
+let modelProvider = "";
+let modelId = "";
+let cwd = "";
+
+// ═══════════════════════════════════════════════════════════════
+// ANSI palette
+// ═══════════════════════════════════════════════════════════════
+
+const R = "\x1b[0m";
+const D = "\x1b[2m";
+
+function rgb(r: number, g: number, b: number) { return `\x1b[38;2;${r};${g};${b}m`; }
+
+// Monokai Pro
+const FG = "\x1b[38;5;252m";
+const COMMENT = "\x1b[38;5;243m";
+const PINK = "\x1b[38;5;198m";
+const GREEN = "\x1b[38;5;154m";
+const ORANGE = "\x1b[38;5;208m";
+const CYAN = "\x1b[38;5;123m";
+const PURPLE = "\x1b[38;5;141m";
+const YELLOW = "\x1b[38;5;221m";
+
+function c(text: string, color: string) { return `${color}${text}${R}`; }
+function dim(text: string) { return `${D}${text}${R}`; }
+
+// Icons
+const I_PATH = "⌘";
+const I_BRANCH = "⎇";
+const I_CLOCK = "✦";
+const I_CTX = "⊡";
+const I_IN = "↑";
+const I_DONE = "✔";
+const I_RUN = "↻";
+const I_CLAUDE = "※";
+const I_MCP = "⊕";
+
+// ═══════════════════════════════════════════════════════════════
+// Fish-style path shortening (from original shannon-statusline)
+// ═══════════════════════════════════════════════════════════════
+
+function abbreviateSegment(segment: string): string {
+  if (segment.length <= 1) return segment;
+  const extra = segment.match(/[-.](.)/);
+  return extra ? `${segment[0]}${extra[0]}` : segment[0];
+}
+
+function truncateTailSegment(segment: string, maxLen: number): string {
+  if (segment.length <= maxLen) return segment;
+  if (maxLen <= 1) return "…";
+  const extStart = segment.lastIndexOf(".");
+  const hasExt = extStart > 0 && extStart < segment.length - 1;
+  if (!hasExt) return `…${segment.slice(-(maxLen - 1))}`;
+  const ext = segment.slice(extStart);
+  const base = segment.slice(0, extStart);
+  const budget = maxLen - ext.length - 1;
+  if (budget <= 0) return `…${ext.slice(-(maxLen - 1))}`;
+  return `…${base.slice(-budget)}${ext}`;
+}
+
+function shortenDisplayPath(fullPath: string, home: string, maxLen: number): string {
+  if (!fullPath) return "";
+  let display = fullPath;
+  if (home && fullPath === home) return "~";
+  if (home && fullPath.startsWith(home + "/")) {
+    display = "~" + fullPath.slice(home.length);
+  }
+
+  const prefix = display.startsWith("~") ? "~" : display.startsWith("/") ? "/" : "";
+  const rawParts = display.split("/").filter(Boolean);
+  const parts = prefix === "~" ? rawParts.slice(1) : rawParts;
+  if (parts.length <= 1) return display;
+
+  const tail = parts.slice(-1);
+  const head = parts.slice(0, -1).map(abbreviateSegment);
+  let shortened = [...head, ...tail].join("/");
+  if (prefix) shortened = prefix + "/" + shortened;
+
+  if (shortened.length <= maxLen) return shortened;
+
+  const ellipsis = prefix + "/…/" + tail.join("/");
+  if (ellipsis.length <= maxLen) return ellipsis;
+
+  const budget = Math.max(1, maxLen - (prefix ? prefix.length + 4 : 3));
+  return `${prefix ? prefix + "/" : ""}…/${truncateTailSegment(tail[0]!, budget)}`;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Context bar
+// ═══════════════════════════════════════════════════════════════
+
+function ctxBar(percent: number, width: number): string {
+  const safeP = Math.min(100, Math.max(0, percent));
+  const filled = Math.round((safeP / 100) * width);
+  const empty = width - filled;
+
+  let r0: number, g0: number, b0: number;
+  let r1: number, g1: number, b1: number;
+  if (safeP >= 85) { [r0, g0, b0] = [90, 0, 48]; [r1, g1, b1] = [255, 0, 144]; }
+  else if (safeP >= 70) { [r0, g0, b0] = [122, 21, 0]; [r1, g1, b1] = [255, 107, 0]; }
+  else { [r0, g0, b0] = [0, 51, 0]; [r1, g1, b1] = [57, 255, 20]; }
+
+  const cells: string[] = [];
+  for (let i = 0; i < filled; i++) {
+    const t = filled > 1 ? i / (filled - 1) : 1;
+    cells.push(`${rgb(Math.round(r0 + (r1 - r0) * t), Math.round(g0 + (g1 - g0) * t), Math.round(b0 + (b1 - b0) * t))}█`);
+  }
+  return `${cells.join("")}${D}${"░".repeat(empty)}${R}`;
+}
+
+function ctxPctColor(percent: number): string {
+  if (percent >= 85) return rgb(255, 0, 144);
+  if (percent >= 70) return rgb(255, 107, 0);
+  return rgb(57, 255, 20);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Formatters
+// ═══════════════════════════════════════════════════════════════
+
+function fmtTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+  return `${n}`;
+}
+
+function fmtDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  const s = ms / 1000;
+  if (s < 60) return `${s.toFixed(0)}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${Math.round(s % 60)}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Matrix rain (6 columns like original)
+// ═══════════════════════════════════════════════════════════════
+
+const RAIN_CHARS = "ｦｧｨｩｪｫｬｭｮｯｰｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿ0123456789λΨΩΔΦ";
+const RAIN_COLS = 6;
+const RAIN_SPEED_MS = 900;
+const RAIN_COL_OFFSET_MS = 280;
+
+function rainCell(row: number, col: number, now: number, total: number): string {
+  const colPhase = ((now + col * RAIN_COL_OFFSET_MS) / RAIN_SPEED_MS) % total;
+  const headRow = Math.floor(colPhase);
+  const dist = (row - headRow + total) % total;
+  const ch = RAIN_CHARS[Math.floor(now / 350 + row * 7 + col * 13) % RAIN_CHARS.length] ?? " ";
+
+  if (dist === 0) return `${rgb(200, 255, 200)}${ch}${R}`;
+  if (dist === 1) return `${rgb(57, 255, 20)}${ch}${R}`;
+  if (dist === 2) return `${rgb(0, 200, 0)}${ch}${R}`;
+  if (dist === 3) return `${rgb(0, 160, 0)}${ch}${R}`;
+  if (dist === 4) return `${rgb(0, 100, 0)}${ch}${R}`;
+  if (dist === total - 1) return `${rgb(20, 20, 20)}${ch}${R}`;
+  if (dist === total - 2) return `${rgb(0, 0, 0)}${ch}${R}`;
+  return `${rgb(8, 8, 8)}${ch}${R}`;
+}
+
+function makeRain(row: number, total: number): string {
+  // rain always on, no early return
+  const now = Date.now();
+  const cells: string[] = [];
+  for (let c = 0; c < RAIN_COLS; c++) cells.push(rainCell(row, c, now, total));
+  return `${cells.join(" ")}  `;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Git
+// ═══════════════════════════════════════════════════════════════
+
+async function getGit(dir: string): Promise<GitStatus | null> {
+  if (!dir) return null;
+  try {
+    const { stdout: branchOut } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: dir, timeout: 1500, encoding: "utf8",
+    });
+    const branch = branchOut.trim();
+    if (!branch) return null;
+
+    let isDirty = false, modified = 0, added = 0, deleted = 0, untracked = 0;
+    try {
+      const { stdout: statusOut } = await execFileAsync("git", ["--no-optional-locks", "status", "--porcelain"], {
+        cwd: dir, timeout: 1500, encoding: "utf8",
+      });
+      const lines = statusOut.trim().split("\n").filter(Boolean);
+      isDirty = lines.length > 0;
+      for (const line of lines) {
+        if (line.startsWith("??")) untracked++;
+        else if (line[0] === "A") added++;
+        else if (line[0] === "D" || line[1] === "D") deleted++;
+        else if (line[0] === "M" || line[1] === "M" || line[0] === "R" || line[0] === "C") modified++;
+      }
+    } catch { /* ignore */ }
+
+    let ahead = 0, behind = 0;
+    try {
+      const { stdout: revOut } = await execFileAsync("git", ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], {
+        cwd: dir, timeout: 1500, encoding: "utf8",
+      });
+      const parts = revOut.trim().split(/\s+/);
+      if (parts.length === 2) { behind = parseInt(parts[0]!, 10) || 0; ahead = parseInt(parts[1]!, 10) || 0; }
+    } catch { /* no upstream */ }
+
+    return { branch, isDirty, ahead, behind, modified, added, deleted, untracked };
+  } catch { return null; }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Config counter
+// ═══════════════════════════════════════════════════════════════
+
+function countConfigs(dir: string) {
+  let claudeMd = 0, rules = 0, mcps = 0, skills = 0;
+  try {
+    if (existsSync(join(dir, "AGENTS.md"))) claudeMd++;
+    if (existsSync(join(dir, "CLAUDE.md"))) claudeMd++;
+    if (existsSync(join(dir, ".claude", "CLAUDE.md"))) claudeMd++;
+    if (existsSync(join(dir, ".pi", "agent", "AGENTS.md"))) claudeMd++;
+
+    const rulesDir = join(dir, ".claude", "rules");
+    if (existsSync(rulesDir)) rules = readdirSync(rulesDir).filter(f => f.endsWith(".md")).length;
+
+    if (existsSync(join(dir, ".mcp.json"))) mcps++;
+    if (existsSync(join(dir, ".config", "mcp", "mcp.json"))) mcps++;
+
+    const skillsDir = join(dir, ".claude", "skills");
+    if (existsSync(skillsDir)) skills = readdirSync(skillsDir, { recursive: true }).filter(f => f.endsWith("SKILL.md")).length;
+  } catch { /* ignore */ }
+  return { claudeMd, rules, mcps, skills };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// HUD Renderer
+// ═══════════════════════════════════════════════════════════════
+
+async function buildHud(ctx: any): Promise<string[]> {
+  const lines: string[] = [];
+  const dir = cwd;
+  const sep = `${COMMENT}│${R}`;
+
+  // ── Line 1: Project + Git + Duration ──
+  const parts1: string[] = [];
+  if (dir) {
+    const home = homedir();
+    parts1.push(`${c(I_PATH, ORANGE)} ${c(shortenDisplayPath(dir, home, 30), ORANGE)}`);
+  }
+
+  const git = await getGit(dir);
+  if (git) {
+    const dirty = git.isDirty ? "*" : "";
+    const branchColor = CYAN;
+    let gitStr = `${c(I_BRANCH, branchColor)} ${c(`${git.branch}${dirty}`, branchColor)}`;
+    const details: string[] = [];
+    if (git.ahead > 0) details.push(c(`↑${git.ahead}`, GREEN));
+    if (git.behind > 0) details.push(c(`↓${git.behind}`, PINK));
+    if (git.modified > 0) details.push(c(`!${git.modified}`, PINK));
+    if (git.added > 0) details.push(c(`+${git.added}`, GREEN));
+    if (git.deleted > 0) details.push(c(`✘${git.deleted}`, PINK));
+    if (git.untracked > 0) details.push(c(`?${git.untracked}`, COMMENT));
+    if (details.length > 0) gitStr += ` ${details.join(" ")}`;
+    parts1.push(gitStr);
+  }
+
+  if (sessionStartTime > 0) {
+    // Turn count before duration
+    if (turnIndex > 0) parts1.push(`${c(`↺ loop`, PURPLE)} ${c(`×${turnIndex}`, FG)}`);
+    parts1.push(`${c(I_CLOCK, COMMENT)} ${c(fmtDuration(Date.now() - sessionStartTime), COMMENT)}`);
+  }
+
+  lines.push(parts1.join(` ${sep} `));
+
+  // ── Line 2: Model (provider/id) + Thinking level + Context + Tokens ──
+  const modelColor = CYAN;
+  const providerColor = COMMENT;
+  let modelStr: string;
+  if (modelProvider && modelId) {
+    modelStr = `${c(I_IN, modelColor)} ${c(modelProvider, providerColor)}${dim("/")}${c(modelId, modelColor)}`;
+  } else if (modelId) {
+    modelStr = `${c(I_IN, modelColor)} ${c(modelId, modelColor)}`;
+  } else if (modelProvider) {
+    modelStr = `${c(I_IN, modelColor)} ${c(modelProvider, modelColor)}`;
+  } else {
+    modelStr = `${c(I_IN, modelColor)} ${c("pi", modelColor)}`;
+  }
+
+  // Thinking level removed — Pi doesn't expose real-time value in event context
+  // (getThinkingLevel() only on command ctx, ctx.model has no current level)
+
+  let ctxStr = "";
+  try {
+    const usage = ctx.getContextUsage?.();
+    if (usage) {
+      const pct = usage.percent ?? 0;
+      const bar = ctxBar(pct, 10);
+      const win = usage.contextWindow ?? 0;
+      const winLabel = win >= 1_000_000 ? `${(win / 1_000_000).toFixed(1)}M` : win >= 1000 ? `${Math.round(win / 1000)}k` : "";
+      ctxStr = `${c(I_CTX, CYAN)} ${bar} ${c(`${pct.toFixed(1)}%`, ctxPctColor(pct))}`;
+      if (winLabel) ctxStr += ` ${dim(`(${winLabel})`)}`;
+
+      const totalTokens = usage.tokens ?? 0;
+      let tokStr = `${c(I_IN, CYAN)} ${c(fmtTokens(totalTokens), FG)}`;
+
+      const line2 = `${modelStr} ${sep} ${ctxStr} ${sep} ${tokStr}`;
+      lines.push(line2);
+    } else {
+      lines.push(modelStr);
+    }
+  } catch { lines.push(modelStr); }
+
+  // ── Line 3: Config counts ──
+  const configs = countConfigs(dir);
+  const cfgParts: string[] = [];
+  if (configs.claudeMd > 0) cfgParts.push(`${c(I_CLAUDE, ORANGE)} ${c(`×${configs.claudeMd}`, ORANGE)} ${dim("AGENTS.md")}`);
+  if (configs.rules > 0) cfgParts.push(`${c(`×${configs.rules}`, COMMENT)} ${dim("rules")}`);
+  if (configs.mcps > 0) cfgParts.push(`${c(I_MCP, CYAN)} ${c(`×${configs.mcps}`, CYAN)} ${dim("MCPs")}`);
+  if (configs.skills > 0) cfgParts.push(`${c(`×${configs.skills}`, PURPLE)} ${dim("skills")}`);
+  if (cfgParts.length > 0) lines.push(cfgParts.join(` ${sep} `));
+
+  // ── Separator + Tool counts ──
+  const completed = tools.filter(t => t.status === "completed");
+  const toolCounts = new Map<string, number>();
+  for (const t of completed) toolCounts.set(t.name, (toolCounts.get(t.name) ?? 0) + 1);
+
+  const toolLineParts: string[] = [];
+  for (const name of ["read", "edit", "write", "bash", "grep", "find", "ls"]) {
+    const count = toolCounts.get(name) ?? 0;
+    if (count > 0) toolLineParts.push(`${GREEN} ${c(name, FG)}${count > 1 ? ` ${c(`×${count}`, COMMENT)}` : ""}`);
+  }
+  if (toolLineParts.length > 0) {
+    lines.push(`${COMMENT}${"─".repeat(67)}${R}`);
+    lines.push(toolLineParts.join(` ${sep} `));
+  }
+
+  // ── Running tools ──
+  const running = tools.filter(t => t.status === "running");
+  for (const t of running.slice(-2)) {
+    const elapsed = fmtDuration(Date.now() - t.startTime);
+    const target = t.target ? `: ${shortenDisplayPath(t.target, homedir(), 22)}` : "";
+    lines.push(`${c(I_RUN, YELLOW)} ${c(t.name, CYAN)}${target} ${c(`(${elapsed})`, COMMENT)}`);
+  }
+
+  // ── Agent activity ──
+  const agentRunning = agents.filter(a => a.status === "running");
+  const agentCompleted = agents.filter(a => a.status === "completed");
+  if (agentRunning.length > 0 || agentCompleted.length > 0) {
+    lines.push(`${COMMENT}${"─".repeat(67)}${R}`);
+    const parts: string[] = [];
+    for (const a of agentRunning) {
+      parts.push(`${c(I_RUN, YELLOW)} ${c("agent", PURPLE)} ${c(`(${fmtDuration(Date.now() - a.startTime)})`, COMMENT)}`);
+    }
+    if (agentCompleted.length > 0) {
+      parts.push(`${c("agent", PURPLE)} ${GREEN} ${c(`×${agentCompleted.length}`, COMMENT)}`);
+    }
+    lines.push(parts.join(` ${sep} `));
+  }
+
+  // ── Matrix rain (if enabled) ──
+  if (true) { // rain always on
+    const total = lines.length;
+    for (let i = 0; i < total; i++) {
+      lines[i] = `${makeRain(i, total)}${lines[i]}`;
+    }
+  }
+
+  return lines;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// HUD refresh
+// ═══════════════════════════════════════════════════════════════
+
+function refreshHud(ctx: any) {
+  buildHud(ctx).then(lines => {
+    if (lines.length > 0) ctx.ui.setWidget("shannon-hud", lines, { placement: "belowEditor" });
+  }).catch(() => {});
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Extension entry
+// ═══════════════════════════════════════════════════════════════
+
+export default function (pi: ExtensionAPI) {
+  // No slash commands — always-on cyberpunk HUD
+
+  // ── Events ──
+  pi.on("session_start", (_event, ctx) => {
+    sessionStartTime = Date.now();
+    turnIndex = 0;
+    cwd = ctx.cwd;
+    tools = [];
+    if (ctx.model) {
+      modelProvider = (ctx.model as any).provider ?? "";
+      modelId = (ctx.model as any).id ?? "";
+    }
+    refreshHud(ctx);
+  });
+
+  pi.on("model_select", (event, ctx) => {
+    if (event.model) {
+      modelProvider = (event.model as any).provider ?? "";
+      modelId = (event.model as any).id ?? "";
+    }
+    refreshHud(ctx);
+  });
+
+  pi.on("thinking_level_select", (_event) => {
+    // Event fires on manual change; no real-time read API in ExtensionContext
+  });
+
+  pi.on("turn_start", (_event, ctx) => {
+    turnIndex = (_event as any).turnIndex ?? (turnIndex + 1);
+    refreshHud(ctx);
+  });
+
+  pi.on("tool_call", (event, ctx) => {
+    const tool: ToolRecord = { name: event.toolName, target: null, status: "running", startTime: Date.now() };
+    if (event.input && typeof event.input === "object") {
+      const inp = event.input as Record<string, unknown>;
+      if (typeof inp.path === "string") tool.target = inp.path;
+      else if (typeof inp.filePath === "string") tool.target = inp.filePath;
+    }
+    tools.push(tool);
+    refreshHud(ctx);
+  });
+
+  pi.on("tool_result", (event, ctx) => {
+    for (let i = tools.length - 1; i >= 0; i--) {
+      if (tools[i]!.name === event.toolName && tools[i]!.status === "running") {
+        tools[i]!.status = event.isError ? "error" : "completed";
+        tools[i]!.endTime = Date.now();
+        break;
+      }
+    }
+    refreshHud(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => refreshHud(ctx));
+  pi.on("agent_end", (_event, ctx) => {
+    // Mark running agents as completed
+    for (const a of agents) {
+      if (a.status === "running") {
+        a.status = "completed";
+        a.endTime = Date.now();
+      }
+    }
+    refreshHud(ctx);
+  });
+  pi.on("agent_start", (_event, ctx) => {
+    agents.push({ status: "running", startTime: Date.now() });
+    refreshHud(ctx);
+  });
+}