@g3nomaly/g3n-mods 0.1.5 → 0.1.7

package/mods/mini-game/hooks/mole.ts

@@ -0,0 +1,91 @@
+// packages/g3n-mods/mods/mini-game/hooks/mole.ts
+import type { Whack } from '../types'
+
+const SIZE = 4
+export const LIVES = 3
+/** How long the first mole stays up. */
+const START_WINDOW_MS = 1400
+/** How long a mole stays up at the fastest. */
+const MIN_WINDOW_MS = 450
+/** What each hit multiplies the window by, so the game speeds up. */
+const SPEEDUP = 0.94
+
+/**
+ * Creates a game in the `ready` state, with no mole up.
+ *
+ * @returns The new game, see `Whack`.
+ */
+export function newWhack(): Whack {
+  return { size: SIZE, mole: null, moleId: 0, score: 0, lives: LIVES, windowMs: START_WINDOW_MS, status: 'ready' }
+}
+
+/**
+ * Puts the next mole up, in a hole other than the current one.
+ *
+ * @param game - Game to put the mole up in, see `Whack`.
+ * @returns The game with the new mole and its id.
+ */
+function nextMole(game: Whack): Whack {
+  const holes = game.size * game.size
+  const offset = 1 + Math.floor(Math.random() * (holes - 1))
+  const mole = game.mole === null ? Math.floor(Math.random() * holes) : (game.mole + offset) % holes
+  return { ...game, mole, moleId: game.moleId + 1 }
+}
+
+/**
+ * Takes a life; the last one ends the game.
+ *
+ * @param game - Game to take the life from, see `Whack`.
+ * @returns The game after the loss.
+ */
+function loseLife(game: Whack): Whack {
+  const lives = game.lives - 1
+  return lives === 0 ? { ...game, lives, mole: null, status: 'over' } : { ...game, lives }
+}
+
+/**
+ * Starts the game with its first mole up.
+ *
+ * @param game - Game to start, see `Whack`.
+ * @returns The game in the `playing` state, or the same game when it is already on.
+ */
+export function startWhack(game: Whack): Whack {
+  return game.status === 'playing' ? game : nextMole({ ...newWhack(), status: 'playing' })
+}
+
+/**
+ * Whacks one hole: the mole scores and speeds the game up, an empty hole costs a life.
+ *
+ * @param game - Game to whack in, see `Whack`.
+ * @param hole - Hole number, counted row by row from `0`.
+ * @returns The game after the whack, or the same game when it is not on.
+ */
+export function whack(game: Whack, hole: number): Whack {
+  if (game.status !== 'playing') return game
+  if (hole !== game.mole) return loseLife(game)
+  const windowMs = Math.max(MIN_WINDOW_MS, Math.round(game.windowMs * SPEEDUP))
+  return nextMole({ ...game, score: game.score + 1, windowMs })
+}
+
+/**
+ * Lets a mole escape when its time runs out, which costs a life.
+ *
+ * @param game - Game the mole was up in, see `Whack`.
+ * @param moleId - Mole whose time ran out; a mole already whacked or gone is ignored.
+ * @returns The game after the escape, or the same game when that mole is no longer up.
+ */
+export function escape(game: Whack, moleId: number): Whack {
+  if (game.status !== 'playing' || game.moleId !== moleId) return game
+  const after = loseLife(game)
+  return after.status === 'over' ? after : nextMole(after)
+}
+
+/**
+ * Ends a round early, keeping its score.
+ *
+ * @param game - Game to end, see `Whack`.
+ * @returns The game in the `over` state, or the same game when it is not on.
+ */
+export function quit(game: Whack): Whack {
+  return game.status === 'playing' ? { ...game, mole: null, status: 'over' } : game
+}

package/mods/mini-game/hooks/register.tsx

@@ -1,123 +1,69 @@
 // packages/g3n-mods/mods/mini-game/hooks/register.tsx
 import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register } from 'claude-code'
+import type { EngineInterface, Register, RenderChildren } from 'claude-code'
 
-import type { Game } from '../types'
+import type { Game, View, Whack } from '../types'
+import { adjacentMines, newGame, reveal, toggleFlag } from './minesweeper'
+import { LIVES, escape, newWhack, quit, startWhack, whack as whackHole } from './mole'
 
 const PANE = 'mini-game'
