@astrofoundry/pi-astro 0.11.2 → 0.12.0

package/README.md

@@ -1,6 +1,6 @@
 # @astrofoundry/pi-astro
 
-Personal customizations for the [pi coding agent](https://github.com/badlogic/pi-mono) — registers an `astro_agent` tool, a `grimoire` docs tool, a `claude-globals` rules-injection extension, a `caveman` compressed-output toggle, 8 curated subagents, 4 skills, and an `astro` theme.
+Personal customizations for the [pi coding agent](https://github.com/badlogic/pi-mono) — registers an `astro_agent` tool, a `grimoire` docs tool, a `caveman` compressed-output toggle, an `astro-footer` status bar, 8 curated subagents, 4 skills, and an `astro` theme.
 
 ## Full setup
 
@@ -45,7 +45,7 @@ Or run `/settings` inside pi and select `astro`.
 
 ```bash
 pi list           # package shows installed
-pi                # launch; confirm [Extensions] lists astro-agents, claude-globals, grimoire
+pi                # launch; confirm [Extensions] lists astro-agents, grimoire, astro-footer
 ```
 
 ## What's inside
@@ -65,8 +65,8 @@ pi                # launch; confirm [Extensions] lists astro-agents, claude-glob
 - `notify-on-stop` — runs a shell command when the agent finishes a turn (sound, voice, desktop notification). **Default: off.** Enable with `/notify on` (state persists in `~/.pi/agent/notify-on-stop.json`); disable with `/notify off`. macOS default command: plays the Glass system sound **and** speaks "Agent done" via `say` using the **`Samantha (Enhanced)`** voice. Linux default: `notify-send "pi" "Agent done"`. Override the voice with `PI_STOP_NOTIFY_VOICE=<voice-name>` (macOS only; e.g. `Alex`, `Karen`, `Daniel (Enhanced)`). Replace the full command with `PI_STOP_NOTIFY='afplay /System/Library/Sounds/Glass.aiff && say "Done"'`. Hard-kill (overrides `/notify on`) with `PI_STOP_NOTIFY_OFF=1`. Commands: `/notify [on|off|status|test]`. See [extensions/notify-on-stop/README.md](extensions/notify-on-stop/README.md) for full details.
   - **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).
+- `astro-snake` — `/snake` launches an in-pi Snake game (Astro-themed, theme-aware colours, speed ramp, no persistence). See [extensions/astro-snake/README.md](extensions/astro-snake/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-footer/format.test.ts

@@ -53,10 +53,11 @@ describe("formatPercent", () => {
         expect(formatPercent(null)).toBe("—");
     });
 
-    it("rounds to nearest integer percent (input is 0-100, not 0-1)", () => {
-        expect(formatPercent(0)).toBe("0%");
-        expect(formatPercent(45.67)).toBe("46%");
-        expect(formatPercent(100)).toBe("100%");
+    it("formats with one decimal place (input is 0-100, not 0-1)", () => {
+        expect(formatPercent(0)).toBe("0.0%");
+        expect(formatPercent(0.05)).toBe("0.1%");
+        expect(formatPercent(45.67)).toBe("45.7%");
+        expect(formatPercent(100)).toBe("100.0%");
     });
 });
 

package/extensions/astro-footer/format.ts

@@ -13,7 +13,7 @@ export function formatCost(usd: number): string {
 
 export function formatPercent(percent: number | null): string {
     if (percent === null) return "—";
-    return `${Math.round(percent)}%`;
+    return `${percent.toFixed(1)}%`;
 }
 
 export function formatPathBasename(cwd: string): string {

package/extensions/astro-footer/icons.ts

@@ -18,7 +18,7 @@ const NERD: IconSet = {
     git: "",
     tokens: "",
     cost: "",
-    context: "",
+    context: "◫",
     separator: "|",
 };
 
@@ -30,7 +30,7 @@ const ASCII: IconSet = {
     git: "git",
     tokens: "tok",
     cost: "$",
-    context: "ctx",
+    context: "◫",
     separator: "|",
 };
 

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

@@ -184,7 +184,7 @@ describe("astro-footer extension", () => {
             onBranchChange: () => () => {},
         };
         const component = factory({}, fakeTheme, fakeFooterData);
-        const lines = component.render(120);
+        const lines = component.render(200);
         expect(lines).toHaveLength(1);
         const line = lines[0];
         expect(line).toContain("Anthropic: Claude Sonnet 4 6");
@@ -192,7 +192,7 @@ describe("astro-footer extension", () => {
         expect(line).toContain("main");
         expect(line).toContain("1.2k");
         expect(line).toContain("$0.05");
-        expect(line).toContain("25%");
+        expect(line).toContain("25.0%/200k");
         expect(line).toContain("🪨 caveman:full");
     });
 

package/extensions/astro-footer/index.ts

@@ -66,7 +66,9 @@ function buildLine(
     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);
+    const contextSegment = renderContext(theme, icons, contextUsage
+        ? { percent: contextUsage.percent, contextWindow: contextUsage.contextWindow }
+        : null);
     if (contextSegment) right.push(contextSegment);
     for (const [, value] of statuses) {
         if (value) right.push(renderExtensionStatus(theme, value));

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

@@ -82,26 +82,33 @@ describe("segments", () => {
         expect(renderCost(fakeTheme, ICONS, 0.123)).toContain("$0.123");
     });
 
-    it("renderContext hides when percent is null", () => {
+    it("renderContext hides when input is null or percent is null", () => {
         expect(renderContext(fakeTheme, ICONS, null)).toBeNull();
+        expect(renderContext(fakeTheme, ICONS, { percent: null, contextWindow: 256_000 })).toBeNull();
     });
 
     it("renderContext uses dim colour below 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, 50);
+        const out = renderContext(fakeTheme, ICONS, { percent: 50, contextWindow: 256_000 });
         expect(out).toContain("<dim>");
-        expect(out).toContain("50%");
+        expect(out).toContain("50.0%/256k");
     });
 
     it("renderContext uses warning colour at and above 70%", () => {
-        const out = renderContext(fakeTheme, ICONS, 70);
+        const out = renderContext(fakeTheme, ICONS, { percent: 70, contextWindow: 200_000 });
         expect(out).toContain("<warning>");
-        expect(out).toContain("70%");
+        expect(out).toContain("70.0%/200k");
     });
 
     it("renderContext uses error colour at and above 90%", () => {
-        const out = renderContext(fakeTheme, ICONS, 95);
+        const out = renderContext(fakeTheme, ICONS, { percent: 95.5, contextWindow: 1_000_000 });
         expect(out).toContain("<error>");
-        expect(out).toContain("95%");
+        expect(out).toContain("95.5%/1.0M");
+    });
+
+    it("renderContext omits the /total suffix when contextWindow is missing", () => {
+        const out = renderContext(fakeTheme, ICONS, { percent: 25, contextWindow: 0 });
+        expect(out).toContain("25.0%");
+        expect(out).not.toContain("25.0%/");
     });
 
     it("renderExtensionStatus uses muted colour", () => {

package/extensions/astro-footer/segments.ts

@@ -62,14 +62,21 @@ export function renderCost(theme: ThemeFn, icons: IconSet, costUsd: number): str
     return `${theme.fg("muted", icons.cost)} ${theme.fg("text", formatCost(costUsd))}`.trim();
 }
 
+export interface ContextSegmentInput {
+    percent: number | null;
+    contextWindow: number | null;
+}
+
 export function renderContext(
     theme: ThemeFn,
     icons: IconSet,
-    percent: number | null,
+    input: ContextSegmentInput | null,
 ): string | null {
-    if (percent === null) return null;
-    const role: ThemeColor = percent >= 90 ? "error" : percent >= 70 ? "warning" : "dim";
-    return `${theme.fg(role, icons.context)} ${theme.fg(role, formatPercent(percent))}`.trim();
+    if (!input || input.percent === null) return null;
+    const role: ThemeColor = input.percent >= 90 ? "error" : input.percent >= 70 ? "warning" : "dim";
+    const total = input.contextWindow && input.contextWindow > 0 ? `/${formatTokens(input.contextWindow)}` : "";
+    const value = `${formatPercent(input.percent)}${total}`;
+    return `${theme.fg(role, icons.context)} ${theme.fg(role, value)}`.trim();
 }
 
 export function renderExtensionStatus(theme: ThemeFn, value: string): string {

package/extensions/astro-snake/README.md

@@ -0,0 +1,36 @@
+# astro-snake
+
+Play **Astro Snake** inside pi.
+
+```
+/snake
+```
+
+Ships as part of [`@astrofoundry/pi-astro`](../../README.md). No extra install.
+
+## What it is
+
+A small, theme-aware Snake game rendered in pi's overlay UI. Always starts a fresh game — no saves, no resume, no high scores, no out-of-session state.
+
+## Controls
+
+| Key | Action |
+|---|---|
+| `↑ ↓ ← →` or `W A S D` | Steer |
+| Press any direction key on launch | Starts the game |
+| `Q` or `Esc` | Quit |
+| `R` or `Space` (after game over / win) | Play again |
+
+The first directional key launches the snake — until then the game waits, so you don't lose 2 seconds before you've focused the terminal.
+
+## Features
+
+- **Speed ramps with score** — tick interval shrinks linearly from 100 ms down to 40 ms by the time you reach 120 points (12 food).
+- **Theme-aware colours** — uses your active pi theme: `success` for the snake, `accent` for the food and title, `error` for the game-over banner, `warning`/`muted`/`dim` for messages and chrome. No hardcoded ANSI.
+- **Astro branding** — `★ ASTRO SNAKE ★` title, `✦` sparkle food, `Stardust` score label.
+- **Win condition** — fill the entire 40×15 board (yes, it's possible) and the game ends with `Board cleared!`.
+- **Wait-to-launch** — game starts paused, first arrow key sends the snake.
+
+## Notes
+
+State lives entirely in memory for the duration of the game; nothing is persisted.

package/extensions/astro-snake/component.test.ts

@@ -0,0 +1,199 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AstroSnakeComponent, type TuiHandle } from "./component.ts";
+
+interface FakeTheme {
+    fg: (role: string, text: string) => string;
+    bold: (text: string) => string;
+}
+
+function makeTheme(): FakeTheme {
+    return {
+        fg: (role, text) => `<${role}>${text}</${role}>`,
+        bold: (text) => `*${text}*`,
+    };
+}
+
+function makeTui(): TuiHandle & { renders: number } {
+    const handle = {
+        renders: 0,
+        requestRender(): void {
+            handle.renders++;
+        },
+    };
+    return handle;
+}
+
+interface Harness {
+    component: AstroSnakeComponent;
+    tui: TuiHandle & { renders: number };
+    closed: { count: number };
+}
+
+function makeComponent(): Harness {
+    const tui = makeTui();
+    const theme = makeTheme();
+    const closed = { count: 0 };
+    const component = new AstroSnakeComponent(
+        tui,
+        theme as unknown as ConstructorParameters<typeof AstroSnakeComponent>[1],
+        () => {
+            closed.count++;
+        },
+    );
+    return { component, tui, closed };
+}
+
+describe("AstroSnakeComponent", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it("starts in 'starting' status with the launch prompt visible", () => {
+        const { component } = makeComponent();
+        expect(component.getState().status).toBe("starting");
+        const lines = component.render(120);
+        expect(lines.join("\n")).toContain("ASTRO SNAKE");
+        expect(lines.join("\n")).toContain("Ready");
+    });
+
+    it("first directional key launches the game (status 'running')", () => {
+        const { component } = makeComponent();
+        component.handleInput("\x1b[A");
+        const state = component.getState();
+        expect(state.status).toBe("running");
+        expect(state.nextDirection).toBe("up");
+        component.dispose();
+    });
+
+    it("Q while running quits and calls onClose", () => {
+        const { component, closed } = makeComponent();
+        component.handleInput("Q");
+        expect(closed.count).toBe(1);
+    });
+
+    it("ESC while running quits and calls onClose", () => {
+        const { component, closed } = makeComponent();
+        component.handleInput("\x1b");
+        expect(closed.count).toBe(1);
+    });
+
+    it("ignores unknown keys while running", () => {
+        const { component, closed } = makeComponent();
+        component.handleInput("x");
+        expect(closed.count).toBe(0);
+        expect(component.getState().status).toBe("starting");
+    });
+
+    it("R after gameover restarts the game", () => {
+        const { component } = makeComponent();
+        component.handleInput("\x1b[C");
+        const stateBefore = component.getState();
+        const overState = { ...stateBefore, status: "gameover" as const, score: 50 };
+        Object.assign(component as unknown as { state: typeof stateBefore }, { state: overState });
+        component.handleInput("R");
+        const stateAfter = component.getState();
+        expect(stateAfter.status).toBe("starting");
+        expect(stateAfter.score).toBe(0);
+        component.dispose();
+    });
+
+    it("Q after gameover quits", () => {
+        const { component, closed } = makeComponent();
+        component.handleInput("\x1b[C");
+        const stateBefore = component.getState();
+        Object.assign(component as unknown as { state: typeof stateBefore }, {
+            state: { ...stateBefore, status: "gameover" as const },
+        });
+        component.handleInput("Q");
+        expect(closed.count).toBe(1);
+    });
+
+    it("ignores unknown keys after gameover", () => {
+        const { component, closed } = makeComponent();
+        const state = component.getState();
+        Object.assign(component as unknown as { state: typeof state }, {
+            state: { ...state, status: "gameover" as const },
+        });
+        component.handleInput("x");
+        expect(closed.count).toBe(0);
+        expect(component.getState().status).toBe("gameover");
+    });
+
+    it("renders the gameover footer when status is gameover", () => {
+        const { component } = makeComponent();
+        const state = component.getState();
+        Object.assign(component as unknown as { state: typeof state }, {
+            state: { ...state, status: "gameover" as const },
+        });
+        component.invalidate();
+        expect(component.render(120).join("\n")).toContain("Mission lost");
+    });
+
+    it("renders the won footer when status is won", () => {
+        const { component } = makeComponent();
+        const state = component.getState();
+        Object.assign(component as unknown as { state: typeof state }, {
+            state: { ...state, status: "won" as const },
+        });
+        component.invalidate();
+        expect(component.render(120).join("\n")).toContain("Board cleared");
+    });
+
+    it("running footer mentions WASD controls", () => {
+        const { component } = makeComponent();
+        const state = component.getState();
+        Object.assign(component as unknown as { state: typeof state }, {
+            state: { ...state, status: "running" as const },
+        });
+        component.invalidate();
+        expect(component.render(120).join("\n")).toContain("WASD");
+    });
+
+    it("invalidate forces a re-render on next call (cache miss)", () => {
+        const { component } = makeComponent();
+        const a = component.render(120);
+        component.invalidate();
+        const b = component.render(120);
+        expect(a).not.toBe(b);
+    });
+
+    it("subsequent render with same width and version returns cached array", () => {
+        const { component } = makeComponent();
+        const a = component.render(120);
+        const b = component.render(120);
+        expect(a).toBe(b);
+    });
+
+    it("steers via WASD in addition to arrow keys", () => {
+        const { component } = makeComponent();
+        component.handleInput("d");
+        expect(component.getState().nextDirection).toBe("right");
+        component.handleInput("w");
+        expect(component.getState().nextDirection).toBe("up");
+        component.dispose();
+    });
+
+    it("ticks the snake forward after launch (fake timers advance state)", () => {
+        const { component, tui } = makeComponent();
+        component.handleInput("\x1b[C");
+        const headBefore = component.getState().snake[0];
+        vi.advanceTimersByTime(150);
+        const headAfter = component.getState().snake[0];
+        expect(headAfter).not.toEqual(headBefore);
+        expect(tui.renders).toBeGreaterThan(1);
+        component.dispose();
+    });
+
+    it("dispose clears the running timer (no further state changes)", () => {
+        const { component } = makeComponent();
+        component.handleInput("\x1b[C");
+        component.dispose();
+        const headBefore = component.getState().snake[0];
+        vi.advanceTimersByTime(500);
+        expect(component.getState().snake[0]).toEqual(headBefore);
+    });
+});

package/extensions/astro-snake/component.ts

@@ -0,0 +1,184 @@
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import { matchesKey, visibleWidth } from "@mariozechner/pi-tui";
+import {
+    applyTick,
+    changeDirection,
+    createInitialState,
+    GAME_HEIGHT,
+    GAME_WIDTH,
+    type Direction,
+    type GameState,
+    tickIntervalForScore,
+} from "./game.ts";
+
+export interface TuiHandle {
+    requestRender(): void;
+}
+
+export class AstroSnakeComponent {
+    private state: GameState;
+    private timer: ReturnType<typeof setTimeout> | null = null;
+    private cachedLines: string[] = [];
+    private cachedWidth = 0;
+    private version = 0;
+    private cachedVersion = -1;
+
+    constructor(
+        private readonly tui: TuiHandle,
+        private readonly theme: Theme,
+        private readonly onClose: () => void,
+    ) {
+        this.state = createInitialState();
+    }
+
+    getState(): GameState {
+        return this.state;
+    }
+
+    handleInput(data: string): void {
+        if (this.state.status === "gameover" || this.state.status === "won") {
+            if (data === "r" || data === "R" || data === " ") {
+                this.state = createInitialState();
+                this.bump();
+                return;
+            }
+            if (matchesKey(data, "escape") || data === "q" || data === "Q") {
+                this.dispose();
+                this.onClose();
+                return;
+            }
+            return;
+        }
+
+        if (matchesKey(data, "escape") || data === "q" || data === "Q") {
+            this.dispose();
+            this.onClose();
+            return;
+        }
+
+        let req: Direction | null = null;
+        if (matchesKey(data, "up") || data === "w" || data === "W") req = "up";
+        else if (matchesKey(data, "down") || data === "s" || data === "S") req = "down";
+        else if (matchesKey(data, "left") || data === "a" || data === "A") req = "left";
+        else if (matchesKey(data, "right") || data === "d" || data === "D") req = "right";
+
+        if (!req) return;
+
+        const wasStarting = this.state.status === "starting";
+        this.state = changeDirection(this.state, req);
+        this.bump();
+        if (wasStarting && this.state.status === "running") {
+            this.scheduleNextTick();
+        }
+    }
+
+    private scheduleNextTick(): void {
+        if (this.timer !== null) return;
+        if (this.state.status !== "running") return;
+        const delay = tickIntervalForScore(this.state.score);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            if (this.state.status !== "running") return;
+            this.state = applyTick(this.state);
+            this.bump();
+            this.scheduleNextTick();
+        }, delay);
+    }
+
+    private bump(): void {
+        this.version++;
+        this.tui.requestRender();
+    }
+
+    invalidate(): void {
+        this.cachedWidth = 0;
+    }
+
+    render(width: number): string[] {
+        if (width === this.cachedWidth && this.cachedVersion === this.version) {
+            return this.cachedLines;
+        }
+
+        const t = this.theme;
+        const cellWidth = 2;
+        const effectiveWidth = Math.min(GAME_WIDTH, Math.floor((width - 4) / cellWidth));
+        const effectiveHeight = GAME_HEIGHT;
+        const boxWidth = effectiveWidth * cellWidth;
+
+        const dim = (s: string) => t.fg("dim", s);
+        const muted = (s: string) => t.fg("muted", s);
+        const accent = (s: string) => t.fg("accent", s);
+        const success = (s: string) => t.fg("success", s);
+        const error = (s: string) => t.fg("error", s);
+        const text = (s: string) => t.fg("text", s);
+        const bold = t.bold.bind(t);
+
+        const lines: string[] = [];
+
+        const boxLine = (content: string): string => {
+            const padding = Math.max(0, boxWidth - visibleWidth(content));
+            return dim(" │") + content + " ".repeat(padding) + dim("│");
+        };
+
+        lines.push(this.padLine(dim(` ╭${"─".repeat(boxWidth)}╮`), width));
+
+        const star = bold(accent("★"));
+        const title = `${star} ${bold(accent("ASTRO SNAKE"))} ${star}`;
+        const stardust = `${muted("Stardust:")} ${bold(accent(String(this.state.score)))}`;
+        lines.push(this.padLine(boxLine(`${title}  ${dim("│")}  ${stardust}`), width));
+
+        lines.push(this.padLine(dim(` ├${"─".repeat(boxWidth)}┤`), width));
+
+        const head = this.state.snake[0];
+        const bodySet = new Set(this.state.snake.slice(1).map((p) => `${p.x},${p.y}`));
+        const food = this.state.food;
+        for (let y = 0; y < effectiveHeight; y++) {
+            let row = "";
+            for (let x = 0; x < effectiveWidth; x++) {
+                if (head.x === x && head.y === y) {
+                    row += success("██");
+                } else if (bodySet.has(`${x},${y}`)) {
+                    row += success("▓▓");
+                } else if (food && food.x === x && food.y === y) {
+                    row += accent("✦ ");
+                } else {
+                    row += "  ";
+                }
+            }
+            lines.push(this.padLine(dim(" │") + row + dim("│"), width));
+        }
+
+        lines.push(this.padLine(dim(` ├${"─".repeat(boxWidth)}┤`), width));
+
+        let footer: string;
+        if (this.state.status === "starting") {
+            footer = `${accent(bold("Ready"))}  ${muted("Press an arrow key (or WASD) to launch")}`;
+        } else if (this.state.status === "gameover") {
+            footer = `${error(bold("Mission lost!"))}  ${muted("Press")} ${bold(text("R"))} ${muted("to retry,")} ${bold(text("Q"))} ${muted("to abort")}`;
+        } else if (this.state.status === "won") {
+            footer = `${accent(bold("Board cleared!"))}  ${muted("Press")} ${bold(text("R"))} ${muted("to fly again,")} ${bold(text("Q"))} ${muted("to land")}`;
+        } else {
+            footer = `${muted("↑↓←→ or WASD to fly,")} ${bold(text("Q"))} ${muted("or")} ${bold(text("ESC"))} ${muted("to abort")}`;
+        }
+        lines.push(this.padLine(boxLine(footer), width));
+
+        lines.push(this.padLine(dim(` ╰${"─".repeat(boxWidth)}╯`), width));
+
+        this.cachedLines = lines;
+        this.cachedWidth = width;
+        this.cachedVersion = this.version;
+        return lines;
+    }
+
+    private padLine(line: string, width: number): string {
+        const padding = Math.max(0, width - visibleWidth(line));
+        return line + " ".repeat(padding);
+    }
+
+    dispose(): void {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}

package/extensions/astro-snake/game.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, it } from "vitest";
+import {
+    applyTick,
+    BASE_TICK_MS,
+    changeDirection,
+    createInitialState,
+    GAME_HEIGHT,
+    GAME_WIDTH,
+    MIN_TICK_MS,
+    SCORE_PER_FOOD,
+    spawnFood,
+    tickIntervalForScore,
+    type GameState,
+    type Point,
+} from "./game.ts";
+
+const fixedRng = (value: number) => () => value;
+
+describe("createInitialState", () => {
+    it("places a 3-segment snake near the centre, starting direction right, status starting", () => {
+        const state = createInitialState(fixedRng(0));
+        expect(state.snake).toHaveLength(3);
+        expect(state.snake[0]).toEqual({ x: GAME_WIDTH / 2, y: Math.floor(GAME_HEIGHT / 2) });
+        expect(state.direction).toBe("right");
+        expect(state.nextDirection).toBe("right");
+        expect(state.status).toBe("starting");
+        expect(state.score).toBe(0);
+        expect(state.food).not.toBeNull();
+    });
+});
+
+describe("spawnFood", () => {
+    it("returns a free cell that is not on the snake", () => {
+        const snake: Point[] = [
+            { x: 0, y: 0 },
+            { x: 1, y: 0 },
+        ];
+        const food = spawnFood(snake, fixedRng(0));
+        expect(food).not.toBeNull();
+        expect(snake.some((p) => p.x === food!.x && p.y === food!.y)).toBe(false);
+    });
+
+    it("returns null when the board is fully occupied", () => {
+        const snake: Point[] = [];
+        for (let y = 0; y < GAME_HEIGHT; y++) {
+            for (let x = 0; x < GAME_WIDTH; x++) {
+                snake.push({ x, y });
+            }
+        }
+        expect(spawnFood(snake, fixedRng(0))).toBeNull();
+    });
+
+    it("respects the rng for deterministic placement", () => {
+        const snake: Point[] = [{ x: 0, y: 0 }];
+        const a = spawnFood(snake, fixedRng(0));
+        const b = spawnFood(snake, fixedRng(0));
+        expect(a).toEqual(b);
+    });
+});
+
+describe("tickIntervalForScore", () => {
+    it("uses BASE_TICK_MS at score 0", () => {
+        expect(tickIntervalForScore(0)).toBe(BASE_TICK_MS);
+    });
+
+    it("ramps linearly downward with score", () => {
+        expect(tickIntervalForScore(40)).toBe(80);
+        expect(tickIntervalForScore(80)).toBe(60);
+    });
+
+    it("clamps at MIN_TICK_MS", () => {
+        expect(tickIntervalForScore(200)).toBe(MIN_TICK_MS);
+        expect(tickIntervalForScore(10_000)).toBe(MIN_TICK_MS);
+    });
+});
+
+describe("changeDirection", () => {
+    function startingState(): GameState {
+        return createInitialState(fixedRng(0));
+    }
+
+    it("transitions starting → running on first directional input", () => {
+        const next = changeDirection(startingState(), "up");
+        expect(next.status).toBe("running");
+        expect(next.nextDirection).toBe("up");
+    });
+
+    it("rejects 180-degree turn (right snake cannot become left)", () => {
+        const state = startingState();
+        const next = changeDirection(state, "left");
+        expect(next).toBe(state);
+    });
+
+    it("ignores input on gameover/won", () => {
+        const over: GameState = { ...startingState(), status: "gameover" };
+        expect(changeDirection(over, "up")).toBe(over);
+        const won: GameState = { ...startingState(), status: "won" };
+        expect(changeDirection(won, "up")).toBe(won);
+    });
+
+    it("preserves status when already running", () => {
+        const running: GameState = { ...startingState(), status: "running" };
+        const next = changeDirection(running, "up");
+        expect(next.status).toBe("running");
+    });
+});
+
+describe("applyTick", () => {
+    function running(overrides: Partial<GameState> = {}): GameState {
+        return { ...createInitialState(fixedRng(0)), status: "running", ...overrides };
+    }
+
+    it("does nothing when status is not running", () => {
+        const state = createInitialState(fixedRng(0));
+        expect(applyTick(state)).toBe(state);
+    });
+
+    it("moves the snake by one cell in the current direction", () => {
+        const state = running();
+        const headBefore = state.snake[0];
+        const next = applyTick(state, fixedRng(0));
+        expect(next.snake[0]).toEqual({ x: headBefore.x + 1, y: headBefore.y });
+        expect(next.snake).toHaveLength(state.snake.length);
+    });
+
+    it("triggers gameover on wall collision", () => {
+        const state = running({
+            snake: [{ x: GAME_WIDTH - 1, y: 0 }],
+            direction: "right",
+            nextDirection: "right",
+            food: { x: 0, y: 0 },
+        });
+        const next = applyTick(state, fixedRng(0));
+        expect(next.status).toBe("gameover");
+    });
+
+    it("triggers gameover on self collision", () => {
+        const state = running({
+            snake: [
+                { x: 5, y: 5 },
+                { x: 6, y: 5 },
+                { x: 6, y: 6 },
+                { x: 5, y: 6 },
+            ],
+            direction: "down",
+            nextDirection: "down",
+            food: { x: 0, y: 0 },
+        });
+        const next = applyTick(state, fixedRng(0));
+        expect(next.status).toBe("gameover");
+    });
+
+    it("grows the snake and increments score when eating food", () => {
+        const state = running({
+            snake: [
+                { x: 5, y: 5 },
+                { x: 4, y: 5 },
+            ],
+            direction: "right",
+            nextDirection: "right",
+            food: { x: 6, y: 5 },
+            score: 0,
+        });
+        const next = applyTick(state, fixedRng(0));
+        expect(next.snake).toHaveLength(3);
+        expect(next.snake[0]).toEqual({ x: 6, y: 5 });
+        expect(next.score).toBe(SCORE_PER_FOOD);
+        expect(next.food).not.toBeNull();
+    });
+
+    it("triggers won when eating fills the board", () => {
+        const allCells: Point[] = [];
+        for (let y = 0; y < GAME_HEIGHT; y++) {
+            for (let x = 0; x < GAME_WIDTH; x++) allCells.push({ x, y });
+        }
+        const food = allCells[allCells.length - 1];
+        const snake = allCells.slice(0, -1).reverse();
+        const head = snake[0];
+        const dx = food.x - head.x;
+        const dy = food.y - head.y;
+        let direction: GameState["direction"] = "right";
+        if (dx === 1) direction = "right";
+        else if (dx === -1) direction = "left";
+        else if (dy === 1) direction = "down";
+        else if (dy === -1) direction = "up";
+        const state: GameState = {
+            snake,
+            food,
+            direction,
+            nextDirection: direction,
+            score: 0,
+            status: "running",
+        };
+        const next = applyTick(state, fixedRng(0));
+        expect(next.status).toBe("won");
+        expect(next.food).toBeNull();
+    });
+
+    it("applies the queued nextDirection (90-degree turn between ticks)", () => {
+        const state = running({
+            snake: [
+                { x: 5, y: 5 },
+                { x: 4, y: 5 },
+            ],
+            direction: "right",
+            nextDirection: "up",
+            food: { x: 0, y: 0 },
+        });
+        const next = applyTick(state, fixedRng(0));
+        expect(next.snake[0]).toEqual({ x: 5, y: 4 });
+        expect(next.direction).toBe("up");
+    });
+
+    it.each([
+        ["up", { x: 5, y: 4 }],
+        ["down", { x: 5, y: 6 }],
+        ["left", { x: 4, y: 5 }],
+        ["right", { x: 6, y: 5 }],
+    ] as const)("moves correctly for direction %s", (direction, expectedHead) => {
+        const state = running({
+            snake: [{ x: 5, y: 5 }],
+            direction,
+            nextDirection: direction,
+            food: { x: 0, y: 0 },
+        });
+        const next = applyTick(state, fixedRng(0));
+        expect(next.snake[0]).toEqual(expectedHead);
+    });
+});

package/extensions/astro-snake/game.ts

@@ -0,0 +1,119 @@
+export type Direction = "up" | "down" | "left" | "right";
+
+export interface Point {
+    x: number;
+    y: number;
+}
+
+export const GAME_WIDTH = 40;
+export const GAME_HEIGHT = 15;
+export const BASE_TICK_MS = 100;
+export const MIN_TICK_MS = 40;
+export const SPEED_RAMP_PER_POINT = 0.5;
+export const SCORE_PER_FOOD = 10;
+
+export type GameStatus = "starting" | "running" | "gameover" | "won";
+
+export interface GameState {
+    snake: Point[];
+    food: Point | null;
+    direction: Direction;
+    nextDirection: Direction;
+    score: number;
+    status: GameStatus;
+}
+
+const OPPOSITE: Record<Direction, Direction> = {
+    up: "down",
+    down: "up",
+    left: "right",
+    right: "left",
+};
+
+export type Rng = () => number;
+
+export function spawnFood(snake: Point[], rng: Rng = Math.random): Point | null {
+    const occupied = new Set(snake.map((p) => `${p.x},${p.y}`));
+    const free: Point[] = [];
+    for (let y = 0; y < GAME_HEIGHT; y++) {
+        for (let x = 0; x < GAME_WIDTH; x++) {
+            if (!occupied.has(`${x},${y}`)) free.push({ x, y });
+        }
+    }
+    if (free.length === 0) return null;
+    return free[Math.floor(rng() * free.length)];
+}
+
+export function createInitialState(rng: Rng = Math.random): GameState {
+    const startX = Math.floor(GAME_WIDTH / 2);
+    const startY = Math.floor(GAME_HEIGHT / 2);
+    const snake: Point[] = [
+        { x: startX, y: startY },
+        { x: startX - 1, y: startY },
+        { x: startX - 2, y: startY },
+    ];
+    return {
+        snake,
+        food: spawnFood(snake, rng),
+        direction: "right",
+        nextDirection: "right",
+        score: 0,
+        status: "starting",
+    };
+}
+
+export function tickIntervalForScore(score: number): number {
+    const speed = BASE_TICK_MS - score * SPEED_RAMP_PER_POINT;
+    return Math.max(MIN_TICK_MS, speed);
+}
+
+export function changeDirection(state: GameState, requested: Direction): GameState {
+    if (state.status === "gameover" || state.status === "won") return state;
+    if (state.direction === OPPOSITE[requested]) return state;
+    return {
+        ...state,
+        nextDirection: requested,
+        status: state.status === "starting" ? "running" : state.status,
+    };
+}
+
+export function applyTick(state: GameState, rng: Rng = Math.random): GameState {
+    if (state.status !== "running") return state;
+    const direction = state.nextDirection;
+    const head = state.snake[0];
+    const newHead: Point =
+        direction === "up"
+            ? { x: head.x, y: head.y - 1 }
+            : direction === "down"
+              ? { x: head.x, y: head.y + 1 }
+              : direction === "left"
+                ? { x: head.x - 1, y: head.y }
+                : { x: head.x + 1, y: head.y };
+
+    if (newHead.x < 0 || newHead.x >= GAME_WIDTH || newHead.y < 0 || newHead.y >= GAME_HEIGHT) {
+        return { ...state, direction, status: "gameover" };
+    }
+    if (state.snake.some((s) => s.x === newHead.x && s.y === newHead.y)) {
+        return { ...state, direction, status: "gameover" };
+    }
+
+    const ate = state.food !== null && state.food.x === newHead.x && state.food.y === newHead.y;
+    const newSnake = ate ? [newHead, ...state.snake] : [newHead, ...state.snake.slice(0, -1)];
+    if (ate) {
+        const nextFood = spawnFood(newSnake, rng);
+        return {
+            ...state,
+            snake: newSnake,
+            food: nextFood,
+            direction,
+            score: state.score + SCORE_PER_FOOD,
+            status: nextFood === null ? "won" : "running",
+        };
+    }
+    return {
+        ...state,
+        snake: newSnake,
+        direction,
+        status: "running",
+    };
+}

package/extensions/astro-snake/index.ts

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { AstroSnakeComponent } from "./component.ts";
+
+export default function astroSnakeExtension(pi: ExtensionAPI): void {
+    pi.registerCommand("snake", {
+        description: "Play Astro Snake",
+        handler: async (_args, ctx) => {
+            if (!ctx.hasUI) {
+                ctx.ui.notify("Astro Snake requires interactive mode.", "error");
+                return;
+            }
+            await ctx.ui.custom((tui, theme, _kb, done) => {
+                return new AstroSnakeComponent(tui, theme, () => done(undefined));
+            });
+        },
+    });
+}

package/package.json

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

package/extensions/claude-globals/index.test.ts

@@ -1,77 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-type Handler = (event: { systemPrompt: string }) => Promise<{ systemPrompt: string } | undefined>;
-
-interface CapturedPi {
-    on: (event: string, handler: Handler) => void;
-    handlers: Record<string, Handler>;
-}
-
-function makePi(): CapturedPi {
-    const handlers: Record<string, Handler> = {};
-    return {
-        handlers,
-        on: (event, handler) => {
-            handlers[event] = handler;
-        },
-    };
-}
-
-describe("claude-globals extension", () => {
-    let fakeHome: string;
-    const homeEnv = process.env.HOME;
-
-    beforeEach(() => {
-        fakeHome = mkdtempSync(join(tmpdir(), "claude-glob-"));
-        process.env.HOME = fakeHome;
-        vi.resetModules();
-    });
-
-    afterEach(() => {
-        rmSync(fakeHome, { recursive: true, force: true });
-        process.env.HOME = homeEnv;
-    });
-
-    it("appends ~/.claude/CLAUDE.md content inside a wrapper tag", async () => {
-        const claudeDir = join(fakeHome, ".claude");
-        const { mkdirSync } = await import("node:fs");
-        mkdirSync(claudeDir, { recursive: true });
-        writeFileSync(join(claudeDir, "CLAUDE.md"), "RULE ONE\nRULE TWO", "utf-8");
-
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-
-        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
-        expect(result).toBeDefined();
-        expect(result?.systemPrompt).toContain("SYS");
-        expect(result?.systemPrompt).toContain("<claude-global-rules");
-        expect(result?.systemPrompt).toContain("RULE ONE");
-        expect(result?.systemPrompt).toContain("RULE TWO");
-        expect(result?.systemPrompt).toContain("</claude-global-rules>");
-    });
-
-    it("returns undefined when ~/.claude/CLAUDE.md does not exist", async () => {
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
-        expect(result).toBeUndefined();
-    });
-
-    it("returns undefined when ~/.claude/CLAUDE.md is empty / whitespace", async () => {
-        const claudeDir = join(fakeHome, ".claude");
-        const { mkdirSync } = await import("node:fs");
-        mkdirSync(claudeDir, { recursive: true });
-        writeFileSync(join(claudeDir, "CLAUDE.md"), "   \n\n  ", "utf-8");
-
-        const mod = await import("./index.ts");
-        const pi = makePi();
-        mod.default(pi as unknown as Parameters<typeof mod.default>[0]);
-        const result = await pi.handlers.before_agent_start({ systemPrompt: "SYS" });
-        expect(result).toBeUndefined();
-    });
-});

package/extensions/claude-globals/index.ts

@@ -1,17 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-
-const CLAUDE_GLOBAL_PATH = path.join(os.homedir(), ".claude", "CLAUDE.md");
-
-export default function claudeGlobalsExtension(pi: ExtensionAPI): void {
-    pi.on("before_agent_start", async (event) => {
-        if (!fs.existsSync(CLAUDE_GLOBAL_PATH)) return;
-        const content = fs.readFileSync(CLAUDE_GLOBAL_PATH, "utf-8").trim();
-        if (!content) return;
-        return {
-            systemPrompt: `${event.systemPrompt}\n\n<claude-global-rules source="~/.claude/CLAUDE.md">\n${content}\n</claude-global-rules>`,
-        };
-    });
-}