afk-snake 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jsiwinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# afk-snake 🐍
+
+A game you play in your terminal while you wait for your AI agents to finish a job.
+No install, one command:
+
+```sh
+npx afk-snake
+```
+
+## Step 1: Snake
+
+- **Steer:** Arrow keys or **WASD**
+- **Pause:** `P` — freezes the game so you can jump back to your Claude terminal (`Enter` returns to Claude; an arrow key resumes)
+- **Restart:** `R`  ·  **Quit:** `Q` / `Ctrl-C`
+- Walls and your own tail are deadly. The snake speeds up as you eat.
+- Your best score is saved to `~/.term-game.json`.
+
+Beat your high score, screenshot the game-over card, and share it — the
+install command is right there on the card.
+
+## Develop
+
+```sh
+npm start     # play from source
+npm test      # run the unit tests (node:test, zero deps)
+```
+
+## Phase 2: Auto-launch while you wait
+
+Run your AI agent (Claude Code) **inside tmux**, then once:
+
+```sh
+afk-snake install      # adds UserPromptSubmit + Stop hooks to ~/.claude/settings.json
+```
+
+Your game is one continuous session: it freezes when the popup closes and **resumes
+right where you left off** (same score and snake) on the next prompt — press any key to
+un-pause. Dying, quitting (`Q`), or restarting (`R`) starts a fresh game next time.
+
+Now every time you send the agent a prompt, Snake pops up over your terminal and
+disappears the moment the agent replies. Remove it any time with:
+
+```sh
+afk-snake uninstall
+```
+
+Not inside tmux? The hooks stay out of your way (the popup is skipped) — just run
+`afk-snake` in a spare terminal instead. A separate-window fallback is future work.
+
+MIT © jsiwinski

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "afk-snake",
+  "version": "0.2.0",
+  "description": "A terminal game to play while AI agents finish jobs. npx afk-snake",
+  "type": "module",
+  "bin": { "afk-snake": "src/index.js" },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test"
+  },
+  "engines": { "node": ">=18" },
+  "license": "MIT",
+  "files": ["src", "README.md", "LICENSE"]
+}

package/src/api.js

