@astrofoundry/pi-astro 0.10.0 → 0.11.0

package/README.md

@@ -66,6 +66,7 @@ pi                # launch; confirm [Extensions] lists astro-agents, claude-glob
   - **macOS voice install (required once for the default):** open **System Settings → Accessibility → Spoken Content → System Voice → Manage Voices…**, expand **English**, check **Samantha (Enhanced)**, click **Done** to download (~500 MB – 1 GB). Verify with `say -v "Samantha (Enhanced)" hi`. If the voice is missing, `say` errors silently and you'll only hear the Glass sound.
 - `vscode-image` — only active inside VS Code's integrated terminal (`TERM_PROGRAM=vscode`). Switches pi-tui's image output to the **Kitty graphics protocol** so images returned by tools like `gemini_image` render as real pixels instead of the `[Image: …]` text fallback. **Requires enabling `Terminal › Integrated: Enable Images` in VS Code settings** (off by default); restart the integrated terminal after flipping it. Disable with `PI_VSCODE_IMAGE_OFF=1`. `/vscode-image` prints current status.
 - `claude-globals` — auto-injects `~/.claude/CLAUDE.md` into every pi session's system prompt
+- `astro-footer` — single-line powerline-style footer: pi marker, model, thinking level, cwd basename, git branch, total tokens, cost, context %, plus any extension statuses (`ctx.ui.setStatus`). Auto-detects Nerd Fonts (iTerm/WezTerm/Kitty/Ghostty/Alacritty) with ASCII fallback. Override via `ASTRO_FOOTER_NERD_FONTS=0|1`. Toggle with `/footer [on|off|status]`. See [extensions/astro-footer/README.md](extensions/astro-footer/README.md).
 - `caveman` — `/caveman [lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra|off|status]` toggles a persistent compressed-output mode. No argument toggles between off and the default level (`full`). Active level is shown as a footer badge and survives `/reload`. The skill body at `skills/caveman/SKILL.md` is also available as a one-shot via `/skill:caveman`.
 
 **Bundled subagents** (callable via `astro_agent`):

package/extensions/astro-agents/index.ts

@@ -73,7 +73,7 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
         description:
             "Delegate a task to a named subagent in an isolated pi subprocess. Agents are discovered from bundled (astro-agents/agents/), user-level (~/.pi/agent/agents/), and project-local (.pi/agents/) sources.",
         parameters: params,