-const TITLE = 'Minesweeper'
+const TITLES: Record<View, string> = { mines: 'Minesweeper', mole: 'Whack-a-mole' }
+/** What `/mini-game` takes after its name, each mapped to the game it opens. */
+const VIEW_ARGS: Record<string, View> = { mines: 'mines', minesweeper: 'mines', mole: 'mole', whack: 'mole' }
+
+const view = atom({ plugin: 'mini-game', key: 'view' } as const, 'mines')
 const game = atom({ plugin: 'mini-game', key: 'game' } as const, null)
 const best = atom({ plugin: 'mini-game', key: 'best' } as const, null)
+const whack = atom({ plugin: 'mini-game', key: 'whack' } as const, null)
+const whackBest = atom({ plugin: 'mini-game', key: 'whackBest' } as const, null)
 
-const SIZE = 9
-const MINES = 10
 const BEST_KEY = 'best-seconds'
+const WHACK_BEST_KEY = 'whack-best'
 /** How long a turn runs before the mod suggests a game, once per session. */
 const HINT_AFTER_MS = 60_000
-/** Width of every cell, in columns: room for the widest glyph (`■`, `⚑`, `✹`) on any surface. */
+/** Width of every cell, in columns: room for the widest glyph (`■`, `⚑`, `✹`, `🐹`) on any surface. */
 const CELL_WIDTH = 2
 
 const NUMBER_COLORS = [undefined, '#6b8fd6', '#7cc47f', '#e06c6c', '#9b87f5', '#e0775a', '#5fb3c4', '#d0d0d0', '#8a8f98']
 
 /**
- * Lists the cells around `cell` on a `size` × `size` board.
- *
- * @param cell - Cell number, counted row by row from `0`.
- * @param size - Board width and height in cells.
- * @returns The neighboring cell numbers, from one to eight of them.
- */
-export function neighbors(cell: number, size: number): number[] {
-  const row = Math.floor(cell / size)
-  const col = cell % size
-  const found: number[] = []
-  for (let dr = -1; dr <= 1; dr++) {
-    for (let dc = -1; dc <= 1; dc++) {
-      const r = row + dr
-      const c = col + dc
-      if ((dr !== 0 || dc !== 0) && r >= 0 && r < size && c >= 0 && c < size) found.push(r * size + c)
-    }
-  }
-  return found
-}
-
-/**
- * Counts the mines in the cells around `cell`.
- *
- * @param board - Board to read, see `Game`.
- * @param cell - Cell number to count around.
- * @returns Number of neighboring mines, from `0` to `8`.
- */
-function adjacentMines(board: Game, cell: number): number {
-  return neighbors(cell, board.size).filter(n => board.mines.includes(n)).length
-}
-
-/**
- * Picks random cells for the mines, leaving `safe` and the cells around it free.
- *
- * @param board - Board to place mines on, see `Game`.
- * @param safe - Cell the first reveal hit, which must not be a mine.
- * @returns Mine cell numbers, `board.mineCount` of them.
- */
-function placeMines(board: Game, safe: number): number[] {
-  const banned = new Set([safe, ...neighbors(safe, board.size)])
-  const free = Array.from({ length: board.size * board.size }, (_, i) => i).filter(i => !banned.has(i))
-  for (let i = free.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1))
-    ;[free[i], free[j]] = [free[j] ?? 0, free[i] ?? 0]
-  }
-  return free.slice(0, board.mineCount)
-}
-
-/**
- * @brief Reveals one cell: the first reveal places the mines, a zero opens its
- * neighbours, a mine ends the game, and the last safe cell wins it.
+ * Shows the pane, titled after the game it holds.
  *
- * @param board - Board to reveal on, see `Game`.
- * @param cell - Cell number to reveal.
- * @param now - Milliseconds since the epoch, stamped as the start or end time.
- * @returns The board after the reveal, or the same board when the cell cannot be revealed.
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
  */
