pi-minimal 0.1.0 → 0.2.1

package/dist/turn-rule.js

@@ -0,0 +1,119 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { CHROME_MARGIN } from "./chrome.js";
+import { formatElapsed } from "./working-status.js";
+export const TURN_ENTRY_TYPE = "pi-minimal.turn";
+export function formatClock(epochMs) {
+    const d = new Date(epochMs);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    return `${hh}:${mm}`;
+}
+export function turnLabel(summary) {
+    const parts = [formatClock(summary.endedAt), formatElapsed(summary.elapsedMs)];
+    if (summary.tools > 0)
+        parts.push(`${summary.tools} tool${summary.tools === 1 ? "" : "s"}`);
+    if (summary.outcome === "aborted")
+        parts.push("aborted");
+    if (summary.outcome === "error")
+        parts.push("error");
+    return parts.join(" · ");
+}
+/** `── label ─────────` filling `width`; label is dropped when the row is too narrow. */
+export function ruleLine(width, label) {
+    const lead = "── ";
+    const tail = " ";
+    const minRule = 4;
+    if (width <= 0)
+        return "";
+    if (visibleWidth(lead) + visibleWidth(label) + visibleWidth(tail) + minRule > width) {
+        return "─".repeat(width);
+    }
+    const shown = truncateToWidth(label, width - lead.length - tail.length - minRule, "…");
+    const rest = Math.max(minRule, width - visibleWidth(lead) - visibleWidth(shown) - visibleWidth(tail));
+    return `${lead}${shown}${tail}${"─".repeat(rest)}`;
+}
+export function runOutcome(messages) {
+    if (!Array.isArray(messages))
+        return "completed";
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message?.role !== "assistant")
+            continue;
+        if (message.stopReason === "aborted")
+            return "aborted";
+        if (message.stopReason === "error")
+            return "error";
+        return "completed";
+    }
+    return "completed";
+}
+export function isTurnSummary(data) {
+    if (!data || typeof data !== "object")
+        return false;
+    const d = data;
+    return (typeof d.endedAt === "number" &&
+        typeof d.elapsedMs === "number" &&
+        typeof d.tools === "number" &&
+        (d.outcome === "completed" || d.outcome === "aborted" || d.outcome === "error"));
+}
+export function installTurnRule(pi) {
+    let ctx;
+    let startedAt = 0;
+    let tools = 0;
+    if (typeof pi.registerEntryRenderer !== "function" || typeof pi.appendEntry !== "function") {
+        return () => { };
+    }
+    pi.registerEntryRenderer(TURN_ENTRY_TYPE, (entry, _options, theme) => {
+        if (!isTurnSummary(entry.data))
+            return undefined;
+        const label = turnLabel(entry.data);
+        const color = entry.data.outcome === "completed" ? "borderMuted" : entry.data.outcome === "aborted" ? "warning" : "error";
+        return {
+            render(width) {
+                const inner = Math.max(0, width - CHROME_MARGIN * 2);
+                const rule = ruleLine(inner, label);
+                const colored = rule.replace(label, theme.fg("dim", label));
+                return ["", `${" ".repeat(CHROME_MARGIN)}${theme.fg(color, colored)}`];
+            },
+            invalidate() { },
+        };
+    });
+    pi.on("session_start", (_event, next) => {
+        if (next.mode !== "tui")
+            return;
+        ctx = next;
+    });
+    pi.on("agent_start", () => {
+        startedAt = Date.now();
+        tools = 0;
+    });
+    pi.on("tool_execution_end", () => {
+        tools += 1;
+    });
+    pi.on("agent_end", (event) => {
+        if (!ctx || ctx.mode !== "tui" || !startedAt)
+            return;
+        const ev = event;
+        const summary = {
+            endedAt: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            tools,
+            outcome: runOutcome(ev.messages),
+        };
+        startedAt = 0;
+        try {
+            pi.appendEntry(TURN_ENTRY_TYPE, summary);
+        }
+        catch {
+            // A session that cannot accept entries just goes without the separator.
+        }
+    });
+    pi.on("session_shutdown", () => {
+        ctx = undefined;
+        startedAt = 0;
+    });
+    return () => {
+        ctx = undefined;
+        startedAt = 0;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -10,9 +10,20 @@
   "keywords": [
     "pi-package"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raviy06/pi-minimal.git"
+  },
+  "homepage": "https://github.com/raviy06/pi-minimal#readme",
+  "bugs": {
+    "url": "https://github.com/raviy06/pi-minimal/issues"
+  },
   "pi": {
     "extensions": [
       "./dist/index.js"
+    ],
+    "themes": [
+      "./themes/minimal-dark.json"
     ]
   },
   "peerDependencies": {
@@ -20,8 +31,8 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@earendil-works/pi-tui": "^1.4.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "*",
     "eslint": "^10.11.0",

package/release-notes.md

@@ -0,0 +1,30 @@
+### Added
+- Automated releases: when `version` in `package.json` changes on `main`, the
+  Publish workflow verifies the build, tags `vX.Y.Z`, creates a GitHub Release
+  (CHANGELOG section + generated notes + package tarball), records a deployment
+  to the `npm` environment, and publishes to npm via OIDC trusted publishing.
+- `CHANGELOG.md` and a "Releasing" section in the README.
+- The Publish workflow upgrades npm to >= 11.5.1 (required for OIDC trusted
+  publishing) and is re-runnable: an existing tag whose version is missing
+  from npm is published without re-tagging.
+- `repository`, `homepage`, and `bugs` fields in `package.json`, required for
+  npm provenance verification.
+
+### Changed
+- The release-triggered publish workflow is now a manual, token-based fallback
+  (`release.yml`) for re-publishing an existing tag.
+
+## What's Changed
+* Document trusted publishing setup by @raviy06 in https://github.com/raviy06/pi-minimal/pull/3
+* Use npm for installation by @raviy06 in https://github.com/raviy06/pi-minimal/pull/4
+* Design pass: tool rows, turn rule, status line, minimal-dark theme by @raviy06 in https://github.com/raviy06/pi-minimal/pull/5
+* Automate releases on version change (0.2.1) by @raviy06 in https://github.com/raviy06/pi-minimal/pull/6
+
+
+**Full Changelog**: https://github.com/raviy06/pi-minimal/compare/v0.1.0...v0.2.1
+
+---
+**Install / upgrade**
+```bash
+pi install npm:pi-minimal@0.2.1   # or: pi update --extensions
+```

package/src/activity.ts

@@ -10,7 +10,3 @@ export function rowIsRunning(context: ActivityContext): boolean {
   if (context.isPartial === false) return false
   return true
 }
-
-export function activityBullet(running: boolean, frame: 0 | 1): "◆" | "◇" {
-  return running && frame === 1 ? "◇" : "◆"
-}

package/src/cwd.ts

@@ -2,8 +2,10 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import path from "node:path"
 import { CHROME_MARGIN } from "./chrome.js"
+import { formatGitState, type GitState } from "./git-state.js"
+import type { Sibling } from "./herdr.js"
 
-function formatCwd(cwd: string): string {
+export function formatCwd(cwd: string): string {
   const home = process.env.HOME || process.env.USERPROFILE || ""
   if (!home) return cwd
   const resolved = path.resolve(cwd)
@@ -14,7 +16,7 @@ function formatCwd(cwd: string): string {
   return cwd
 }
 
-function formatTokens(n: number): string {
+export function formatTokens(n: number): string {
   if (n < 1000) return String(n)
   if (n < 10000) return `${(n / 1000).toFixed(1)}K`
   if (n < 1e6) return `${Math.round(n / 1000)}K`
@@ -22,7 +24,7 @@ function formatTokens(n: number): string {
   return `${Math.round(n / 1e6)}M`
 }
 
-function modelIcon(id: string): string {
+export function modelIcon(id: string): string {
   const s = id.toLowerCase()
   if (s.includes("grok")) return "✦"
   if (
@@ -38,7 +40,7 @@ function modelIcon(id: string): string {
   return "◆"
 }
 
-function shortModel(id: string): string {
+export function shortModel(id: string): string {
   return (id.split("/").pop() || id).replace(/^claude-/, "")
 }
 
@@ -48,61 +50,107 @@ function thinkingColor(level: string): "dim" | "accent" | "warning" {
   return "dim"
 }
 
-function meter(percent: number, fill: string, empty: string): string {
-  const n = 8
-  const filled = Math.max(0, Math.min(n, Math.round((percent / 100) * n)))
-  return fill.repeat(filled) + empty.repeat(n - filled)
+/** Context pressure band used for the meter and percentage colour. */
+export function contextBand(pct: number): "accent" | "warning" | "error" {
+  if (pct >= 90) return "error"
+  if (pct >= 70) return "warning"
+  return "accent"
 }
 
-function splitRow(left: string, right: string, width: number): string {
-  let L = left
-  let R = right
-  while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(R) > 0) {
-    R = truncateToWidth(R, Math.max(0, visibleWidth(R) - 1), "")
+export function meter(percent: number, fill: string, empty: string, cells = 8): string {
+  const filled = Math.max(0, Math.min(cells, Math.round((percent / 100) * cells)))
+  return fill.repeat(filled) + empty.repeat(cells - filled)
+}
+
+/**
+ * Fit `left` and `right` into `width`. Right-hand segments are dropped from the end first (they are
+ * the least important), then the left is truncated.
+ */
+export function splitRow(left: string, rightSegments: string[], width: number, sep = "  "): string {
+  const segments = [...rightSegments.filter((s) => visibleWidth(s) > 0)]
+  let right = segments.join(sep)
+  while (segments.length > 0 && visibleWidth(left) + 2 + visibleWidth(right) > width) {
+    segments.pop()
+    right = segments.join(sep)
   }
-  while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(L) > 0) {
-    L = truncateToWidth(L, Math.max(0, visibleWidth(L) - 1), "")
+  let L = left
+  if (visibleWidth(L) + (right ? 2 : 0) + visibleWidth(right) > width) {
+    L = truncateToWidth(L, Math.max(0, width - (right ? 2 : 0) - visibleWidth(right)), "")
   }
-  const gap = Math.max(1, width - visibleWidth(L) - visibleWidth(R))
-  return L + " ".repeat(gap) + R
+  const gap = right ? Math.max(2, width - visibleWidth(L) - visibleWidth(right)) : 0
+  return L + " ".repeat(gap) + right
+}
+
+function siblingColor(status: string): "success" | "warning" | "error" | "accent" | "muted" {
+  if (status === "idle" || status === "done") return "success"
+  if (status === "working") return "accent"
+  if (status === "blocked") return "error"
+  return "muted"
 }
 
-export function installCwd(ctx: ExtensionContext): void {
+export type StatusLineSources = {
+  gitState: () => GitState | undefined
+  siblings: () => Sibling[] | undefined
+  onGitChange: (listener: () => void) => () => void
+}
+
+export function installCwd(ctx: ExtensionContext, sources: StatusLineSources): void {
   ctx.ui.setWidget(
     "tw-cwd",
-    (_tui, theme) => ({
-      invalidate() {},
-      render(width: number): string[] {
-        const inner = Math.max(8, width - CHROME_MARGIN * 2)
-        const id = ctx.model?.id || "no-model"
-        const icon = theme.fg("accent", modelIcon(id))
-        const name = theme.fg("text", shortModel(id))
-        const usage = ctx.getContextUsage?.()
-        const window = usage?.contextWindow || ctx.model?.contextWindow
-        const used = usage?.tokens
-        let tokenStr = theme.fg("dim", "?/?")
-        let bar = theme.fg("dim", "░░░░░░░░")
-        let pctStr = theme.fg("dim", "?%")
-        if (typeof used === "number" && window) {
-          const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)))
-          tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`)
-          const hot = pct >= 85
-          bar = meter(pct, theme.fg(hot ? "warning" : "accent", "█"), theme.fg("dim", "░"))
-          pctStr = theme.fg(hot ? "warning" : "muted", `${pct}%`)
-        } else if (used === null && window) {
-          tokenStr = theme.fg("dim", `?/${formatTokens(window)}`)
-        }
-        const thinking = ctx.thinkingLevel || ""
-        const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : ""
-        const midot = theme.fg("dim", " · ")
-        const left = [`${icon} ${name}`, tokenStr, `${bar} ${pctStr}`, think]
-          .filter(Boolean)
-          .join(midot)
-        const right = ctx.cwd ? theme.fg("accent", formatCwd(ctx.cwd)) : ""
-        const row = splitRow(left, right, inner)
-        return [`${" ".repeat(CHROME_MARGIN)}${row}`]
-      },
-    }),
+    (tui, theme) => {
+      const unsub = sources.onGitChange(() => tui.requestRender())
+      return {
+        dispose: unsub,
+        invalidate() {},
+        render(width: number): string[] {
+          const inner = Math.max(8, width - CHROME_MARGIN * 2)
+          const id = ctx.model?.id || "no-model"
+          const icon = theme.fg("accent", modelIcon(id))
+          const name = theme.fg("text", shortModel(id))
+          const thinking = ctx.thinkingLevel || ""
+          const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : ""
+
+          const usage = ctx.getContextUsage?.()
+          const window = usage?.contextWindow || ctx.model?.contextWindow
+          const used = usage?.tokens
+          let bar = theme.fg("dim", "░░░░░░░░")
+          let pctStr = theme.fg("dim", "?%")
+          let tokenStr = theme.fg("dim", "?/?")
+          if (typeof used === "number" && window) {
+            const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)))
+            const band = contextBand(pct)
+            bar = meter(pct, theme.fg(band, "▓"), theme.fg("dim", "░"))
+            pctStr = theme.fg(band === "accent" ? "muted" : band, `${pct}%`)
+            tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`)
+          } else if (used === null && window) {
+            tokenStr = theme.fg("dim", `?/${formatTokens(window)}`)
+          }
+
+          const midot = theme.fg("dim", " · ")
+          const model = [`${icon} ${name}`, think].filter(Boolean).join(midot)
+          const context = `${bar} ${pctStr} ${tokenStr}`
+          const left = `${model}   ${context}`
+
+          const right: string[] = []
+          if (ctx.cwd) right.push(theme.fg("muted", formatCwd(ctx.cwd)))
+          const git = formatGitState(sources.gitState())
+          if (git.branch) {
+            const dirty = git.dirty ? ` ${theme.fg("warning", git.dirty)}` : ""
+            right.push(`${theme.fg("dim", "⎇")} ${theme.fg("muted", git.branch)}${dirty}`)
+          }
+          const siblings = sources.siblings()
+          if (siblings && siblings.length > 0) {
+            right.push(
+              siblings
+                .map((s) => `${theme.fg("text", s.name)} ${theme.fg(siblingColor(s.status), s.status)}`)
+                .join(theme.fg("dim", " · ")),
+            )
+          }
+          const row = splitRow(left, right, inner)
+          return [`${" ".repeat(CHROME_MARGIN)}${row}`]
+        },
+      }
+    },
     { placement: "aboveEditor" },
   )
 }

package/src/footer.ts

@@ -1,49 +1,49 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
 import { keyHint } from "@earendil-works/pi-coding-agent"
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui"
+import { truncateToWidth } from "@earendil-works/pi-tui"
 import { CHROME_MARGIN } from "./chrome.js"
-import type { Sibling } from "./herdr.js"
 import { formatTrackerLines } from "./tracker.js"
 
-function statusColor(
-  status: string,
-): "success" | "warning" | "error" | "accent" | "muted" {
-  if (status === "idle" || status === "done") return "success"
-  if (status === "working") return "accent"
-  if (status === "blocked") return "error"
-  return "muted"
+export type FooterSources = {
+  /** True while an agent run is in progress. */
+  busy: () => boolean
+  /** Current editor text, when the host exposes it. */
+  editorText: () => string
+  /** Context usage percentage, when known. */
+  contextPct: () => number | undefined
 }
 
-export function installFooter(
-  ctx: ExtensionContext,
-  getSiblings: () => Sibling[] | undefined,
-): void {
+/**
+ * Key hints are shown only when nothing else needs the line: idle agent, empty editor. Otherwise
+ * the footer collapses to zero lines (tracker lines excepted).
+ */
+export function footerHints(sources: FooterSources, hints: string[]): string[] {
+  if (sources.busy()) return []
+  if (sources.editorText().trim().length > 0) return []
+  const pct = sources.contextPct()
+  const out = [...hints]
+  if (pct !== undefined && pct >= 70) out.push("/compact")
+  return out
+}
+
+export function installFooter(ctx: ExtensionContext, sources: FooterSources): void {
   ctx.ui.setFooter((tui, theme, footerData) => {
     const unsub = footerData.onBranchChange(() => tui.requestRender())
     return {
       dispose: unsub,
       invalidate() {},
       render(width: number): string[] {
-        const send = keyHint("tui.input.submit", "send")
-        const think = keyHint("app.thinking.cycle", "thinking")
-        const left = [send, think].filter(Boolean).join("  ·  ")
-
-        const siblings = getSiblings()
-        let right = ""
-        if (siblings && siblings.length > 0) {
-          right = siblings
-            .map((s) => {
-              const name = theme.fg("text", s.name)
-              const st = theme.fg(statusColor(s.status), s.status)
-              return `${name} ${st}`
-            })
-            .join(theme.fg("dim", "  ·  "))
-        }
-
         const inner = Math.max(8, width - CHROME_MARGIN * 2)
-        const pad = Math.max(1, inner - visibleWidth(left) - visibleWidth(right))
-        const line = truncateToWidth(left + " ".repeat(pad) + right, inner, "")
-        const out = [`${" ".repeat(CHROME_MARGIN)}${line}`]
+        const out: string[] = []
+        const hints = footerHints(sources, [
+          keyHint("tui.input.submit", "send"),
+          keyHint("app.thinking.cycle", "thinking"),
+          keyHint("app.tools.expand", "expand tools"),
+        ].filter(Boolean))
+        if (hints.length > 0) {
+          const line = theme.fg("dim", hints.join("  ·  "))
+          out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(line, inner, "")}`)
+        }
         for (const extra of formatTrackerLines(ctx, theme as { fg: (name: string, s: string) => string })) {
           out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(extra, inner, "")}`)
         }

package/src/git-state.ts

@@ -0,0 +1,71 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+
+export type GitState = {
+  branch: string | undefined
+  /** Count of changed paths from `git status --porcelain`; undefined when unknown. */
+  dirty: number | undefined
+}
+
+export function parseBranch(stdout: string): string | undefined {
+  const line = stdout.trim().split("\n")[0]?.trim()
+  if (!line || line === "HEAD") return undefined
+  return line
+}
+
+export function parsePorcelain(stdout: string): number {
+  return stdout.split("\n").filter((line) => line.trim().length > 0).length
+}
+
+export function formatGitState(state: GitState | undefined): { branch: string; dirty: string } {
+  if (!state?.branch) return { branch: "", dirty: "" }
+  const dirty = state.dirty && state.dirty > 0 ? `±${state.dirty}` : ""
+  return { branch: state.branch, dirty }
+}
+
+/**
+ * Polls git for the current branch and dirty count. Call `refresh()` after events that may have
+ * changed the tree (tool results, turn end); `get()` is always synchronous.
+ */
+export function createGitState(pi: ExtensionAPI, cwd: () => string, minIntervalMs = 5000) {
+  let state: GitState | undefined
+  let lastRun = 0
+  let inFlight: Promise<void> | undefined
+  const listeners = new Set<() => void>()
+
+  const refresh = (force = false): Promise<void> => {
+    const now = Date.now()
+    if (inFlight) return inFlight
+    if (!force && now - lastRun < minIntervalMs) return Promise.resolve()
+    lastRun = now
+    inFlight = (async () => {
+      try {
+        const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 })
+        if (branchRun.code !== 0) {
+          state = undefined
+          return
+        }
+        const branch = parseBranch(branchRun.stdout)
+        const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: cwd(), timeout: 3000 })
+        const dirty = statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined
+        state = { branch, dirty }
+      } catch {
+        state = undefined
+      } finally {
+        inFlight = undefined
+        for (const listener of listeners) listener()
+      }
+    })()
+    return inFlight
+  }
+
+  return {
+    get: () => state,
+    refresh,
+    onChange(listener: () => void) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+  }
+}
+
+export type GitStateHandle = ReturnType<typeof createGitState>

package/src/index.ts

@@ -5,12 +5,18 @@ import { installFooter } from "./footer.js"
 import { installCwd } from "./cwd.js"
 import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
 import { hideGauntletWidgets } from "./tracker.js"
-import { stopLiveWatch, wrapBuiltinTools } from "./tools.js"
+import { installToolRenderers, stopLiveWatch } from "./tools.js"
 import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
 import { installWorkingStatus } from "./working-status.js"
+import { installTurnRule } from "./turn-rule.js"
+import { installTranscript } from "./transcript.js"
+import { createGitState } from "./git-state.js"
 
 export default function piMinimalExtension(pi: ExtensionAPI): void {
   const stopWorkingStatus = installWorkingStatus(pi)
+  const stopTurnRule = installTurnRule(pi)
+  installToolRenderers(pi)
+  installTranscript(pi)
   let fastTimer: ReturnType<typeof setInterval> | undefined
   let slowTimer: ReturnType<typeof setInterval> | undefined
   let stealTimer: ReturnType<typeof setInterval> | undefined
@@ -18,6 +24,9 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   let siblings: Sibling[] | undefined
   let generation = 0
   let hideWidgets = true
+  let busy = false
+  let currentCwd = process.cwd()
+  const gitState = createGitState(pi, () => currentCwd)
   const stopTimers = () => {
     if (fastTimer) clearInterval(fastTimer)
     if (slowTimer) clearInterval(slowTimer)
@@ -97,17 +106,40 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
         },
         chrome: () => {
           installHeader(ctx)
-          installFooter(ctx, () => siblings)
+          installChromeFooter(ctx)
         },
       },
     )
   }
 
+  const contextPct = (ctx: ExtensionContext): number | undefined => {
+    const usage = ctx.getContextUsage?.()
+    const window = usage?.contextWindow || ctx.model?.contextWindow
+    if (typeof usage?.tokens !== "number" || !window) return undefined
+    return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)))
+  }
+
+  const installChromeFooter = (ctx: ExtensionContext) => {
+    installFooter(ctx, {
+      busy: () => busy,
+      editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+      contextPct: () => contextPct(ctx),
+    })
+  }
+
+  const installStatusLine = (ctx: ExtensionContext) => {
+    installCwd(ctx, {
+      gitState: gitState.get,
+      siblings: () => siblings,
+      onGitChange: gitState.onChange,
+    })
+  }
+
   const pinChrome = (ctx: ExtensionContext, reason: ReclaimReason) => {
     hideForeignChrome(ctx, reason)
     if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome) return
     ctx.ui.setWidget("tw-cwd", undefined)
-    installCwd(ctx)
+    installStatusLine(ctx)
   }
 
   pi.on("session_start", async (_event, ctx) => {
@@ -118,10 +150,11 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
       projectTrusted: ctx.isProjectTrusted(),
     })
     hideWidgets = config.hideGauntletWidgets
+    currentCwd = ctx.cwd
     installHeader(ctx)
-    installFooter(ctx, () => siblings)
-    installCwd(ctx)
-    wrapBuiltinTools(pi, ctx)
+    installChromeFooter(ctx)
+    installStatusLine(ctx)
+    void gitState.refresh(true)
     pinChrome(ctx, "session_start")
     ctx.ui.setHiddenThinkingLabel("◆ Thought")
     ctx.ui.setWorkingIndicator()
@@ -135,16 +168,27 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
     }
   })
 
+  pi.on("agent_start", () => {
+    busy = true
+  })
+  pi.on("agent_end", () => {
+    busy = false
+    void gitState.refresh()
+  })
   pi.on("turn_end", (_event, ctx) => {
     pinChrome(ctx, "turn_end")
+    void gitState.refresh()
   })
   pi.on("tool_execution_end", (_event, ctx) => {
     pinChrome(ctx, "tool_execution_end")
+    void gitState.refresh()
   })
 
   pi.on("session_shutdown", async () => {
+    busy = false
     stopTimers()
     stopWorkingStatus()
+    stopTurnRule()
     stopLiveWatch()
     generation += 1
     siblings = undefined