-        async execute(_toolCallId, input, signal, _onUpdate, ctx) {
+        async execute(_toolCallId, input, signal, onUpdate, ctx) {
             const scope: AgentScope = input.scope ?? "user";
 
             const agents = discoverAgents({
@@ -102,12 +102,26 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
 
             const skillPaths = agent.skills ? resolvePackageSkills(agent.skills, ctx) : [];
 
+            const detailsBase = {
+                agent: agent.name,
+                source: agent.source,
+                color: agent.color,
+            };
+
             const result = await runAgent({
                 agent,
                 task: input.task,
                 cwd: ctx.cwd,
                 skillPaths,
                 signal,
+                onUpdate: onUpdate
+                    ? (text) => {
+                          onUpdate({
+                              content: [{ type: "text", text }],
+                              details: detailsBase,
+                          });
+                      }
+                    : undefined,
             });
 
             if (result.exitCode !== 0) {
@@ -120,11 +134,7 @@ export default function astroAgentsExtension(pi: ExtensionAPI): void {
 
             return {
                 content: [{ type: "text", text }],
-                details: {
-                    agent: agent.name,
-                    source: agent.source,
-                    color: agent.color,
-                },
+                details: detailsBase,
             };
         },
     });

package/extensions/astro-agents/spawn.test.ts

@@ -198,6 +198,103 @@ describe("runAgent (spawn.ts)", () => {
         expect(res.stderr).toContain("spawn failed");
     });
 
+    it("streams onUpdate after each message_end and uses agent_end as final state", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "first" }] },
+            }) + "\n",
+        );
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "second" }] },
+            }) + "\n",
+        );
+        fake.close(0);
+
+        const res = await promise;
+        expect(updates).toEqual(["first", "second"]);
+        expect(res.text).toBe("second");
+    });
+
+    it("does not emit duplicate onUpdate when message text is unchanged", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text: "only-text" }] },
+            }) + "\n",
+        );
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "message_end",
+                message: { role: "tool", content: [{ type: "text", text: "ignored-tool-result" }] },
+            }) + "\n",
+        );
+        fake.close(0);
+
+        await promise;
+        expect(updates).toEqual(["only-text"]);
+    });
+
+    it("falls back to agent_end messages when message_end events are absent", async () => {
+        const { spawn } = await import("node:child_process");
+        const fake = makeFakeProc();
+        vi.mocked(spawn).mockReturnValue(fake.proc as unknown as ReturnType<typeof spawn>);
+        const { runAgent } = await import("./spawn.ts");
+
+        const updates: string[] = [];
+        const promise = runAgent({
+            agent: { name: "a", description: "x", source: "bundle", filePath: "/tmp/a.md", systemPrompt: "" },
+            task: "t",
+            cwd: "/tmp",
+            onUpdate: (text) => updates.push(text),
+        });
+
+        fake.emit(
+            "stdout",
+            JSON.stringify({
+                type: "agent_end",
+                messages: [{ role: "assistant", content: [{ type: "text", text: "final" }] }],
+            }) + "\n",
+        );
+        fake.close(0);
+
+        const res = await promise;
+        expect(res.text).toBe("final");
+        expect(updates).toEqual(["final"]);
+    });
+
     it("kills process on abort signal", async () => {
         const { spawn } = await import("node:child_process");
         const fake = makeFakeProc();

package/extensions/astro-agents/spawn.ts

@@ -19,6 +19,11 @@ interface AgentEndEvent {
     messages?: AssistantMessage[];
 }
 
+interface MessageEndEvent {
+    type: "message_end";
+    message?: AssistantMessage;
+}
+
 interface UnknownEvent {
     type?: string;
     [key: string]: unknown;
@@ -73,10 +78,11 @@ export interface RunAgentOptions {
     cwd: string;
     skillPaths?: string[];
     signal?: AbortSignal | undefined;
+    onUpdate?: (text: string) => void;
 }
 
 export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
-    const { agent, task, cwd, skillPaths, signal } = options;
+    const { agent, task, cwd, skillPaths, signal, onUpdate } = options;
 
     const args = ["--mode", "json", "-p", "--no-session"];
     let tmpDir: string | null = null;
@@ -112,6 +118,15 @@ export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
             let stdoutBuffer = "";
             let stderrBuffer = "";
             const collectedMessages: AssistantMessage[] = [];
+            let lastEmittedText = "";
+
+            const emitProgress = (): void => {
+                if (!onUpdate) return;
+                const text = extractTextFromMessages(collectedMessages);
+                if (!text || text === lastEmittedText) return;
+                lastEmittedText = text;
+                onUpdate(text);
+            };
 
             const handleLine = (line: string): void => {
                 if (!line.trim()) return;
@@ -121,9 +136,21 @@ export async function runAgent(options: RunAgentOptions): Promise<SpawnResult> {
                 } catch {
                     return;
                 }
+                if (event.type === "message_end") {
+                    const msg = (event as MessageEndEvent).message;
+                    if (msg) {
+                        collectedMessages.push(msg);
+                        emitProgress();
+                    }
+                    return;
+                }
                 if (event.type === "agent_end") {
                     const end = event as AgentEndEvent;
-                    if (end.messages) collectedMessages.push(...end.messages);
+                    if (end.messages && end.messages.length > collectedMessages.length) {
+                        collectedMessages.length = 0;
+                        collectedMessages.push(...end.messages);
+                        emitProgress();
+                    }
                 }
             };
 

package/extensions/astro-footer/README.md

@@ -0,0 +1,63 @@
+# astro-footer
+
+Single-line powerline-style footer for the [pi coding agent](https://github.com/badlogic/pi-mono). Replaces the built-in footer with a compact status line:
+
+```
+π › claude-sonnet-4-6 › think:med › pi-astro › main                    1.2k › $0.05 › 25% › 🪨 caveman:full
+```
+
+Ships as part of [`@astrofoundry/pi-astro`](../../README.md). No extra install. Auto-activates on every pi session.
+
+## What it shows
+
+**Left side:**
+
+| Segment | Value |
+|---|---|
+| `π` | Pi marker |
+| **model** | Last segment of the active model id (e.g. `claude-sonnet-4-6`) |
+| **thinking** | Current thinking level (`think:off` … `think:xhi`), colour-coded |
+| **path** | Current working directory's basename |
+| **git** | Current branch (hidden when not in a git repo) |
+
+**Right side:**
+
+| Segment | Value |
+|---|---|
+| **tokens** | Cumulative input + output tokens for the session (`1.2k`, `45M`) |
+| **cost** | Cumulative session cost (`$0.05`, `$1.23`) |
+| **context** | Context window usage as a percentage; **yellow ≥ 70%, red ≥ 90%** |
+| **extension statuses** | Anything any extension has published via `ctx.ui.setStatus(key, text)` (e.g. caveman's `🪨 caveman:full`) |
+
+Segments hide automatically when the data isn't available (no model, no git, zero cost, etc.).
+
+## Commands
+
+| Command | Effect |
+|---|---|
+| `/footer` or `/footer status` | Print current state |
+| `/footer on` | Enable (re-activate after `/footer off`) |
+| `/footer off` | Restore pi's built-in footer |
+
+Argument autocomplete is wired — type `/footer ` and tab-cycle.
+
+## Icons
+
+Auto-detects Nerd Fonts in iTerm, WezTerm, Kitty, Ghostty, Alacritty, and falls back to plain ASCII glyphs everywhere else.
+
+Override the auto-detection:
+
+```bash
+export ASTRO_FOOTER_NERD_FONTS=1   # force Nerd Font icons
+export ASTRO_FOOTER_NERD_FONTS=0   # force ASCII icons
+```
+
+Read at extension load — restart pi after changing.
+
+## Extension-status pass-through
+
+Any other extension that calls `ctx.ui.setStatus(key, text)` automatically appears on the right side, in muted colour. No config required.
+
+This is what surfaces caveman's mode badge, notify-on-stop's state, and any future extension's status without each rolling its own footer renderer.
+
+To remove an extension's status from the footer, the extension itself calls `ctx.ui.setStatus(key, undefined)`.

package/extensions/astro-footer/format.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+
+describe("formatTokens", () => {
+    it("returns plain integer below 1000", () => {
+        expect(formatTokens(0)).toBe("0");
+        expect(formatTokens(999)).toBe("999");
+    });
+
+    it("formats thousands with one decimal under 10k", () => {
+        expect(formatTokens(1000)).toBe("1.0k");
+        expect(formatTokens(1234)).toBe("1.2k");
+        expect(formatTokens(9999)).toBe("10.0k");
+    });
+
+    it("formats thousands without decimals at and above 10k", () => {
+        expect(formatTokens(10_000)).toBe("10k");
+        expect(formatTokens(45_678)).toBe("46k");
+        expect(formatTokens(999_999)).toBe("1000k");
+    });
+
+    it("formats millions", () => {
+        expect(formatTokens(1_000_000)).toBe("1.0M");
+        expect(formatTokens(1_500_000)).toBe("1.5M");
+        expect(formatTokens(45_678_900)).toBe("46M");
+    });
+});
+
+describe("formatCost", () => {
+    it("returns $0 for zero", () => {
+        expect(formatCost(0)).toBe("$0");
+    });
+
+    it("uses 4 decimals below 1 cent", () => {
+        expect(formatCost(0.0001)).toBe("$0.0001");
+        expect(formatCost(0.0099)).toBe("$0.0099");
+    });
+
+    it("uses 3 decimals between 1 cent and 1 dollar", () => {
+        expect(formatCost(0.01)).toBe("$0.010");
+        expect(formatCost(0.123)).toBe("$0.123");
+        expect(formatCost(0.999)).toBe("$0.999");
+    });
+
+    it("uses 2 decimals at and above 1 dollar", () => {
+        expect(formatCost(1)).toBe("$1.00");
+        expect(formatCost(12.345)).toBe("$12.35");
+    });
+});
+
+describe("formatPercent", () => {
+    it("renders em-dash for null", () => {
+        expect(formatPercent(null)).toBe("—");
+    });
+
+    it("rounds to nearest integer percent", () => {
+        expect(formatPercent(0)).toBe("0%");
+        expect(formatPercent(0.4567)).toBe("46%");
+        expect(formatPercent(1)).toBe("100%");
+    });
+});
+
+describe("formatPathBasename", () => {
+    it("returns last segment for unix path", () => {
+        expect(formatPathBasename("/Users/astro/wb/github/astrofoundry/pi-astro")).toBe("pi-astro");
+    });
+
+    it("strips trailing slashes", () => {
+        expect(formatPathBasename("/foo/bar/")).toBe("bar");
+    });
+
+    it("handles root path", () => {
+        expect(formatPathBasename("/")).toBe("/");
+    });
+
+    it("handles relative path", () => {
+        expect(formatPathBasename("just-folder")).toBe("just-folder");
+    });
+
+    it("handles windows-style separators", () => {
+        expect(formatPathBasename("C:\\Users\\astro\\proj")).toBe("proj");
+    });
+});

package/extensions/astro-footer/format.ts

@@ -0,0 +1,23 @@
+export function formatTokens(n: number): string {
+    if (n < 1000) return `${n}`;
+    if (n < 1_000_000) return `${(n / 1000).toFixed(n < 10_000 ? 1 : 0)}k`;
+    return `${(n / 1_000_000).toFixed(n < 10_000_000 ? 1 : 0)}M`;
+}
+
+export function formatCost(usd: number): string {
+    if (usd === 0) return "$0";
+    if (usd < 0.01) return `$${usd.toFixed(4)}`;
+    if (usd < 1) return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}
+
+export function formatPercent(percent: number | null): string {
+    if (percent === null) return "—";
+    return `${Math.round(percent * 100)}%`;
+}
+
+export function formatPathBasename(cwd: string): string {
+    const trimmed = cwd.replace(/[\\/]+$/, "");
+    const segments = trimmed.split(/[\\/]/);
+    return segments[segments.length - 1] || trimmed || "/";
+}

package/extensions/astro-footer/icons.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { detectNerdFonts, iconsFor } from "./icons.ts";
+
+describe("detectNerdFonts", () => {
+    it("returns true when ASTRO_FOOTER_NERD_FONTS=1", () => {
+        expect(detectNerdFonts({ ASTRO_FOOTER_NERD_FONTS: "1" })).toBe(true);
+    });
+
+    it("returns false when ASTRO_FOOTER_NERD_FONTS=0 even on a nerd-friendly terminal", () => {
+        expect(detectNerdFonts({ ASTRO_FOOTER_NERD_FONTS: "0", TERM_PROGRAM: "iTerm.app" })).toBe(false);
+    });
+
+    it("detects iTerm via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "iTerm.app" })).toBe(true);
+    });
+
+    it("detects WezTerm via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "WezTerm" })).toBe(true);
+    });
+
+    it("detects ghostty via TERM_PROGRAM", () => {
+        expect(detectNerdFonts({ TERM_PROGRAM: "ghostty" })).toBe(true);
+    });
+
+    it("detects kitty via TERM", () => {
+        expect(detectNerdFonts({ TERM: "xterm-kitty" })).toBe(true);
+    });
+
+    it("detects iTerm2 via LC_TERMINAL", () => {
+        expect(detectNerdFonts({ LC_TERMINAL: "iTerm2" })).toBe(true);
+    });
+
+    it("returns false for an unknown terminal", () => {
+        expect(detectNerdFonts({ TERM: "xterm-256color", TERM_PROGRAM: "Apple_Terminal" })).toBe(false);
+    });
+
+    it("returns false when env is empty", () => {
+        expect(detectNerdFonts({})).toBe(false);
+    });
+});
+
+describe("iconsFor", () => {
+    it("returns nerd-font icons when true", () => {
+        const icons = iconsFor(true);
+        expect(icons.separator).toBe("");
+        expect(icons.git).toBe("");
+    });
+
+    it("returns ascii icons when false", () => {
+        const icons = iconsFor(false);
+        expect(icons.separator).toBe("›");
+        expect(icons.git).toBe("git");
+    });
+});

package/extensions/astro-footer/icons.ts

@@ -0,0 +1,54 @@
+export interface IconSet {
+    pi: string;
+    model: string;
+    thinking: string;
+    path: string;
+    git: string;
+    tokens: string;
+    cost: string;
+    context: string;
+    separator: string;
+}
+
+const NERD: IconSet = {
+    pi: "π",
+    model: "",
+    thinking: "",
+    path: "",
+    git: "",
+    tokens: "",
+    cost: "",
+    context: "",
+    separator: "",
+};
+
+const ASCII: IconSet = {
+    pi: "π",
+    model: "@",
+    thinking: "?",
+    path: "/",
+    git: "git",
+    tokens: "tok",
+    cost: "$",
+    context: "ctx",
+    separator: "›",
+};
+
+const NERD_TERM_PROGRAMS = new Set(["iTerm.app", "WezTerm", "ghostty"]);
+const NERD_TERMS = ["xterm-kitty", "alacritty", "wezterm"];
+
+export function detectNerdFonts(env: NodeJS.ProcessEnv = process.env): boolean {
+    const override = env.ASTRO_FOOTER_NERD_FONTS;
+    if (override === "1") return true;
+    if (override === "0") return false;
+    const program = env.TERM_PROGRAM ?? "";
+    if (NERD_TERM_PROGRAMS.has(program)) return true;
+    const term = env.TERM ?? "";
+    if (NERD_TERMS.some((t) => term === t || term.startsWith(`${t}-`))) return true;
+    if (env.LC_TERMINAL === "iTerm2") return true;
+    return false;
+}
+
+export function iconsFor(useNerd: boolean): IconSet {
+    return useNerd ? NERD : ASCII;
+}

package/extensions/astro-footer/index.test.ts

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+type Handler = (event: unknown, ctx: unknown) => void | Promise<void>;
+type CommandHandler = (args: string, ctx: unknown) => Promise<void> | void;
+
+interface FakePi {
+    handlers: Record<string, Handler>;
+    commands: Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>;
+    getThinkingLevel: ReturnType<typeof vi.fn>;
+    on: (event: string, h: Handler) => void;
+    registerCommand: (
+        name: string,
+        opts: {
+            description?: string;
+            handler: CommandHandler;
+            getArgumentCompletions?: (p: string) => unknown;
+        },
+    ) => void;
+}
+
+function makePi(): FakePi {
+    const handlers: Record<string, Handler> = {};
+    const commands = new Map<string, { handler: CommandHandler; getArgumentCompletions?: (p: string) => unknown }>();
+    return {
+        handlers,
+        commands,
+        getThinkingLevel: vi.fn(() => "medium"),
+        on: (event, h) => {
+            handlers[event] = h;
+        },
+        registerCommand: (name, opts) => {
+            commands.set(name, {
+                handler: opts.handler,
+                getArgumentCompletions: opts.getArgumentCompletions,
+            });
+        },
+    };
+}
+
+interface FakeCtx {
+    ui: {
+        notify: ReturnType<typeof vi.fn>;
+        setFooter: ReturnType<typeof vi.fn>;
+    };
+    cwd: string;
+    model: { id: string } | undefined;
+    sessionManager: { getBranch: () => unknown[] };
+    getContextUsage: () => { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+}
+
+function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx {
+    return {
+        ui: {
+            notify: vi.fn(),
+            setFooter: vi.fn(),
+        },
+        cwd: "/Users/astro/proj",
+        model: { id: "anthropic/claude-sonnet-4-6" },
+        sessionManager: { getBranch: () => [] },
+        getContextUsage: () => undefined,
+        ...overrides,
+    };
+}
+
+describe("astro-footer extension", () => {
+    const origEnv = { ...process.env };
+
+    beforeEach(() => {
+        vi.resetModules();
+        delete process.env.ASTRO_FOOTER_NERD_FONTS;
+        delete process.env.TERM_PROGRAM;
+        delete process.env.TERM;
+        delete process.env.LC_TERMINAL;
+    });
+
+    afterEach(() => {
+        for (const k of Object.keys(process.env)) {
+            if (!(k in origEnv)) delete process.env[k];
+        }
+        for (const [k, v] of Object.entries(origEnv)) {
+            process.env[k] = v;
+        }
+    });
+
+    async function load(): Promise<typeof import("./index.ts")> {
+        return await import("./index.ts");
+    }
+
+    async function install(): Promise<{ pi: FakePi; mod: Awaited<ReturnType<typeof load>> }> {
+        const mod = await load();
+        const pi = makePi();
+        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
+        return { pi, mod };
+    }
+
+    it("registers /footer command and session_start handler", async () => {
+        const { pi } = await install();
+        expect(pi.commands.has("footer")).toBe(true);
+        expect(pi.handlers.session_start).toBeDefined();
+    });
+
+    it("session_start activates the footer via ctx.ui.setFooter", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        expect(ctx.ui.setFooter).toHaveBeenCalledTimes(1);
+    });
+
+    it("/footer status reports current state", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("status", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/astro-footer: on/), "info");
+    });
+
+    it("/footer off restores the default footer", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("off", ctx);
+        expect(ctx.ui.setFooter).toHaveBeenCalledWith(undefined);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/off/), "info");
+    });
+
+    it("/footer on re-activates after being off", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("off", ctx);
+        await pi.commands.get("footer")!.handler("on", ctx);
+        const setFooterCalls = ctx.ui.setFooter.mock.calls;
+        expect(setFooterCalls[0][0]).toBeUndefined();
+        expect(typeof setFooterCalls[1][0]).toBe("function");
+    });
+
+    it("/footer with unknown subcommand warns", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.commands.get("footer")!.handler("nonsense", ctx);
+        expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringMatching(/unknown subcommand/), "warning");
+    });
+
+    it("argument autocomplete returns on/off/status", async () => {
+        const { pi } = await install();
+        const completions = pi.commands.get("footer")!.getArgumentCompletions!("");
+        expect(completions).toEqual(
+            expect.arrayContaining([
+                { value: "on", label: "on" },
+                { value: "off", label: "off" },
+                { value: "status", label: "status" },
+            ]),
+        );
+    });
+
+    it("renders a single-line footer with model, path, git, and extension statuses", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx({
+            sessionManager: {
+                getBranch: () => [
+                    {
+                        type: "message",
+                        message: {
+                            role: "assistant",
+                            usage: { input: 1000, output: 200, cost: { total: 0.05 } },
+                        },
+                    },
+                ],
+            },
+            getContextUsage: () => ({ tokens: 50, contextWindow: 200_000, percent: 0.25 }),
+        });
+        await pi.handlers.session_start({}, ctx);
+        const factory = ctx.ui.setFooter.mock.calls[0][0] as (
+            tui: unknown,
+            theme: unknown,
+            footerData: unknown,
+        ) => { render: (w: number) => string[] };
+        const fakeTheme = {
+            fg: (_role: string, text: string) => text,
+            bold: (text: string) => text,
+        };
+        const fakeFooterData = {
+            getGitBranch: () => "main",
+            getExtensionStatuses: () => new Map([["caveman", "🪨 caveman:full"]]),
+            getAvailableProviderCount: () => 1,
+            onBranchChange: () => () => {},
+        };
+        const component = factory({}, fakeTheme, fakeFooterData);
+        const lines = component.render(120);
+        expect(lines).toHaveLength(1);
+        const line = lines[0];
+        expect(line).toContain("claude-sonnet-4-6");
+        expect(line).toContain("proj");
+        expect(line).toContain("main");
+        expect(line).toContain("1.2k");
+        expect(line).toContain("$0.05");
+        expect(line).toContain("25%");
+        expect(line).toContain("🪨 caveman:full");
+    });
+
+    it("renders without right side when there's nothing to show", async () => {
+        process.env.ASTRO_FOOTER_NERD_FONTS = "0";
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        const factory = ctx.ui.setFooter.mock.calls[0][0] as (
+            tui: unknown,
+            theme: unknown,
+            footerData: unknown,
+        ) => { render: (w: number) => string[] };
+        const fakeTheme = { fg: (_role: string, text: string) => text };
+        const fakeFooterData = {
+            getGitBranch: () => null,
+            getExtensionStatuses: () => new Map(),
+            getAvailableProviderCount: () => 1,
+            onBranchChange: () => () => {},
+        };
+        const component = factory({}, fakeTheme, fakeFooterData);
+        const lines = component.render(80);
+        expect(lines).toHaveLength(1);
+        expect(lines[0]).not.toContain("$");
+        expect(lines[0]).toContain("proj");
+    });
+});