-export function reveal(board: Game, cell: number, now: number): Game {
-  if (board.status === 'won' || board.status === 'lost') return board
-  if (board.revealed.includes(cell) || board.flagged.includes(cell)) return board
-
-  const mines = board.status === 'ready' ? placeMines(board, cell) : board.mines
-  const started: Game = board.status === 'ready' ? { ...board, mines, status: 'playing', startedAt: now } : board
-  if (mines.includes(cell)) return { ...started, revealed: [...started.revealed, cell], status: 'lost', endedAt: now }
-
-  const open = new Set(started.revealed)
-  const queue = [cell]
-  while (queue.length > 0) {
-    const next = queue.pop() ?? cell
-    if (open.has(next) || started.flagged.includes(next)) continue
-    open.add(next)
-    if (adjacentMines(started, next) === 0) queue.push(...neighbors(next, started.size).filter(n => !open.has(n)))
-  }
-
-  const revealed = [...open]
-  const isWon = revealed.length === started.size * started.size - started.mineCount
-  return isWon ? { ...started, revealed, status: 'won', endedAt: now } : { ...started, revealed }
+async function openPane($: EngineInterface): Promise<void> {
+  await $.ui.open({ id: PANE, title: TITLES[await read($, view)] })
 }
 
 /**
- * Creates a board in the `ready` state, with no mines placed yet.
+ * Starts a new Minesweeper board and shows the pane.
  *
- * @param now - Milliseconds since the epoch, stamped as the start time.
- * @returns The new board, see `Game`.
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
  */
-function newGame(now: number): Game {
-  return { size: SIZE, mineCount: MINES, mines: [], revealed: [], flagged: [], status: 'ready', isFlagMode: false, startedAt: now }
+async function startGame($: EngineInterface): Promise<void> {
+  const now = await $.clock.now()
+  await update($, game, () => newGame(now))
+  await openPane($)
 }
 
 /**
- * Starts a new board and shows the pane.
+ * Switches the pane to `next`, setting up its game when there is none to play.
+ * Leaving whack-a-mole mid-round ends the round, so moles do not escape unseen.
  *
  * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @param next - Game to show.
  */
-async function startGame($: EngineInterface): Promise<void> {
-  const now = await $.clock.now()
-  await update($, game, () => newGame(now))
-  await $.ui.open({ id: PANE, title: TITLE })
+async function showView($: EngineInterface, next: View): Promise<void> {
+  await update($, view, () => next)
+  if (next === 'mole') {
+    await update($, whack, current => current ?? newWhack())
+    await openPane($)
+    return
+  }
+  await changeWhack($, quit)
+  const current = await read($, game)
+  if (current === null || current.status === 'won' || current.status === 'lost') await startGame($)
+  else await openPane($)
 }
 
 /**
@@ -130,10 +76,7 @@ async function pressCell($: EngineInterface, cell: number): Promise<void> {
   const now = await $.clock.now()
   const after = await update($, game, board => {
     if (board === null) return board
-    if (!board.isFlagMode) return reveal(board, cell, now)
-    if (board.revealed.includes(cell) || board.status === 'won' || board.status === 'lost') return board
-    const flagged = board.flagged.includes(cell) ? board.flagged.filter(c => c !== cell) : [...board.flagged, cell]
-    return { ...board, flagged }
+    return board.isFlagMode ? toggleFlag(board, cell) : reveal(board, cell, now)
   })
   if (after?.status === 'won' && after.endedAt === now) {
     const seconds = Math.round((now - after.startedAt) / 1000)
@@ -156,12 +99,46 @@ async function toggleFlagMode($: EngineInterface): Promise<void> {
 }
 
 /**
- * Redraws the timer once a second while a game is on.
+ * Applies `change` to the whack-a-mole game, times each new mole's escape, and
+ * records the score when the round ends.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @param change - Pure step from `mole.ts` to apply.
+ */
+async function changeWhack($: EngineInterface, change: (current: Whack) => Whack): Promise<void> {
+  let wasPlaying = false
+  let moleIdBefore = 0
+  const after = await update($, whack, current => {
+    if (current === null) return current
+    wasPlaying = current.status === 'playing'
+    moleIdBefore = current.moleId
+    return change(current)
+  })
+  if (after === null) return
+
+  if (after.status === 'playing' && after.moleId !== moleIdBefore) {
+    const moleId = after.moleId
+    $.clock.after(after.windowMs, () => void changeWhack($, current => escape(current, moleId)))
+  }
+
+  if (wasPlaying && after.status === 'over') {
+    const previous = await read($, whackBest)
+    const isBest = after.score > 0 && (previous === null || after.score > previous)
+    if (isBest) {
+      await update($, whackBest, () => after.score)
+      await $.store.set(WHACK_BEST_KEY, after.score)
+    }
+    $.ui.toast(`Game over: ${after.score} whacked${isBest ? ', a new high score' : ''}`)
+  }
+}
+
+/**
+ * Redraws the timer once a second while a Minesweeper game is on.
  *
  * @param $ - Engine handle the hook received, see `EngineInterface`.
  */
 async function tick($: EngineInterface): Promise<void> {
-  if ((await read($, game))?.status === 'playing') $.ui.invalidate('ui.render')
+  if ((await read($, view)) === 'mines' && (await read($, game))?.status === 'playing') $.ui.invalidate('ui.render')
 }
 
 let hintTurn: string | undefined
@@ -177,7 +154,7 @@ async function hint($: EngineInterface, turnId: string): Promise<void> {
   if (isHinted || hintTurn !== turnId) return
   if ((await $.ui.panes()).some(pane => pane.id === PANE)) return
   isHinted = true
-  $.ui.toast('Waiting on Claude? /mini-game opens Minesweeper.')
+  $.ui.toast('Waiting on Claude? /mini-game opens Minesweeper, /mini-game mole opens whack-a-mole.')
 }
 
 /**
@@ -187,19 +164,26 @@ async function hint($: EngineInterface, turnId: string): Promise<void> {
  */
 export const register: Register = on => {
   on('session.start', async ($, e, next) => {
-    await $.command.register({ name: 'mini-game', description: 'Play Minesweeper while Claude works' })
-    const stored = await $.store.get(BEST_KEY)
-    if (typeof stored === 'number') await update($, best, () => stored)
-    void $.ui.open({ id: PANE, title: TITLE })
+    await $.command.register({ name: 'mini-game', description: 'Play Minesweeper or whack-a-mole while Claude works' })
+    const storedBest = await $.store.get(BEST_KEY)
+    if (typeof storedBest === 'number') await update($, best, () => storedBest)
+    const storedWhackBest = await $.store.get(WHACK_BEST_KEY)
+    if (typeof storedWhackBest === 'number') await update($, whackBest, () => storedWhackBest)
+    void openPane($)
     $.clock.every(1000, () => void tick($))
     return next(e)
   })
 
-  on('command.run', { command: 'mini-game' }, async $ => {
-    const current = await read($, game)
-    if (current === null || current.status === 'won' || current.status === 'lost') await startGame($)
-    else await $.ui.open({ id: PANE, title: TITLE })
-    return { text: 'Minesweeper is open. Clear the board without hitting a mine.' }
+  on('command.run', { command: 'mini-game' }, async ($, e) => {
+    const arg = e.args.trim().toLowerCase()
+    const next = arg === '' ? await read($, view) : VIEW_ARGS[arg]
+    if (next === undefined) return { text: `Unknown game "${arg}". Use /mini-game mines or /mini-game mole.`, exitCode: 1 }
+    await showView($, next)
+    return {
+      text: next === 'mines'
+        ? 'Minesweeper is open. Clear the board without hitting a mine.'
+        : 'Whack-a-mole is open. Hit the mole before it hides; three misses and the round ends.',
+    }
   })
 
   on('turn.start', async ($, e, next) => {
@@ -216,66 +200,126 @@ export const register: Register = on => {
 
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
     const { Box, Text, Button } = $.ui.resolve(e)
-    const board = await read($, game)
-    if (board === null) {
-      return <Button key="new" label="new game" variant="primary" onPress={() => startGame($)} />
-    }
+    const current = await read($, view)
 
-    const now = await $.clock.now()
-    const elapsed = board.status === 'ready' ? 0 : Math.round(((board.endedAt ?? now) - board.startedAt) / 1000)
-    const record = await read($, best)
-    const isOver = board.status === 'won' || board.status === 'lost'
+    const tabs = (
+      <Box flexDirection="row" columnGap={1}>
+        {(Object.keys(TITLES) as View[]).map(v => (
+          <Button key={`view:${v}`} label={TITLES[v]} variant={v === current ? 'primary' : 'secondary'} onPress={() => showView($, v)} />
+        ))}
+      </Box>
+    )
+
+    // Every cell sits in a box of one fixed width, so changing a cell never moves the others: glyphs differ in width.
+    const grid = (size: number, face: (cell: number) => RenderChildren) => (
+      <Box flexDirection="column">
+        {Array.from({ length: size }, (_, r) => (
+          <Box flexDirection="row" columnGap={1}>
+            {Array.from({ length: size }, (_, c) => (
+              <Box width={CELL_WIDTH} flexShrink={0} justifyContent="center">{face(r * size + c)}</Box>
+            ))}
+          </Box>
+        ))}
+      </Box>
+    )
 
     /**
-     * Draws what a cell shows: a number, a flag, a mine, or a button that reveals or flags it.
+     * Draws whack-a-mole: lives, score and high score, and the holes, each a button while a round is on.
      *
-     * @param cell - Cell number to draw.
-     * @returns The cell's content.
+     * @param round - Game to draw, see `Whack`.
+     * @returns The status line, the controls and the holes.
      */
-    const cellFace = (cell: number) => {
-      const isRevealed = board.revealed.includes(cell)
-      const isMine = board.mines.includes(cell)
-      if (isRevealed || (isOver && isMine)) {
-        if (isMine) return <Text color="#e06c6c">✹</Text>
-        const n = adjacentMines(board, cell)
-        return <Text color={NUMBER_COLORS[n]}>{n === 0 ? ' ' : String(n)}</Text>
+    const moleView = async (round: Whack) => {
+      const record = await read($, whackBest)
+      const isPlaying = round.status === 'playing'
+
+      const holeFace = (hole: number) => {
+        if (!isPlaying) return <Text dimColor>○</Text>
+        return (
+          <Button key={`hole:${hole}`} plain onPress={() => changeWhack($, current => whackHole(current, hole))}>
+            {hole === round.mole ? <Text>🐹</Text> : <Text color="#6b7280">○</Text>}
+          </Button>
+        )
       }
-      const label = board.flagged.includes(cell) ? '⚑' : '■'
-      if (isOver) return <Text dimColor>{label}</Text>
+
+      const hearts = '♥'.repeat(round.lives) + '♡'.repeat(LIVES - round.lives)
+      const recordText = record === null ? '' : ` · best ${record}`
+      const status = round.status === 'over'
+        ? <Text color="#e06c6c" bold>Game over. {round.score} whacked{recordText}</Text>
+        : round.status === 'ready'
+          ? <Text dimColor>Hit the mole before it hides{recordText}</Text>
+          : <Text><Text color="#e06c6c">{hearts}</Text><Text dimColor> · {round.score} whacked{recordText}</Text></Text>
+
       return (
-        <Button key={`cell:${cell}`} plain onPress={() => pressCell($, cell)}>
-          <Text color={label === '⚑' ? '#e0775a' : '#6b7280'}>{label}</Text>
-        </Button>
+        <Box flexDirection="column" gap={1}>
+          <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+            {status}
+            {isPlaying ? '' : <Button key="play" label={round.status === 'over' ? 'play again' : 'start'} variant="primary" onPress={() => changeWhack($, startWhack)} />}
+          </Box>
+          {grid(round.size, holeFace)}
+        </Box>
       )
     }
 
-    // Every cell sits in a box of one fixed width, so revealing a cell never moves the others: glyphs differ in width.
-    const cellView = (cell: number) => (
-      <Box width={CELL_WIDTH} flexShrink={0} justifyContent="center">{cellFace(cell)}</Box>
-    )
+    /**
+     * Draws the Minesweeper board: numbers, flags, mines, and buttons for hidden cells.
+     *
+     * @param board - Board to draw, see `Game`.
+     * @returns The status line, the controls and the board.
+     */
+    const minesView = async (board: Game) => {
+      const now = await $.clock.now()
+      const elapsed = board.status === 'ready' ? 0 : Math.round(((board.endedAt ?? now) - board.startedAt) / 1000)
+      const record = await read($, best)
+      const isOver = board.status === 'won' || board.status === 'lost'
 
-    const rows = Array.from({ length: board.size }, (_, r) => (
-      <Box flexDirection="row" columnGap={1}>
-        {Array.from({ length: board.size }, (_, c) => cellView(r * board.size + c))}
-      </Box>
-    ))
+      const cellFace = (cell: number) => {
+        const isRevealed = board.revealed.includes(cell)
+        const isMine = board.mines.includes(cell)
+        if (isRevealed || (isOver && isMine)) {
+          if (isMine) return <Text color="#e06c6c">✹</Text>
+          const n = adjacentMines(board, cell)
+          return <Text color={NUMBER_COLORS[n]}>{n === 0 ? ' ' : String(n)}</Text>
+        }
+        const label = board.flagged.includes(cell) ? '⚑' : '■'
+        if (isOver) return <Text dimColor>{label}</Text>
+        return (
+          <Button key={`cell:${cell}`} plain onPress={() => pressCell($, cell)}>
+            <Text color={label === '⚑' ? '#e0775a' : '#6b7280'}>{label}</Text>
+          </Button>
+        )
+      }
 
-    const status = board.status === 'won'
-      ? <Text color="#7cc47f" bold>Cleared in {elapsed}s</Text>
-      : board.status === 'lost'
-        ? <Text color="#e06c6c" bold>Boom. {board.revealed.length} cells cleared</Text>
-        : <Text dimColor>💣 {board.mineCount - board.flagged.length} · ⏱ {elapsed}s{record === null ? '' : ` · best ${record}s`}</Text>
+      const status = board.status === 'won'
+        ? <Text color="#7cc47f" bold>Cleared in {elapsed}s</Text>
+        : board.status === 'lost'
+          ? <Text color="#e06c6c" bold>Boom. {board.revealed.length} cells cleared</Text>
+          : <Text dimColor>💣 {board.mineCount - board.flagged.length} · ⏱ {elapsed}s{record === null ? '' : ` · best ${record}s`}</Text>
 
-    return (
-      <Box flexDirection="column" gap={1}>
-        <Box flexDirection="row" justifyContent="space-between" alignItems="center">
-          {status}
-          <Box flexDirection="row" columnGap={1}>
-            {isOver ? '' : <Button key="flag" label={board.isFlagMode ? '⚑ flagging' : '⚑ flag'} variant={board.isFlagMode ? 'primary' : 'secondary'} onPress={() => toggleFlagMode($)} />}
-            <Button key="new" label="new game" onPress={() => startGame($)} />
+      return (
+        <Box flexDirection="column" gap={1}>
+          <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+            {status}
+            <Box flexDirection="row" columnGap={1}>
+              {isOver ? '' : <Button key="flag" label={board.isFlagMode ? '⚑ flagging' : '⚑ flag'} variant={board.isFlagMode ? 'primary' : 'secondary'} onPress={() => toggleFlagMode($)} />}
+              <Button key="new" label="new game" onPress={() => startGame($)} />
+            </Box>
           </Box>
+          {grid(board.size, cellFace)}
         </Box>
-        <Box flexDirection="column">{rows}</Box>
+      )
+    }
+
+    const board = await read($, game)
+    const round = await read($, whack)
+    const body = current === 'mole'
+      ? await moleView(round ?? newWhack())
+      : (board === null ? <Button key="new" label="new game" variant="primary" onPress={() => startGame($)} /> : await minesView(board))
+
+    return (
+      <Box flexDirection="column" gap={1}>
+        {tabs}
+        {body}
       </Box>
     )
   })

package/mods/mini-game/types/index.d.ts

@@ -14,8 +14,25 @@ export type Game = {
   endedAt?: number
 }
 
+/** A whack-a-mole game; holes are numbered row by row from 0. */
+export type Whack = {
+  size: number
+  /** Hole the mole is up in; `null` before the start and after the end */
+  mole: number | null
+  /** Counts the moles put up, so a timer knows whether its mole is still the one up */
+  moleId: number
+  score: number
+  lives: number
+  /** How long the current mole stays up; shrinks with each hit */
+  windowMs: number
+  status: 'ready' | 'playing' | 'over'
+}
+
+/** The game the pane shows. */
+export type View = 'mines' | 'mole'
+
 declare module 'claude-code' {
   interface PluginState {
-    'mini-game': { game: Game | null; best: number | null }
+    'mini-game': { view: View; game: Game | null; best: number | null; whack: Whack | null; whackBest: number | null }
   }
 }