@@ -0,0 +1,23 @@
+// src/api.js
+// The ONLY client module that touches the network. `fetch` is injectable for tests.
+// Callers wrap calls in try/catch and degrade to "didn't sync" — gameplay never blocks.
+export function createApi(baseUrl, { fetch = globalThis.fetch } = {}) {
+  async function call(path, token, body) {
+    const res = await fetch(baseUrl + path, {
+      method: body ? 'POST' : 'GET',
+      headers: {
+        'content-type': 'application/json',
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    if (!res.ok) throw new Error(`http ${res.status}`);
+    return res.json();
+  }
+  return {
+    postGame: (token, facts) => call('/games', token, facts),
+    postUnlock: (token, itemId) => call('/unlocks', token, { itemId }),
+    getMe: (token) => call('/me', token),
+    postLogin: (githubToken) => call('/login', null, { githubToken }),
+  };
+}

package/src/cli.js

@@ -0,0 +1,22 @@
+import { run } from './loop.js';
+import { install, uninstall } from './install.js';
+import { startPopup, stopPopup } from './popup.js';
+import { login } from './login.js';
+
+const SUBCOMMANDS = new Set(['install', 'uninstall', '_start', '_stop', 'login']);
+
+export function parseCommand(argv) {
+  const arg = argv[2];
+  return SUBCOMMANDS.has(arg) ? arg : 'play';
+}
+
+export function main(argv = process.argv, env = process.env) {
+  switch (parseCommand(argv)) {
+    case 'install': return install(env);
+    case 'uninstall': return uninstall(env);
+    case '_start': return startPopup(env);
+    case '_stop': return stopPopup(env);
+    case 'login': return login().then((r) => { if (!r || !r.ok) process.exit(1); });
+    default: return run();
+  }
+}

package/src/economyClient.js

@@ -0,0 +1,67 @@
+// src/economyClient.js
+// The loop's single touchpoint for the account + token economy. All network calls
+// degrade silently (gameplay never blocks). `api` and `loadAuth` are injectable.
+import { createApi } from './api.js';
+import { loadAuth as realLoadAuth } from './profile.js';
+import { hasGlow, SKIN_GLOW, GLOW_PRICE } from './skins.js';
+
+const DEFAULT_BASE = 'https://term-game-api.jsiwinski2.workers.dev';
+const isUnauthorized = (err) => /\b401\b/.test(String(err && err.message));
+
+export function createEconomyClient({ api, loadAuth = realLoadAuth, env = process.env } = {}) {
+  const client = api || createApi(env.TERM_GAME_API || DEFAULT_BASE);
+  const state = { loggedIn: false, token: null, login: null, balance: 0, best: 0, unlocks: [] };
+
+  async function load() {
+    const auth = loadAuth();
+    if (!auth) return;
+    state.loggedIn = true;
+    state.token = auth.token;
+    state.login = auth.login;
+    try {
+      const me = await client.getMe(auth.token);
+      state.balance = me.balance;
+      state.best = me.best;
+      state.unlocks = me.unlocks || [];
+    } catch {
+      // logged in but /me unreachable: keep defaults, no glow this session
+    }
+  }
+
+  async function submitGame(facts) {
+    if (!state.loggedIn) return null;
+    try {
+      const r = await client.postGame(state.token, facts);
+      state.balance = r.balance;
+      state.best = r.best;
+      return r;
+    } catch (err) {
+      if (isUnauthorized(err)) state.loggedIn = false;
+      return null;
+    }
+  }
+
+  async function buyGlow() {
+    if (!state.loggedIn) return { ok: false };
+    try {
+      const r = await client.postUnlock(state.token, SKIN_GLOW);
+      state.balance = r.balance;
+      state.unlocks = r.unlocks || state.unlocks;
+      return { ok: true, balance: r.balance };
+    } catch (err) {
+      if (isUnauthorized(err)) state.loggedIn = false;
+      return { ok: false };
+    }
+  }
+
+  return {
+    load,
+    submitGame,
+    buyGlow,
+    hasGlow: () => hasGlow(state.unlocks),
+    canBuyGlow: () => state.loggedIn && !hasGlow(state.unlocks) && state.balance >= GLOW_PRICE,
+    get loggedIn() { return state.loggedIn; },
+    get balance() { return state.balance; },
+    get best() { return state.best; },
+  };
+}

package/src/economyFooter.js

@@ -0,0 +1,8 @@
+// src/economyFooter.js
+// Pure: the one game-over line that sells the loop. Kept ≤ 30 chars so it fits
+// the centered game-over card's inner width. No I/O, no network.
+export function economyLine({ loggedIn, awarded = 0, balance = 0, canAfford = false } = {}) {
+  if (!loggedIn) return `+${awarded} tokens  [A] keep them`;
+  if (canAfford) return `+${awarded}  bal ${balance}  [S] glow skin`;
+  return `+${awarded} earned   balance ${balance}`;
+}

package/src/engine.js

@@ -0,0 +1,89 @@
+export const DIRS = {
+  up: { x: 0, y: -1 },
+  down: { x: 0, y: 1 },
+  left: { x: -1, y: 0 },
+  right: { x: 1, y: 0 },
+};
+
+export const FOOD_COUNT = 3;
+
+export function spawnFood(width, height, blocked, rng) {
+  const occupied = new Set(blocked.map((c) => `${c.x},${c.y}`));
+  const free = [];
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (!occupied.has(`${x},${y}`)) free.push({ x, y });
+    }
+  }
+  if (free.length === 0) return null;
+  return free[Math.floor(rng() * free.length)];
+}
+
+// Top a foods array up toward FOOD_COUNT, never placing one on the snake or an
+// existing food. Returns as many as fit if the board lacks free cells.
+export function fillFoods(width, height, snake, foods, rng) {
+  const result = [...foods];
+  while (result.length < FOOD_COUNT) {
+    const food = spawnFood(width, height, [...snake, ...result], rng);
+    if (!food) break;
+    result.push(food);
+  }
+  return result;
+}
+
+export function createGame({ width, height, rng = Math.random }) {
+  const cx = Math.floor(width / 2);
+  const cy = Math.floor(height / 2);
+  const snake = [
+    { x: cx, y: cy },
+    { x: cx - 1, y: cy },
+    { x: cx - 2, y: cy },
+  ];
+  const dir = DIRS.right;
+  const foods = fillFoods(width, height, snake, [], rng);
+  return { width, height, snake, dir, pendingDir: dir, foods, score: 0, status: 'playing', rng };
+}
+
+function isOpposite(a, b) {
+  return a.x === -b.x && a.y === -b.y;
+}
+
+export function turn(state, dirName) {
+  const dir = DIRS[dirName];
+  if (!dir) return state;
+  if (state.snake.length > 1 && isOpposite(dir, state.dir)) return state;
+  return { ...state, pendingDir: dir };
+}
+
+export function step(state) {
+  if (state.status !== 'playing') return state;
+  const dir = state.pendingDir;
+  const head = state.snake[0];
+  const newHead = { x: head.x + dir.x, y: head.y + dir.y };
+
+  if (
+    newHead.x < 0 || newHead.x >= state.width ||
+    newHead.y < 0 || newHead.y >= state.height
+  ) {
+    return { ...state, dir, status: 'over' };
+  }
+
+  const eatenIndex = state.foods.findIndex((f) => f.x === newHead.x && f.y === newHead.y);
+  const willEat = eatenIndex !== -1;
+  const body = willEat ? state.snake : state.snake.slice(0, -1);
+  if (body.some((c) => c.x === newHead.x && c.y === newHead.y)) {
+    return { ...state, dir, status: 'over' };
+  }
+
+  const newSnake = [newHead, ...state.snake];
+  let score = state.score;
+  let foods = state.foods;
+  if (willEat) {
+    score += 1;
+    const remaining = state.foods.filter((_, i) => i !== eatenIndex);
+    foods = fillFoods(state.width, state.height, newSnake, remaining, state.rng);
+  } else {
+    newSnake.pop();
+  }
+  return { ...state, dir, snake: newSnake, foods, score };
+}

package/src/gameover.js

@@ -0,0 +1,27 @@
+// Built programmatically so every line is exactly the same length — required for the
+// centered overlay (overlayCenter). No wide emoji (which would break column alignment).
+export function gameOverCard({ score, best, isNewBest, economyLine }) {
+  const W = 30; // inner width (between the side borders)
+  const pad = (s, w = W) => {
+    const total = Math.max(0, w - s.length);
+    const left = Math.floor(total / 2);
+    return ' '.repeat(left) + s + ' '.repeat(total - left);
+  };
+  const leftLine = (s) => ('   ' + s).padEnd(W).slice(0, W);
+  const row = (s) => '│' + s + '│';
+  const rows = [
+    '┌' + '─'.repeat(W) + '┐',
+    row(pad('G A M E   O V E R')),
+    row(' '.repeat(W)),
+    row(leftLine('Score:  ' + score)),
+    row(leftLine('Best:   ' + best)),
+    row(isNewBest ? pad('new best!') : ' '.repeat(W)),
+  ];
+  if (economyLine) rows.push(row(leftLine(economyLine)));
+  rows.push(
+    row(leftLine('play:  npx afk-snake')),
+    '└' + '─'.repeat(W) + '┘',
+    pad('[R] play again   [Q] quit', W + 2), // matches the box outer width (W + 2 borders)
+  );
+  return rows.join('\n');
+}

package/src/glow.js

@@ -0,0 +1,15 @@
+// src/glow.js
+// Pure comet-trail coloring: a bright bold head dimming toward the tail, using
+// 256-colour ANSI. Each painted cell is self-contained (colour + char + reset),
+// so colour never bleeds between cells.
+const ESC = '\x1b[';
+export const RESET = `${ESC}0m`;
+const RAMP = [231, 230, 228, 222, 220, 214, 208, 202, 196]; // white -> yellow -> orange -> red
+
+export function cometColor(index) {
+  return `${ESC}38;5;${RAMP[Math.min(index, RAMP.length - 1)]}m`;
+}
+
+export function paintCell(ch, index) {
+  return `${cometColor(index)}${ch}${RESET}`;
+}

package/src/highscore.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const DEFAULT_PATH = join(homedir(), '.term-game.json');
+
+export function loadHighScore(path = DEFAULT_PATH) {
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof data.best === 'number' ? data.best : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function saveHighScore(score, path = DEFAULT_PATH) {
+  writeFileSync(path, JSON.stringify({ best: score }), 'utf8');
+}
+
+export function updateHighScore(score, path = DEFAULT_PATH) {
+  const best = loadHighScore(path);
+  if (score > best) {
+    saveHighScore(score, path);
+    return { best: score, isNewBest: true };
+  }
+  return { best, isNewBest: false };
+}
+
+// Pure, in-memory best tracking — no file I/O. No-account play uses this so the
+// best lives only for the sitting (durable best moves to the account/server).
+export function nextBest(best, score) {
+  return score > best ? { best: score, isNewBest: true } : { best, isNewBest: false };
+}

package/src/hooks.js

@@ -0,0 +1,38 @@
+// A harmless trailing shell comment that tags our hook commands so uninstall
+// can find them regardless of how the launcher was resolved.
+export const MARKER = '# term-game-phase2';
+
+const EVENTS = { UserPromptSubmit: '_start', Stop: '_stop' };
+
+function entryFor(launcherCmd, sub) {
+  return { hooks: [{ type: 'command', command: `${launcherCmd} ${sub} ${MARKER}` }] };
+}
+
+function isOurEntry(group) {
+  // Match only commands ending in the marker (entryFor always appends it last),
+  // so a user hook that merely contains the marker string is never touched.
+  return (
+    group &&
+    Array.isArray(group.hooks) &&
+    group.hooks.some((h) => typeof h.command === 'string' && h.command.endsWith(` ${MARKER}`))
+  );
+}
+
+export function withoutTermGameHooks(settings) {
+  if (!settings.hooks) return settings;
+  const hooks = {};
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    const kept = (groups || []).filter((g) => !isOurEntry(g));
+    if (kept.length) hooks[event] = kept; // drop now-empty events
+  }
+  return { ...settings, hooks };
+}
+
+export function withTermGameHooks(settings, launcherCmd) {
+  const hooks = { ...(settings.hooks || {}) };
+  for (const [event, sub] of Object.entries(EVENTS)) {
+    const existing = (hooks[event] || []).filter((g) => !isOurEntry(g)); // drop stale -> idempotent
+    hooks[event] = [...existing, entryFor(launcherCmd, sub)];
+  }
+  return { ...settings, hooks };
+}

package/src/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from './cli.js';
+main();

package/src/input.js

@@ -0,0 +1,20 @@
+export function mapKey(data) {
+  const s = data.toString();
+  switch (s) {
+    case '\x1b[A': return 'up';
+    case '\x1b[B': return 'down';
+    case '\x1b[C': return 'right';
+    case '\x1b[D': return 'left';
+    case 'w': case 'W': return 'up';
+    case 's': case 'S': return 'down';
+    case 'a': case 'A': return 'left';
+    case 'd': case 'D': return 'right';
+    case 'r': case 'R': return 'restart';
+    case 'p': case 'P': return 'pause';
+    case 'q': case 'Q': return 'quit';
+    case ' ': return 'space';
+    case '\r': case '\n': return 'enter';
+    case '\x03': return 'quit'; // Ctrl-C
+    default: return null;
+  }
+}

package/src/install.js

@@ -0,0 +1,32 @@
+import { settingsPath, readSettings, writeSettings } from './settings.js';
+import { withTermGameHooks, withoutTermGameHooks } from './hooks.js';
+import { launcherCommand } from './launcher.js';
+
+function manualSnippet(cmd) {
+  const snippet = {
+    hooks: {
+      UserPromptSubmit: [{ hooks: [{ type: 'command', command: `${cmd} _start` }] }],
+      Stop: [{ hooks: [{ type: 'command', command: `${cmd} _stop` }] }],
+    },
+  };
+  return JSON.stringify(snippet, null, 2) + '\n';
+}
+
+export function install(env = process.env, out = process.stdout, cmd = launcherCommand()) {
+  const path = settingsPath(env);
+  writeSettings(path, withTermGameHooks(readSettings(path), cmd));
+  out.write(`afk-snake: installed wait-game hooks in ${path}\n`);
+  out.write(`  UserPromptSubmit -> ${cmd} _start\n`);
+  out.write(`  Stop             -> ${cmd} _stop\n`);
+  out.write(`Run your agent inside tmux for the popup. Remove with: afk-snake uninstall\n`);
+  out.write(`\nManual equivalent (merge into ${path} yourself if you prefer;\n`);
+  out.write(`note: hooks added by hand must also be removed by hand — uninstall only\n`);
+  out.write(`removes hooks written by 'afk-snake install'):\n`);
+  out.write(manualSnippet(cmd));
+}
+
+export function uninstall(env = process.env, out = process.stdout) {
+  const path = settingsPath(env);
+  writeSettings(path, withoutTermGameHooks(readSettings(path)));
+  out.write(`afk-snake: removed wait-game hooks from ${path}\n`);
+}

package/src/launcher.js

@@ -0,0 +1,37 @@
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+// This package's own entry point — always present, so it is the reliable
+// dev/local fallback for launching the game.
+export const LOCAL_ENTRY = join(dirname(fileURLToPath(import.meta.url)), 'index.js');
+
+export function isInsideTmux(env = process.env) {
+  return Boolean(env.TMUX);
+}
+
+// Pure. onPath: did `term-game` resolve on PATH? (Param is named `onPath`, not
+// `termGameOnPath`, to avoid colliding with the probe function of that name.)
+// Tier 1 also covers a global install and `npx afk-snake` after publish.
+export function resolveGameCommand({ onPath, localEntry = LOCAL_ENTRY }) {
+  if (onPath) return ['afk-snake'];
+  return ['node', localEntry];
+}
+
+// Thin (not unit-tested): probe whether `term-game` is runnable on PATH.
+export function termGameOnPath() {
+  try {
+    execSync('command -v afk-snake', { stdio: 'ignore', shell: '/bin/sh' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Thin: the resolved launch command as a single string, for hook commands.
+// Path segments containing spaces are quoted so a space in the install dir
+// doesn't break shell tokenisation when the string is embedded in a hook.
+export function launcherCommand() {
+  const parts = resolveGameCommand({ onPath: termGameOnPath() });
+  return parts.map((p) => (p.includes(' ') ? `"${p}"` : p)).join(' ');
+}

package/src/login.js

@@ -0,0 +1,57 @@
+// src/login.js
+// The `afk-snake login` GitHub device flow. Runs in a normal shell (never inside the
+// real-time popup). Everything is injectable so it tests without network or delays.
+import { saveAuth as realSaveAuth } from './profile.js';
+import { createApi } from './api.js';
+
+// Public OAuth client id for the term-game device flow (no secret needed).
+export const GITHUB_CLIENT_ID = 'Ov23liVs5WRAqLXaySlG';
+const DEFAULT_BASE = 'https://term-game-api.jsiwinski2.workers.dev';
+
+export async function login({
+  fetch = globalThis.fetch,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+  out = process.stdout,
+  saveAuth = realSaveAuth,
+  env = process.env,
+  clientId = GITHUB_CLIENT_ID,
+} = {}) {
+  const codeRes = await fetch('https://github.com/login/device/code', {
+    method: 'POST',
+    headers: { accept: 'application/json', 'content-type': 'application/json' },
+    body: JSON.stringify({ client_id: clientId, scope: '' }),
+  });
+  const code = await codeRes.json();
+  out.write(`\nGo to ${code.verification_uri} and enter code: ${code.user_code}\n`);
+
+  let interval = code.interval || 5;
+  const deadline = (code.expires_in || 900);
+  let elapsed = 0;
+  while (elapsed < deadline) {
+    await sleep(interval * 1000);
+    elapsed += interval;
+    const tokRes = await fetch('https://github.com/login/oauth/access_token', {
+      method: 'POST',
+      headers: { accept: 'application/json', 'content-type': 'application/json' },
+      body: JSON.stringify({
+        client_id: clientId,
+        device_code: code.device_code,
+        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+      }),
+    });
+    const tok = await tokRes.json();
+    if (tok.access_token) {
+      const api = createApi(env.TERM_GAME_API || DEFAULT_BASE, { fetch });
+      const session = await api.postLogin(tok.access_token);
+      saveAuth({ token: session.token, login: session.login });
+      out.write(`\nWelcome, @${session.login}\n`);
+      return { ok: true, login: session.login };
+    }
+    if (tok.error === 'authorization_pending') continue;
+    if (tok.error === 'slow_down') { interval += 5; continue; }
+    out.write(`\nLogin failed: ${tok.error || 'unknown error'}\n`);
+    return { ok: false, error: tok.error };
+  }
+  out.write('\nLogin timed out. Run `afk-snake login` again.\n');
+  return { ok: false, error: 'timeout' };
+}

package/src/loop.js

@@ -0,0 +1,204 @@
+import { randomUUID } from 'node:crypto';
+import { createGame, turn, step } from './engine.js';
+import { drawFrame, fitBoard, clearScreen, overlayCenter } from './render.js';
+import { mapKey } from './input.js';
+import { nextBest } from './highscore.js';
+import { gameOverCard } from './gameover.js';
+import { readyCard } from './readycard.js';
+import { loadSession, saveSession, clearSession } from './session.js';
+import { canResume } from './resume.js';
+import { createEconomyClient } from './economyClient.js';
+import { economyLine } from './economyFooter.js';
+
+const BASE_TICK_MS = 100;
+const MIN_TICK_MS = 55;
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const PLAY_HINT = 'p pause · q quit';
+const PAUSE_HINT = 'paused · arrows resume · Enter back to Claude · q quit';
+const READY_FOOTER = '✓ agent ready · Enter to return';
+
+export function run(out = process.stdout, inp = process.stdin, economy = createEconomyClient()) {
+  const size = fitBoard(out.columns, out.rows);
+  if (!size) {
+    out.write('afk-snake needs a bigger terminal window. Resize and try again.\n');
+    process.exit(1);
+  }
+
+  const saved = loadSession();
+  const resuming = canResume(saved, size);
+  let state = resuming ? saved : createGame(size);
+  let lastScore = state.score;
+  let paused = resuming;
+  let ready = false;
+  let agentReady = false;
+  let best = 0;
+  let gameId = randomUUID();
+  let startTime = Date.now();
+  let economyText = null;   // the game-over economy line, once known
+  let glowPending = false;  // guards against a double-buy while /unlocks is in flight
+  let timer = null;
+
+  // Pull account state in the background; when it lands, refresh best + redraw (for glow).
+  economy.load().then(() => { best = economy.best; draw(); }).catch(() => {});
+
+  const tickMs = () => Math.max(MIN_TICK_MS, BASE_TICK_MS - state.score * 6);
+
+  const cleanup = () => {
+    if (timer) { clearInterval(timer); timer = null; }
+    if (inp.isTTY) inp.setRawMode(false);
+    inp.pause();
+    out.write(SHOW_CURSOR + '\n');
+  };
+  const quit = (code = 0) => { clearSession(); cleanup(); process.exit(code); };
+  const saveAndExit = () => {
+    if (state.status === 'playing') saveSession(state);
+    cleanup();
+    process.exit(0);
+  };
+
+  const showReady = () => {
+    agentReady = true;
+    ready = true;
+    if (timer) { clearInterval(timer); timer = null; }
+    draw();
+  };
+
+  const board = () => drawFrame(state, { glow: economy.hasGlow() });
+
+  const drawGameOver = () => {
+    const card = gameOverCard({ score: state.score, best, isNewBest: state.score >= best && state.score > 0, economyLine: economyText });
+    out.write(clearScreen() + overlayCenter(board(), card.split('\n')).join('\r\n'));
+  };
+
+  const draw = () => {
+    if (state.status === 'over') return drawGameOver();
+    if (ready) {
+      const composed = overlayCenter(board(), readyCard().split('\n'));
+      out.write(clearScreen() + composed.join('\r\n'));
+      return;
+    }
+    const lines = board();
+    if (paused) lines.push(PAUSE_HINT);
+    else if (agentReady) lines.push(READY_FOOTER);
+    else if (state.status === 'playing') lines[lines.length - 1] += '   ·   ' + PLAY_HINT;
+    out.write(clearScreen() + lines.join('\r\n'));
+  };
+
+  const schedule = () => {
+    if (timer) clearInterval(timer);
+    timer = setInterval(onTick, tickMs());
+  };
+
+  const newGame = () => {
+    clearSession();
+    state = createGame(size);
+    lastScore = 0;
+    paused = false;
+    gameId = randomUUID();
+    startTime = Date.now();
+    economyText = null;
+    draw();
+    schedule();
+  };
+
+  // On game-over: set best, show the card immediately, then (logged in) post facts and
+  // refresh the economy line with the server's truth.
+  function onGameOver() {
+    clearInterval(timer); timer = null;
+    clearSession();
+    best = nextBest(best, state.score).best;
+    if (economy.loggedIn) {
+      economyText = economyLine({ loggedIn: true, awarded: state.score, balance: economy.balance, canAfford: economy.canBuyGlow() });
+      drawGameOver();
+      economy.submitGame({ gameId, score: state.score, durationMs: Date.now() - startTime, foodsEaten: state.score })
+        .then((r) => {
+          if (!r) return;
+          best = nextBest(best, r.best).best;
+          economyText = economyLine({ loggedIn: true, awarded: r.awarded, balance: economy.balance, canAfford: economy.canBuyGlow() });
+          drawGameOver();
+        })
+        .catch(() => {});
+    } else {
+      economyText = economyLine({ loggedIn: false, awarded: state.score });
+      drawGameOver();
+    }
+  }
+
+  function onTick() {
+    state = step(state);
+    if (state.status === 'over') return onGameOver();
+    if (state.score !== lastScore) { lastScore = state.score; schedule(); }
+    draw();
+  }
+
+  function onKey(data) {
+    const intent = mapKey(data);
+    if (ready) {
+      if (intent === 'enter') return saveAndExit();
+      const RESUME = ['space', 'up', 'down', 'left', 'right'];
+      if (RESUME.includes(intent)) {
+        if (state.status !== 'playing') return;
+        ready = false;
+        paused = true;
+        draw();
+        return;
+      }
+      return;
+    }
+    // Game-over: [S] buys the glow skin, [A] points to `afk-snake login`. Read the raw
+    // key because 's'/'a' map to movement (WASD), which is irrelevant on a dead game.
+    if (state.status === 'over') {
+      const raw = data.toString().toLowerCase();
+      if (raw === 's' && economy.canBuyGlow() && !glowPending) {
+        glowPending = true;
+        economy.buyGlow().then((res) => {
+          glowPending = false;
+          economyText = res.ok
+            ? 'Glowing trail unlocked'
+            : economyLine({ loggedIn: economy.loggedIn, awarded: state.score, balance: economy.balance, canAfford: economy.canBuyGlow() });
+          drawGameOver();
+        }).catch(() => { glowPending = false; });
+        return;
+      }
+      if (raw === 'a' && !economy.loggedIn) {
+        economyText = 'run: afk-snake login';
+        drawGameOver();
+        return;
+      }
+    }
+    if (paused) {
+      if (intent === 'quit') return quit(0);
+      if (intent === 'restart') return newGame();
+      if (intent === 'enter') return saveAndExit();
+      paused = false;
+      if (intent && intent !== 'space' && intent !== 'pause') state = turn(state, intent);
+      draw();
+      schedule();
+      return;
+    }
+    if (!intent) return;
+    if (intent === 'quit') return quit(0);
+    if (intent === 'restart') return newGame();
+    if (intent === 'enter') { if (agentReady) return saveAndExit(); return; }
+    if (intent === 'pause') {
+      if (state.status !== 'playing') return;
+      paused = true;
+      if (timer) { clearInterval(timer); timer = null; }
+      draw();
+      return;
+    }
+    if (intent === 'space') return;
+    if (state.status === 'playing') state = turn(state, intent);
+  }
+
+  if (inp.isTTY) inp.setRawMode(true);
+  inp.resume();
+  inp.on('data', onKey);
+  process.on('SIGINT', () => quit(0));
+  process.on('SIGTERM', saveAndExit);
+  process.on('SIGUSR2', showReady);
+  out.write(HIDE_CURSOR);
+  draw();
+  if (!paused) schedule();
+}

package/src/popup.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isInsideTmux, resolveGameCommand, termGameOnPath, LOCAL_ENTRY } from './launcher.js';
+
+// The popup runs a wrapper shell that records its OWN pid (which `exec` then
+// hands to the game process) so the Stop hook can SIGTERM the real game. The
+// game's existing SIGTERM handler restores the terminal and exits, the popup
+// command finishes, and tmux closes the popup.
+export function buildPopupCommand(gameArgv, pidfile) {
+  // Quote argv parts and the pidfile that contain spaces, so an install path
+  // like `~/My Projects/term_game` doesn't word-split inside the wrapper shell.
+  const game = gameArgv.map((p) => (p.includes(' ') ? `"${p}"` : p)).join(' ');
+  return `sh -c 'echo $$ > "${pidfile}"; exec ${game}'`;
+}
+
+export function pidfilePath(env = process.env) {
+  return join(env.TMPDIR || tmpdir(), 'term-game-popup.pid');
+}
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+// UserPromptSubmit hook: agent started working.
+export function startPopup(env = process.env, out = process.stderr) {
+  if (!isInsideTmux(env)) {
+    out.write('afk-snake: run inside tmux to enable the wait-game popup.\n');
+    return;
+  }
+  const pidfile = pidfilePath(env);
+  if (existsSync(pidfile)) {
+    const pid = Number(readFileSync(pidfile, 'utf8').trim());
+    if (pid && pidAlive(pid)) return; // already up -> no stacked popups
+  }
+  const gameArgv = resolveGameCommand({ onPath: termGameOnPath(), localEntry: LOCAL_ENTRY });
+  const popupCmd = buildPopupCommand(gameArgv, pidfile);
+  // Detached + unref so the hook returns immediately and never blocks the agent.
+  const child = spawn('tmux', ['display-popup', '-E', '-w', '90%', '-h', '90%', popupCmd], {
+    stdio: 'ignore',
+    detached: true,
+  });
+  // spawn errors (e.g. tmux not on PATH) arrive async as an 'error' event;
+  // swallow them so a hook environment without tmux never crashes the agent.
+  child.on('error', () => {});
+  child.unref();
+}
+
+// Stop hook: agent finished its turn. Signal the running game (SIGUSR2) to show its
+// "Your Agent is Ready" card. Do NOT kill it or close the popup — the game closes itself
+// when the player presses Enter. Leave the pidfile in place (the game is still alive).
+export function stopPopup(env = process.env) {
+  const pidfile = pidfilePath(env);
+  if (!existsSync(pidfile)) return;
+  const pid = Number(readFileSync(pidfile, 'utf8').trim());
+  if (pid && pidAlive(pid)) {
+    try { process.kill(pid, 'SIGUSR2'); } catch {}
+  }
+}

package/src/profile.js

@@ -0,0 +1,36 @@
+// src/profile.js
+import { readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const PROFILE_PATH = join(homedir(), '.term-game.json');
+
+export function loadProfile(path = PROFILE_PATH) {
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    return data && typeof data === 'object' ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+export function saveProfile(profile, path = PROFILE_PATH) {
+  writeFileSync(path, JSON.stringify(profile), 'utf8');
+}
+
+export function loadAuth(path = PROFILE_PATH) {
+  const { auth } = loadProfile(path);
+  return auth && typeof auth.token === 'string' ? auth : null;
+}
+
+export function saveAuth({ token, login }, path = PROFILE_PATH) {
+  const profile = loadProfile(path);
+  profile.auth = { token, login };
+  saveProfile(profile, path);
+}
+
+export function clearAuth(path = PROFILE_PATH) {
+  const profile = loadProfile(path);
+  delete profile.auth;
+  saveProfile(profile, path);
+}

package/src/readycard.js

@@ -0,0 +1,21 @@
+// Built programmatically so every line is exactly the same length — required for the
+// centered overlay (overlayCenter). No wide emoji (which would break column alignment).
+export function readyCard() {
+  const W = 34; // inner width (between the side borders)
+  const pad = (s) => {
+    const total = Math.max(0, W - s.length);
+    const left = Math.floor(total / 2);
+    return ' '.repeat(left) + s + ' '.repeat(total - left);
+  };
+  // label padded to a fixed width so the arrows line up across action rows
+  const action = (label, desc) => ('   ' + label.padEnd(14) + '→  ' + desc).padEnd(W).slice(0, W);
+  const row = (s) => '│' + s + '│';
+  return [
+    '┌' + '─'.repeat(W) + '┐',
+    row(pad('YOUR AGENT IS READY')),
+    row(' '.repeat(W)),
+    row(action('Enter', 'back to Claude')),
+    row(action('Space/Arrows', 'resume playing')),
+    '└' + '─'.repeat(W) + '┘',
+  ].join('\n');
+}

package/src/render.js

@@ -0,0 +1,66 @@
+import { paintCell } from './glow.js';
+
+const RESET = '\x1b[0m';
+
+export const CHARS = {
+  head: '@', body: 'o', food: '*', empty: ' ',
+  h: '─', v: '│', tl: '┌', tr: '┐', bl: '└', br: '┘',
+};
+
+export function fitBoard(cols, rows, min = { width: 10, height: 8 }) {
+  const width = (cols ?? 0) - 2;   // 2 vertical borders
+  const height = (rows ?? 0) - 3;  // 2 horizontal borders + 1 score line
+  if (width < min.width || height < min.height) return null;
+  return { width, height };
+}
+
+export function drawFrame(state, { glow = false } = {}) {
+  const { width, height, snake, foods, score } = state;
+  const grid = [];
+  for (let y = 0; y < height; y++) grid.push(new Array(width).fill(CHARS.empty));
+  for (const f of foods) grid[f.y][f.x] = CHARS.food;
+  snake.forEach((c, i) => {
+    const ch = i === 0 ? CHARS.head : CHARS.body;
+    grid[c.y][c.x] = glow ? paintCell(ch, i) : ch;
+  });
+
+  const lines = [];
+  lines.push(CHARS.tl + CHARS.h.repeat(width) + CHARS.tr);
+  for (const row of grid) lines.push(CHARS.v + row.join('') + CHARS.v);
+  lines.push(CHARS.bl + CHARS.h.repeat(width) + CHARS.br);
+  lines.push(`Score: ${score}`);
+  return lines;
+}
+
+const ESC = '\x1b[';
+export function clearScreen() {
+  return `${ESC}2J${ESC}H`;
+}
+
+// Split a line into visible cells (1 display column each), where any ANSI escape
+// run attaches to the printable char that follows it. We only emit our own escapes
+// (colour + reset), so this is sufficient.
+function visibleCells(line) {
+  return line.match(/(?:\x1b\[[0-9;]*m)*[\s\S]/g) || [];
+}
+
+// Write `card` lines centered over `base` lines. For plain lines this is the original
+// byte-for-byte behavior; for lines containing ANSI it splices by VISIBLE column and
+// wraps the inserted card text in resets so ambient colour never bleeds into it.
+export function overlayCenter(base, card) {
+  if (card.length === 0) return [...base];
+  const rowOffset = Math.max(0, Math.floor((base.length - card.length) / 2));
+  return base.map((line, i) => {
+    const c = card[i - rowOffset];
+    if (c === undefined) return line;
+    if (!line.includes('\x1b')) {
+      const colOffset = Math.max(0, Math.floor((line.length - c.length) / 2));
+      return line.slice(0, colOffset) + c + line.slice(colOffset + c.length);
+    }
+    const cells = visibleCells(line);
+    const colOffset = Math.max(0, Math.floor((cells.length - c.length) / 2));
+    const left = cells.slice(0, colOffset).join('');
+    const right = cells.slice(colOffset + c.length).join('');
+    return left + RESET + c + RESET + right;
+  });
+}

package/src/resume.js

@@ -0,0 +1,11 @@
+// Decide whether a loaded session should resume, or be discarded for a fresh game.
+// Resume only an in-progress game whose board still fits the current popup size.
+export function canResume(saved, size) {
+  return Boolean(
+    saved &&
+    saved.status === 'playing' &&
+    size &&
+    saved.width <= size.width &&
+    saved.height <= size.height,
+  );
+}

package/src/session.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export function sessionPath(env = process.env) {
+  return join(env.TMPDIR || tmpdir(), 'term-game-session.json');
+}
+
+export function saveSession(state, env = process.env) {
+  const { rng, ...rest } = state; // rng is a function — not JSON-serializable
+  writeFileSync(sessionPath(env), JSON.stringify(rest), 'utf8');
+}
+
+export function loadSession(env = process.env) {
+  try {
+    const data = JSON.parse(readFileSync(sessionPath(env), 'utf8'));
+    if (!data || !Array.isArray(data.snake) || typeof data.score !== 'number') return null;
+    // back-compat: pre-multi-food saves stored a single `food`; normalise to `foods`.
+    if (!Array.isArray(data.foods)) data.foods = data.food ? [data.food] : [];
+    delete data.food;
+    return { ...data, rng: Math.random };
+  } catch {
+    return null;
+  }
+}
+
+export function clearSession(env = process.env) {
+  rmSync(sessionPath(env), { force: true }); // force: tolerate a missing file, surface real errors
+}

package/src/settings.js

@@ -0,0 +1,21 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+
+export function settingsPath(env = process.env) {
+  const home = env.HOME || homedir();
+  return join(home, '.claude', 'settings.json');
+}
+
+export function readSettings(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+}

package/src/skins.js

@@ -0,0 +1,11 @@
+// src/skins.js
+// Shared id for the one v1 unlock (mirrors server/src/catalog.js) + ownership check.
+export const SKIN_GLOW = 'skin-glow';
+
+export function hasGlow(unlocks = []) {
+  return Array.isArray(unlocks) && unlocks.includes(SKIN_GLOW);
+}
+
+// Client-side mirror of the server catalog price, used only to decide whether to
+// show the [S] spend prompt. The server remains authoritative on the actual charge.
+export const GLOW_PRICE = 30;