package/extensions/astro-footer/index.ts

@@ -0,0 +1,146 @@
+import type {
+    ExtensionAPI,
+    ExtensionContext,
+    ReadonlyFooterDataProvider,
+} from "@mariozechner/pi-coding-agent";
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { detectNerdFonts, iconsFor, type IconSet } from "./icons.ts";
+import {
+    renderContext,
+    renderCost,
+    renderExtensionStatus,
+    renderGit,
+    renderModel,
+    renderPath,
+    renderPi,
+    renderThinking,
+    renderTokens,
+    type ThemeFn,
+} from "./segments.ts";
+
+interface UsageTotals {
+    input: number;
+    output: number;
+    cost: number;
+}
+
+function collectUsage(ctx: ExtensionContext): UsageTotals {
+    const totals: UsageTotals = { input: 0, output: 0, cost: 0 };
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.type !== "message") continue;
+        if (entry.message.role !== "assistant") continue;
+        const msg = entry.message as AssistantMessage;
+        totals.input += msg.usage.input;
+        totals.output += msg.usage.output;
+        totals.cost += msg.usage.cost.total;
+    }
+    return totals;
+}
+
+function buildLine(
+    theme: ThemeFn,
+    icons: IconSet,
+    ctx: ExtensionContext,
+    pi: ExtensionAPI,
+    footerData: ReadonlyFooterDataProvider,
+    width: number,
+): string {
+    const usage = collectUsage(ctx);
+    const totalTokens = usage.input + usage.output;
+    const contextUsage = ctx.getContextUsage();
+    const thinkingLevel = pi.getThinkingLevel();
+    const branch = footerData.getGitBranch();
+    const statuses = footerData.getExtensionStatuses();
+
+    const left = [
+        renderPi(theme, icons),
+        renderModel(theme, icons, ctx.model?.id),
+        renderThinking(theme, icons, thinkingLevel),
+        renderPath(theme, icons, ctx.cwd),
+        renderGit(theme, icons, branch),
+    ].filter((s): s is string => Boolean(s));
+
+    const right: string[] = [];
+    const tokenSegment = renderTokens(theme, icons, totalTokens);
+    if (tokenSegment) right.push(tokenSegment);
+    const costSegment = renderCost(theme, icons, usage.cost);
+    if (costSegment) right.push(costSegment);
+    const contextSegment = renderContext(theme, icons, contextUsage?.percent ?? null);
+    if (contextSegment) right.push(contextSegment);
+    for (const [, value] of statuses) {
+        if (value) right.push(renderExtensionStatus(theme, value));
+    }
+
+    const sep = ` ${theme.fg("border", icons.separator)} `;
+    const leftStr = left.join(sep);
+    const rightStr = right.join(sep);
+
+    if (rightStr.length === 0) return truncateToWidth(leftStr, width);
+
+    const padWidth = Math.max(1, width - visibleWidth(leftStr) - visibleWidth(rightStr));
+    return truncateToWidth(leftStr + " ".repeat(padWidth) + rightStr, width);
+}
+
+export default function astroFooterExtension(pi: ExtensionAPI): void {
+    const useNerd = detectNerdFonts();
+    const icons = iconsFor(useNerd);
+
+    let enabled = true;
+
+    function activate(ctx: ExtensionContext): void {
+        ctx.ui.setFooter((_tui, theme, footerData) => {
+            const themeFn: ThemeFn = {
+                fg: (role, text) => theme.fg(role, text),
+            };
+            return {
+                invalidate() {},
+                render(width: number): string[] {
+                    return [buildLine(themeFn, icons, ctx, pi, footerData, width)];
+                },
+            };
+        });
+    }
+
+    pi.on("session_start", async (_event, ctx) => {
+        if (enabled) activate(ctx);
+    });
+
+    pi.registerCommand("footer", {
+        description: "Toggle astro-footer. Usage: /footer [on|off|status].",
+        getArgumentCompletions: (prefix) => {
+            const items = ["on", "off", "status"];
+            const lower = prefix.toLowerCase();
+            const matches = items
+                .filter((value) => value.startsWith(lower))
+                .map((value) => ({ value, label: value }));
+            return matches.length > 0 ? matches : null;
+        },
+        handler: async (args, ctx) => {
+            const sub = args.trim().toLowerCase() || "status";
+            if (sub === "status") {
+                ctx.ui.notify(
+                    enabled ? `astro-footer: on (${useNerd ? "nerd" : "ascii"} icons)` : "astro-footer: off",
+                    "info",
+                );
+                return;
+            }
+            if (sub === "on") {
+                enabled = true;
+                activate(ctx);
+                ctx.ui.notify("astro-footer: on", "info");
+                return;
+            }
+            if (sub === "off") {
+                enabled = false;
+                ctx.ui.setFooter(undefined);
+                ctx.ui.notify("astro-footer: off (default footer restored)", "info");
+                return;
+            }
+            ctx.ui.notify(
+                `astro-footer: unknown subcommand "${sub}". Use on|off|status.`,
+                "warning",
+            );
+        },
+    });
+}

package/extensions/astro-footer/segments.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { iconsFor } from "./icons.ts";
+import {
+    renderContext,
+    renderCost,
+    renderExtensionStatus,
+    renderGit,
+    renderModel,
+    renderPath,
+    renderPi,
+    renderThinking,
+    renderTokens,
+    type ThemeFn,
+} from "./segments.ts";
+
+const fakeTheme: ThemeFn = {
+    fg: (role, text) => `<${role}>${text}</${role}>`,
+};
+
+const ICONS = iconsFor(false);
+
+describe("segments", () => {
+    it("renderPi shows pi icon with accent color", () => {
+        expect(renderPi(fakeTheme, ICONS)).toBe("<accent>π</accent>");
+    });
+
+    it("renderModel returns null when no model", () => {
+        expect(renderModel(fakeTheme, ICONS, undefined)).toBeNull();
+    });
+
+    it("renderModel uses the last segment of a slash-separated id", () => {
+        const out = renderModel(fakeTheme, ICONS, "anthropic/claude-sonnet-4-6");
+        expect(out).toContain("claude-sonnet-4-6");
+        expect(out).not.toContain("anthropic/");
+    });
+
+    it("renderThinking returns null when level missing", () => {
+        expect(renderThinking(fakeTheme, ICONS, undefined)).toBeNull();
+    });
+
+    it("renderThinking labels each level", () => {
+        expect(renderThinking(fakeTheme, ICONS, "off")).toContain("think:off");
+        expect(renderThinking(fakeTheme, ICONS, "minimal")).toContain("think:min");
+        expect(renderThinking(fakeTheme, ICONS, "low")).toContain("think:low");
+        expect(renderThinking(fakeTheme, ICONS, "medium")).toContain("think:med");
+        expect(renderThinking(fakeTheme, ICONS, "high")).toContain("think:high");
+        expect(renderThinking(fakeTheme, ICONS, "xhigh")).toContain("think:xhi");
+    });
+
+    it("renderThinking falls back gracefully on unknown level", () => {
+        const out = renderThinking(fakeTheme, ICONS, "weird");
+        expect(out).toContain("think:weird");
+    });
+
+    it("renderPath shows the basename of cwd", () => {
+        const out = renderPath(fakeTheme, ICONS, "/Users/astro/proj");
+        expect(out).toContain("proj");
+    });
+
+    it("renderGit returns null when no branch", () => {
+        expect(renderGit(fakeTheme, ICONS, null)).toBeNull();
+    });
+
+    it("renderGit shows branch name in success colour", () => {
+        const out = renderGit(fakeTheme, ICONS, "feat-foo");
+        expect(out).toContain("<success>feat-foo</success>");
+    });
+
+    it("renderTokens hides when total is zero", () => {
+        expect(renderTokens(fakeTheme, ICONS, 0)).toBeNull();
+    });
+
+    it("renderTokens formats large totals", () => {
+        expect(renderTokens(fakeTheme, ICONS, 1234)).toContain("1.2k");
+    });
+
+    it("renderCost hides when zero", () => {
+        expect(renderCost(fakeTheme, ICONS, 0)).toBeNull();
+    });
+
+    it("renderCost formats sub-dollar costs", () => {
+        expect(renderCost(fakeTheme, ICONS, 0.123)).toContain("$0.123");
+    });
+
+    it("renderContext hides when percent is null", () => {
+        expect(renderContext(fakeTheme, ICONS, null)).toBeNull();
+    });
+
+    it("renderContext uses dim colour below 70%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.5);
+        expect(out).toContain("<dim>");
+    });
+
+    it("renderContext uses warning colour at and above 70%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.7);
+        expect(out).toContain("<warning>");
+    });
+
+    it("renderContext uses error colour at and above 90%", () => {
+        const out = renderContext(fakeTheme, ICONS, 0.95);
+        expect(out).toContain("<error>");
+    });
+
+    it("renderExtensionStatus uses muted colour", () => {
+        expect(renderExtensionStatus(fakeTheme, "🪨 caveman:full")).toBe("<muted>🪨 caveman:full</muted>");
+    });
+});

package/extensions/astro-footer/segments.ts

@@ -0,0 +1,76 @@
+import type { ThemeColor } from "@mariozechner/pi-coding-agent";
+import type { IconSet } from "./icons.ts";
+import { formatCost, formatPathBasename, formatPercent, formatTokens } from "./format.ts";
+
+export interface ThemeFn {
+    fg: (role: ThemeColor, text: string) => string;
+}
+
+const THINKING_LABELS: Record<string, string> = {
+    off: "off",
+    minimal: "min",
+    low: "low",
+    medium: "med",
+    high: "high",
+    xhigh: "xhi",
+};
+
+const THINKING_COLORS: Record<string, ThemeColor> = {
+    off: "dim",
+    minimal: "muted",
+    low: "accent",
+    medium: "accent",
+    high: "warning",
+    xhigh: "error",
+};
+
+export function renderPi(theme: ThemeFn, icons: IconSet): string {
+    return theme.fg("accent", icons.pi);
+}
+
+export function renderModel(theme: ThemeFn, icons: IconSet, modelId: string | undefined): string | null {
+    if (!modelId) return null;
+    const short = modelId.split("/").pop() ?? modelId;
+    return `${theme.fg("muted", icons.model)} ${theme.fg("text", short)}`.trim();
+}
+
+export function renderThinking(theme: ThemeFn, icons: IconSet, level: string | undefined): string | null {
+    if (!level) return null;
+    const label = THINKING_LABELS[level] ?? level;
+    const color = THINKING_COLORS[level] ?? "dim";
+    return `${theme.fg(color, icons.thinking)} ${theme.fg(color, `think:${label}`)}`.trim();
+}
+
+export function renderPath(theme: ThemeFn, icons: IconSet, cwd: string): string {
+    const name = formatPathBasename(cwd);
+    return `${theme.fg("dim", icons.path)} ${theme.fg("accent", name)}`.trim();
+}
+
+export function renderGit(theme: ThemeFn, icons: IconSet, branch: string | null): string | null {
+    if (!branch) return null;
+    return `${theme.fg("success", icons.git)} ${theme.fg("success", branch)}`.trim();
+}
+
+export function renderTokens(theme: ThemeFn, icons: IconSet, totalTokens: number): string | null {
+    if (totalTokens === 0) return null;
+    return `${theme.fg("muted", icons.tokens)} ${theme.fg("text", formatTokens(totalTokens))}`.trim();
+}
+
+export function renderCost(theme: ThemeFn, icons: IconSet, costUsd: number): string | null {
+    if (costUsd === 0) return null;
+    return `${theme.fg("muted", icons.cost)} ${theme.fg("text", formatCost(costUsd))}`.trim();
+}
+
+export function renderContext(
+    theme: ThemeFn,
+    icons: IconSet,
+    percent: number | null,
+): string | null {
+    if (percent === null) return null;
+    const role: ThemeColor = percent >= 0.9 ? "error" : percent >= 0.7 ? "warning" : "dim";
+    return `${theme.fg(role, icons.context)} ${theme.fg(role, formatPercent(percent))}`.trim();
+}
+
+export function renderExtensionStatus(theme: ThemeFn, value: string): string {
+    return theme.fg("muted", value);
+}

package/extensions/gemini-image/index.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { GoogleGenAI } from "@google/genai";
 import { StringEnum } from "@mariozechner/pi-ai";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "typebox";
 import { persistApiKey, resolveExistingApiKey } from "./credentials.ts";
 import {
@@ -72,6 +73,13 @@ type Params = {
     skip_confirm?: boolean;
 };
 
+interface GeminiImageDetails {
+    model: ImageModel;
+    images: number;
+    savedPaths: string[];
+    actualCostUsd?: number;
+}
+
 async function ensureApiKey(ctx: ExtensionContext): Promise<string> {
     const existing = resolveExistingApiKey();
     if (existing) return existing;
@@ -410,15 +418,35 @@ export default function geminiImageExtension(pi: ExtensionAPI): void {
                 ...call.images.map((img) => ({ type: "image" as const, data: img.data, mimeType: img.mimeType })),
             ];
 
-            return {
-                content,
-                details: {
-                    model: finalModel,
-                    images: call.images.length,
-                    savedPaths,
-                    actualCostUsd: actual?.usd,
-                },
+            const details: GeminiImageDetails = {
+                model: finalModel,
+                images: call.images.length,
+                savedPaths,
+                actualCostUsd: actual?.usd,
             };
+
+            return { content, details };
+        },
+        renderResult(result, { expanded, isPartial }, theme, _context) {
+            if (isPartial) {
+                return new Text(theme.fg("warning", "Generating..."), 0, 0);
+            }
+            const details = result.details as GeminiImageDetails | undefined;
+            if (!details) {
+                return new Text(theme.fg("dim", "(no details)"), 0, 0);
+            }
+            const plural = details.images === 1 ? "image" : "images";
+            let text = theme.fg("toolTitle", theme.bold(details.model));
+            text += theme.fg("muted", ` · ${details.images} ${plural}`);
+            if (typeof details.actualCostUsd === "number") {
+                text += theme.fg("dim", ` · $${details.actualCostUsd.toFixed(4)}`);
+            }
+            if (expanded) {
+                for (const path of details.savedPaths) {
+                    text += "\n" + theme.fg("dim", `  ${path}`);
+                }
+            }
+            return new Text(text, 0, 0);
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"