@g3nomaly/g3n-mods 0.1.5 → 0.1.7

package/mods/custom-crab-agents/view/view.ts

@@ -0,0 +1,154 @@
+// packages/g3n-mods/mods/custom-crab-agents/view/view.ts
+import { crabSvg } from '../hooks/sprite'
+import type { Pose } from '../hooks/sprite'
+import type { CrabView, CrabsViewData, PlannedView } from '../types'
+
+/** What the viewer hands a view: a way to send the mod an action and to open a link. */
+type ViewApi = { act: (name: string, arg?: unknown) => void; openLink: (href: string) => void }
+
+/** Makes an element with a class, and text when given. */
+function el<K extends keyof HTMLElementTagNameMap>(tag: K, className: string, text?: string): HTMLElementTagNameMap[K] {
+  const node = document.createElement(tag)
+  node.className = className
+  if (text !== undefined) node.textContent = text
+  return node
+}
+
+/** Sets an element's text only when it changed. */
+function setText(node: Element, text: string): void {
+  if (node.textContent !== text) node.textContent = text
+}
+
+/**
+ * Puts a crab's sprite in its slot, only when its look changed: the SVG animates itself, and replacing it would
+ * start its walk over.
+ */
+function setSprite(slot: HTMLElement, role: CrabView['role'], pose: Pose, phase: number): void {
+  const look = `${role}:${pose}:${phase}`
+  if (slot.dataset.look === look) return
+  slot.dataset.look = look
+  slot.innerHTML = crabSvg(role, pose, phase)
+}
+
+/** Moves `children` into `parent` in this order, touching only those out of place, and drops the rest. */
+function arrange(parent: HTMLElement, children: HTMLElement[]): void {
+  children.forEach((child, index) => {
+    if (parent.children[index] !== child) parent.insertBefore(child, parent.children[index] ?? null)
+  })
+  while (parent.children.length > children.length) parent.lastElementChild?.remove()
+}
+
+/**
+ * @brief Mounts the crabs: each subagent as a card with its animated crab, its role, model, steps and stats, and a
+ * bar. A card is one real button that opens the agent's chat. Running crabs come first, then the finished ones in a
+ * group that folds, then the planned ones in grey.
+ *
+ * @param root - The shadow root the viewer gives this view.
+ * @param api - Sends `openChat` to the mod.
+ * @returns The instance the viewer hands each update to.
+ */
+export function mount(root: ShadowRoot, api: ViewApi): { update: (data: unknown) => void } {
+  const frame = el('div', 'cr')
+  const head = el('header', 'cr-head')
+  const count = el('span', 'cr-count')
+  head.append(el('span', 'cr-title', 'Subagents'), count)
+  const running = el('div', 'cr-list')
+  const finished = el('details', 'cr-group')
+  finished.open = true
+  const finishedLabel = el('summary', 'cr-group-label')
+  const finishedList = el('div', 'cr-list')
+  finished.append(finishedLabel, finishedList)
+  const planned = el('section', 'cr-group cr-planned')
+  const plannedLabel = el('div', 'cr-group-label')
+  const plannedList = el('div', 'cr-list')
+  planned.append(plannedLabel, plannedList)
+  const empty = el('p', 'cr-empty', 'No subagents yet. Each one shows up here as a crab.')
+  frame.append(head, running, finished, planned, empty)
+  root.append(frame)
+
+  const cards = new Map<string, HTMLButtonElement>()
+  const plans = new Map<number, HTMLElement>()
+
+  /** Builds a crab's card once: a button holding the sprite and the text. */
+  const makeCard = (id: string): HTMLButtonElement => {
+    const card = el('button', 'cr-card')
+    card.type = 'button'
+    card.addEventListener('click', () => api.act('openChat', { id }))
+    const sprite = el('span', 'cr-sprite')
+    const body = el('span', 'cr-body')
+    const top = el('span', 'cr-top')
+    top.append(el('span', 'cr-name'), el('span', 'cr-mark'))
+    const meta = el('span', 'cr-meta')
+    meta.append(el('span', 'cr-role'), el('span', 'cr-model'))
+    const line = el('span', 'cr-line')
+    line.append(el('span', 'cr-step'), el('span', 'cr-stats'))
+    const bar = el('span', 'cr-bar')
+    bar.append(el('span', 'cr-fill'))
+    body.append(top, meta, line, bar)
+    card.append(sprite, body)
+    return card
+  }
+
+  /** Brings a crab's card up to date. */
+  const fill = (card: HTMLButtonElement, crab: CrabView): void => {
+    card.dataset.status = crab.status
+    card.title = `Open the conversation of ${crab.title}`
+    card.style.setProperty('--tier', crab.color)
+    setSprite(card.querySelector('.cr-sprite') as HTMLElement, crab.role, crab.status === 'running' ? 'running' : 'idle', crab.phase)
+    setText(card.querySelector('.cr-name') as HTMLElement, crab.title)
+    setText(card.querySelector('.cr-mark') as HTMLElement, crab.status === 'running' ? '' : crab.status === 'failed' ? '✗' : '✓')
+    setText(card.querySelector('.cr-role') as HTMLElement, crab.roleName)
+    setText(card.querySelector('.cr-model') as HTMLElement, `${crab.model}${crab.effort === undefined ? '' : ` · ${crab.effort}`}`)
+    setText(card.querySelector('.cr-step') as HTMLElement, crab.stepLine)
+    setText(card.querySelector('.cr-stats') as HTMLElement, crab.stats)
+    ;(card.querySelector('.cr-fill') as HTMLElement).style.width = `${(Math.max(0, Math.min(1, crab.share)) * 100).toFixed(1)}%`
+  }
+
+  /** Builds or updates a planned item's grey crab. */
+  const plannedCard = (item: PlannedView): HTMLElement => {
+    let card = plans.get(item.index)
+    if (card === undefined) {
+      card = el('div', 'cr-card is-planned')
+      const body = el('span', 'cr-body')
+      const top = el('span', 'cr-top')
+      top.append(el('span', 'cr-name'), el('span', 'cr-mark', '◷'))
+      body.append(top, el('span', 'cr-meta'))
+      card.append(el('span', 'cr-sprite'), body)
+      plans.set(item.index, card)
+    }
+    setSprite(card.querySelector('.cr-sprite') as HTMLElement, item.role, 'planned', 0)
+    setText(card.querySelector('.cr-name') as HTMLElement, `${item.index}. ${item.content}`)
+    setText(card.querySelector('.cr-meta') as HTMLElement, `planned${item.after.length > 0 ? ` · after ${item.after.join(', ')}` : ''}`)
+    return card
+  }
+
+  return {
+    update: (data: unknown) => {
+      const view = data as CrabsViewData | null
+      const crabs = view?.crabs ?? []
+      const plan = view?.planned ?? []
+      for (const [id, card] of cards) if (!crabs.some(crab => crab.id === id)) { card.remove(); cards.delete(id) }
+      const cardOf = (crab: CrabView): HTMLButtonElement => {
+        let card = cards.get(crab.id)
+        if (card === undefined) {
+          card = makeCard(crab.id)
+          cards.set(crab.id, card)
+        }
+        fill(card, crab)
+        return card
+      }
+      const live = crabs.filter(crab => crab.status === 'running').map(cardOf)
+      const done = crabs.filter(crab => crab.status !== 'running').reverse().map(cardOf)
+      arrange(running, live)
+      arrange(finishedList, done)
+      setText(finishedLabel, `Finished · ${done.length}`)
+      finished.hidden = done.length === 0
+      for (const index of [...plans.keys()]) if (!plan.some(item => item.index === index)) plans.delete(index)
+      arrange(plannedList, plan.map(plannedCard))
+      setText(plannedLabel, `Planned · ${plan.length}`)
+      planned.hidden = plan.length === 0
+      empty.hidden = crabs.length > 0 || plan.length > 0
+      setText(count, [live.length > 0 ? `${live.length} running` : '', done.length > 0 ? `${done.length} done` : ''].filter(Boolean).join(' · '))
+    },
+  }
+}

package/mods/delete-guard/hooks/register.tsx

@@ -33,9 +33,6 @@ const WARN_BG = '#3a2222'
 const WARN_EDGE = '#7a3b3b'
 const UNTRACKED_BG = '#6b3a22'
 
-/** Shell syntax that starts a new command: `&&`, `||`, `;`, `|`, a newline, `$(` and a backtick. */
-const SEGMENT_BREAK = /&&|\|\||;|\||\n|\$\(|`/
-
 /** Words that run the command after them: `sudo rm`, `xargs -0 rm`, `env X=1 rm`. */
 const PREFIX = /^(?:\w+=\S*\s+|(?:sudo|command|exec|nice|nohup|time|env)\s+(?:-\S+\s+)*|xargs\s+(?:-\S+\s+)*)+/
 
@@ -49,13 +46,51 @@ const TRASH_COMMANDS = [
 ] as const
 
 /**
- * Splits a shell command line into its commands, each trimmed.
+ * Splits a shell command line into its commands, each trimmed, as a shell reads it: at `&&`, `||`, `;`, `|`, a
+ * newline, a subshell and a command substitution. Quoted text is one word, not commands, and a heredoc body is data,
+ * so `python3 - <<EOF` with code that mentions a delete is not taken for one.
  *
  * @param command - Shell command line, e.g. `cd build && rm -rf dist`.
  * @returns The non-empty commands in order.
  */
 function segments(command: string): string[] {
-  return command.split(SEGMENT_BREAK).map(part => part.trim()).filter(part => part.length > 0)
+  const parts: string[] = []
+  let part = ''
+  let quote: "'" | '"' | undefined
+  // Command substitutions opened inside double quotes, innermost last: their `)` returns to the quoted text.
+  const resume: Array<'"'> = []
+  const heredocs: string[] = []
+  const lines = command.split('\n')
+  for (let l = 0; l < lines.length; l++) {
+    const line = lines[l] ?? ''
+    for (let i = 0; i < line.length; i++) {
+      const char = line.charAt(i)
+      const pair = line.slice(i, i + 2)
+      if (quote !== undefined) {
+        // Inside quotes nothing splits, except a command substitution, which runs, in double quotes.
+        if (char === quote) quote = undefined
+        else if (quote === '"' && pair === '$(') { parts.push(part); part = ''; resume.push('"'); quote = undefined; i += 1; continue }
+        else if (quote === '"' && char === '`') { parts.push(part); part = ''; continue }
+        part += char
+        continue
+      }
+      if (char === ')' && resume.length > 0) { parts.push(part); part = ''; quote = resume.pop(); continue }
+      if (char === "'" || char === '"') { quote = char; part += char; continue }
+      const heredoc = /^<<-?\s*(['"]?)([A-Za-z_][\w-]*)\1/.exec(line.slice(i))
+      if (heredoc !== null) { heredocs.push(heredoc[2] ?? ''); part += heredoc[0]; i += heredoc[0].length - 1; continue }
+      const breakLength = pair === '&&' || pair === '||' || pair === '$(' ? 2 : char === ';' || char === '|' || char === '`' || char === '(' || char === ')' ? 1 : 0
+      if (breakLength > 0) { parts.push(part); part = ''; i += breakLength - 1; continue }
+      part += char
+    }
+    // A heredoc's body is data handed to the command, not commands: skip its lines up to the closing word.
+    for (const word of heredocs.splice(0)) {
+      while (l + 1 < lines.length && (lines[l + 1] ?? '').trim() !== word) l++
+      l++
+    }
+    if (quote === undefined) { parts.push(part); part = '' } else part += '\n'
+  }
+  parts.push(part)
+  return parts.map(one => one.trim()).filter(one => one.length > 0)
 }
 
 /**
@@ -92,21 +127,49 @@ function operands(args: readonly string[]): string[] {
  * @returns The delete and what it removes, or `undefined` when nothing is deleted for good.
  */
 export function findDeletion(command: string): Deletion | undefined {
+  // A `cd` before the delete moves where it runs: `cd guard-demo && rm -rf build` deletes guard-demo/build.
+  let dir: string | undefined
+  const at = (found: Omit<Deletion, 'dir'>): Deletion => (dir === undefined ? found : { ...found, dir })
   for (const segment of segments(command)) {
     const [program = '', ...args] = words(segment)
+    if (program === 'cd') {
+      const target = unquote(args[0] ?? '~')
+      dir = dir === undefined || target.startsWith('/') || target.startsWith('~') ? target : `${dir}/${target}`
+      continue
+    }
     if (DELETERS.has(program)) {
-      return { segment, kind: 'files', paths: operands(args) }
+      return at({ segment, kind: 'files', paths: operands(args) })
     }
     if (program === 'find' && (args.includes('-delete') || /-exec(?:dir)?\s+(?:\S*\/)?rm\b/.test(segment))) {
-      return { segment, kind: 'find', paths: [] }
+      return at({ segment, kind: 'find', paths: [] })
     }
     if (program === 'git' && args[0] === 'clean' && args.some(arg => /^-\w*f/.test(arg) || arg === '--force')) {
-      return { segment, kind: 'git-clean', paths: [] }
+      return at({ segment, kind: 'git-clean', paths: [] })
     }
   }
   return undefined
 }
 
+/**
+ * Resolves a path as the shell would from `base`: `~` to the home directory, `.` and `..` folded.
+ *
+ * @param base - Absolute folder a relative path starts from.
+ * @param path - Path as the command spelled it, quotes removed.
+ * @param home - Home directory, for `~`.
+ * @returns The absolute path.
+ */
+export function resolvePath(base: string, path: string, home: string): string {
+  const expanded = path.replace(/^~(?=\/|$)/, home)
+  const joined = expanded.startsWith('/') ? expanded : `${base.replace(/\/$/, '')}/${expanded}`
+  const parts: string[] = []
+  for (const part of joined.split('/')) {
+    if (part === '' || part === '.') continue
+    if (part === '..') parts.pop()
+    else parts.push(part)
+  }
+  return `/${parts.join('/')}`
+}
+
 /**
  * Builds the command Claude should run instead of a permanent delete.
  *
@@ -178,11 +241,12 @@ function globRegExp(glob: string): RegExp {
  *
  * @param $ - Engine handle the hook received.
  * @param operand - Operand as the command spelled it.
+ * @param base - Absolute folder the delete runs in.
  * @param home - Home directory, for `~`.
  * @returns The paths, empty when a glob matches nothing.
  */
-async function expandOperand($: EngineInterface, operand: string, home: string): Promise<string[]> {
-  const path = unquote(operand).replace(/^~(?=\/|$)/, home)
+async function expandOperand($: EngineInterface, operand: string, base: string, home: string): Promise<string[]> {
+  const path = resolvePath(base, unquote(operand), home)
   if (!/[*?[]/.test(path)) return [path]
   const cut = path.lastIndexOf('/')
   const dir = cut === -1 ? '.' : path.slice(0, cut) || '/'
@@ -227,16 +291,16 @@ async function walk($: EngineInterface, path: string, found: { path: string; siz
  * @param deletion - A delete of kind `find` or `git-clean`.
  * @returns The paths, or `undefined` when the listing failed.
  */
-async function listedPaths($: EngineInterface, deletion: Deletion): Promise<string[] | undefined> {
+async function listedPaths($: EngineInterface, deletion: Deletion, base: string): Promise<string[] | undefined> {
   const argv = words(deletion.segment).map(unquote)
   if (deletion.kind === 'git-clean') {
     const flags = argv.slice(2)
       .filter(arg => arg !== '--force')
       .map(arg => (/^-[^-]/.test(arg) ? arg.replace(/f/g, '') : arg))
       .filter(arg => arg !== '-')
-    const ran = await $.process.run(['git', 'clean', '-n', ...flags], { timeoutMs: 10_000 }).catch(() => undefined)
+    const ran = await $.process.run(['git', 'clean', '-n', ...flags], { cwd: base, timeoutMs: 10_000 }).catch(() => undefined)
     if (ran?.exitCode !== 0) return undefined
-    return ran.stdout.split('\n').map(line => line.replace(/^Would remove /, '').trim()).filter(line => line !== '')
+    return ran.stdout.split('\n').map(line => line.replace(/^Would remove /, '').trim()).filter(line => line !== '').map(line => `${base}/${line}`)
   }
   const kept: string[] = []
   for (let i = 0; i < argv.length; i++) {
@@ -248,9 +312,9 @@ async function listedPaths($: EngineInterface, deletion: Deletion): Promise<stri
     }
     kept.push(arg)
   }
-  const ran = await $.process.run([...kept, '-print'], { timeoutMs: 10_000 }).catch(() => undefined)
+  const ran = await $.process.run([...kept, '-print'], { cwd: base, timeoutMs: 10_000 }).catch(() => undefined)
   if (ran?.exitCode !== 0) return undefined
-  return ran.stdout.split('\n').filter(line => line !== '')
+  return ran.stdout.split('\n').filter(line => line !== '').map(line => (line.startsWith('/') ? line : `${base}/${line}`))
 }
 
 /**
@@ -260,8 +324,8 @@ async function listedPaths($: EngineInterface, deletion: Deletion): Promise<stri
  * @param paths - Roots of the delete, relative to the session's directory or absolute.
  * @returns Tracked paths relative to the session's directory; empty outside a repository.
  */
-async function trackedFiles($: EngineInterface, paths: readonly string[]): Promise<Set<string>> {
-  const ran = await $.process.run(['git', 'ls-files', '-z', '--', ...paths], { timeoutMs: 10_000 }).catch(() => undefined)
+async function trackedFiles($: EngineInterface, paths: readonly string[], base: string): Promise<Set<string>> {
+  const ran = await $.process.run(['git', 'ls-files', '-z', '--', ...paths], { cwd: base, timeoutMs: 10_000 }).catch(() => undefined)
   if (ran?.exitCode !== 0) return new Set()
   return new Set(ran.stdout.split('\0').filter(path => path !== ''))
 }
@@ -271,14 +335,14 @@ async function trackedFiles($: EngineInterface, paths: readonly string[]): Promi
  *
  * @param $ - Engine handle the hook received.
  * @param deletion - Delete to measure, see `findDeletion`.
- * @param cwd - Session's directory, absolute.
+ * @param base - Absolute folder the delete runs in, after any `cd` before it.
  * @param home - Home directory, for `~`.
  * @returns The files largest first, with their total; `isKnown` false when they could not be listed.
  */
-async function measure($: EngineInterface, deletion: Deletion, cwd: string, home: string): Promise<BlastRadius> {
+async function measure($: EngineInterface, deletion: Deletion, base: string, home: string): Promise<BlastRadius> {
   const roots = deletion.kind === 'files'
-    ? (await Promise.all(deletion.paths.map(operand => expandOperand($, operand, home)))).flat()
-    : await listedPaths($, deletion)
+    ? (await Promise.all(deletion.paths.map(operand => expandOperand($, operand, base, home)))).flat()
+    : await listedPaths($, deletion, base)
   if (roots === undefined) return { files: [], total: 0, isCut: false, isKnown: false }
 
   const found: { path: string; size: number }[] = []
@@ -289,10 +353,10 @@ async function measure($: EngineInterface, deletion: Deletion, cwd: string, home
       break
     }
   }
-  const tracked = deletion.kind === 'git-clean' || roots.length === 0 ? new Set<string>() : await trackedFiles($, roots)
+  const tracked = deletion.kind === 'git-clean' || roots.length === 0 ? new Set<string>() : await trackedFiles($, roots, base)
   const files: DoomedFile[] = found
     .map(file => {
-      const path = relativeTo(cwd, file.path)
+      const path = relativeTo(base, file.path)
       return { path, size: file.size, isTracked: tracked.has(path) }
     })
     .sort((a, b) => b.size - a.size)
@@ -320,6 +384,7 @@ function fileCount(count: number, isCut = false): string {
  */
 function restoreNote(radius: BlastRadius): string {
   if (!radius.isKnown) return "Couldn't list what this deletes, so its size is unknown."
+  if (radius.files.length === 0) return "Couldn't find what this names here, so it may delete nothing, or something the guard can't see."
   const tracked = radius.files.filter(file => file.isTracked).length
   if (tracked === 0) return "None of these are tracked by git, so they can't be restored."
   if (tracked === radius.files.length) return 'All of these are tracked by git: their committed versions can be restored, uncommitted changes cannot.'
@@ -415,7 +480,6 @@ async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: Abor
     settle(answer)
     void showSwitch($)
   }
-  const timer = $.clock.after(HOLD_MS, () => drop('timeout'))
   const onAbort = (): void => drop('cancel')
   signal?.addEventListener('abort', onAbort, { once: true })
 
@@ -423,8 +487,19 @@ async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: Abor
   if (held.length === 1) await $.ui.open({ id: PANE, title: HOLD_TITLE, focus: true })
   $.ui.invalidate('ui.render')
 
-  const answer = await answered
-  timer.cancel()
+  // The wait runs on a child process that sleeps out the hold. A hook has ten seconds of its own time; waiting on the
+  // engine does not count against it, but waiting on a promise of the module's own (or on $.clock.sleep) does, so a
+  // plain await of the answer would fail the hook after ten seconds. Closing the stream kills the child.
+  const sleeper = $.process.spawn({ argv: ['sleep', String(Math.ceil(HOLD_MS / 1000))] })
+  const slept = (async (): Promise<'timeout'> => {
+    try {
+      while (!(await sleeper.next()).done) { /* sleep prints nothing */ }
+    } catch { /* closed early, or could not start */ }
+    return 'timeout'
+  })()
+  const answer = await Promise.race([answered, slept])
+  if (answer === 'timeout') drop('timeout')
+  void sleeper.return(undefined as never).catch(() => undefined)
   signal?.removeEventListener('abort', onAbort)
   return answer
 }
@@ -461,7 +536,8 @@ export const register: Register = on => {
   })
 
   on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
-    if (!(await read($, isOn))) return next(e)
+    // The saved switch, not this session's copy, so a switch flipped in any session holds here at once.
+    if ((await $.store.get(STORE_KEY).catch(() => undefined)) !== true) return next(e)
     const deletion = findDeletion(e.command)
     if (deletion === undefined) return next(e)
 
@@ -474,18 +550,22 @@ export const register: Register = on => {
       return { deny: `delete-guard: \`${deletion.segment}\` deletes permanently. Move it to the trash instead: ${instead}.` }
     }
 
+    // Where the delete runs: the session's folder, moved by any `cd` the command makes first. When nothing it names is
+    // found there the card still asks, since the guard may be looking in the wrong place.
     const cwd = await $.session.cwd()
-    const radius = await measure($, deletion, cwd, home)
-    if (radius.isKnown && radius.files.length === 0) return next(e)
+    const base = deletion.dir === undefined ? cwd : resolvePath(cwd, deletion.dir, home)
+    const radius = await measure($, deletion, base, home)
 
-    const folder = cwd.split('/').filter(Boolean).pop() ?? cwd
+    const folder = base.split('/').filter(Boolean).pop() ?? base
     const answer = await hold($, { segment: deletion.segment, folder, radius }, next.signal)
     if (answer === 'delete') return next(e)
     if (answer === 'timeout') {
       return { deny: `delete-guard: no one answered the delete card within ${HOLD_MS / 60_000} minutes, so \`${deletion.segment}\` did not run. Ask the user before trying again.` }
     }
     return { deny: `delete-guard: the user cancelled \`${deletion.segment}\`. Do not delete these files without asking; to remove them, move them to the trash: ${instead}.` }
-  }).catch(($, e, next) => (next.called ? next(e) : { deny: 'delete-guard: the guard failed, so the command was not run.' }))
+  }).catch(($, e, next) => (next.called
+    ? next(e)
+    : { deny: `delete-guard: the guard failed (${next.error.kind}${next.error.message === undefined ? '' : `: ${next.error.message}`}), so the command was not run.` }))
 
   on('ui.close', async ($, e, next) => {
     // Closing the card by hand answers every delete it holds with Cancel.
@@ -500,7 +580,9 @@ export const register: Register = on => {
     const { Box, Text, Button } = $.ui.resolve(e)
     const card = held[0]
     if (card === undefined) {
-      const isGuarding = await read($, isOn)
+      // The saved switch, which any session may have flipped; this session's copy until one is saved.
+      const stored = await $.store.get(STORE_KEY).catch(() => undefined)
+      const isGuarding = stored === undefined ? await read($, isOn) : stored === true
       return (
         <Box flexDirection="row" columnGap={2} alignItems="center">
           <Button key="switch" label={isGuarding ? '● on' : '○ off'} variant={isGuarding ? 'primary' : 'secondary'} onPress={() => setGuard($, !isGuarding)} />
@@ -575,7 +657,7 @@ export const register: Register = on => {
           </Box>
         )}
         <Box flexDirection="row" columnGap={2} alignItems="center" marginTop={1}>
-          <Button key="delete" variant="primary" label={`Delete ${fileCount(radius.files.length, radius.isCut)}`} onPress={() => answerFirst($, 'delete')} />
+          <Button key="delete" variant="primary" label={radius.files.length === 0 ? 'Run it' : `Delete ${fileCount(radius.files.length, radius.isCut)}`} onPress={() => answerFirst($, 'delete')} />
           <Button key="cancel" label="Cancel" onPress={() => answerFirst($, 'cancel')} />
           <Text dimColor>Held by delete-guard</Text>
         </Box>

package/mods/delete-guard/types/index.d.ts

@@ -5,6 +5,8 @@ export type Deletion = {
   segment: string
   kind: 'files' | 'find' | 'git-clean'
   paths: string[]
+  /** Where the delete runs when the command changes directory before it, as its `cd`s spell it, e.g. `guard-demo` */
+  dir?: string
 }
 
 /** One file a delete would remove: its path relative to the session's directory, its bytes, and whether git tracks it. */

package/mods/mini-game/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mini-game",
   "version": "0.1.0",
-  "description": "Minesweeper to play while Claude works.",
+  "description": "Minesweeper and whack-a-mole to play while Claude works.",
   "author": {
     "name": "g3ntrovert"
   },

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

@@ -0,0 +1,27 @@
+// packages/g3n-mods/mods/mini-game/hooks/bubbles.ts
+import type { Sheet } from '../types'
+
+const SIZE = 8
+
+/**
+ * Creates a sheet with every bubble whole.
+ *
+ * @param cleared - Sheets popped clean before this one.
+ * @returns The new sheet, see `Sheet`.
+ */
+export function newSheet(cleared: number): Sheet {
+  return { size: SIZE, popped: [], cleared }
+}
+
+/**
+ * Pops one bubble; popping the last one swaps in a fresh sheet.
+ *
+ * @param sheet - Sheet to pop on, see `Sheet`.
+ * @param bubble - Bubble number, counted row by row from `0`.
+ * @returns The sheet after the pop, or the same sheet when the bubble was already popped.
+ */
+export function pop(sheet: Sheet, bubble: number): Sheet {
+  if (sheet.popped.includes(bubble)) return sheet
+  const popped = [...sheet.popped, bubble]
+  return popped.length === sheet.size * sheet.size ? newSheet(sheet.cleared + 1) : { ...sheet, popped }
+}

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

@@ -0,0 +1,108 @@
+// packages/g3n-mods/mods/mini-game/hooks/minesweeper.ts
+import type { Game } from '../types'
+
+const SIZE = 9
+const MINES = 10
+
+/**
+ * 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`.
+ */
+export 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.
+ *
+ * @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.
+ */
+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 }
+}
+
+/**
+ * Flags or unflags a hidden cell while the game is on.
+ *
+ * @param board - Board to flag on, see `Game`.
+ * @param cell - Cell number to flag.
+ * @returns The board after the flag, or the same board when the cell cannot be flagged.
+ */
+export function toggleFlag(board: Game, cell: number): Game {
+  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 }
+}
+
+/**
+ * Creates a board in the `ready` state, with no mines placed yet.
+ *
+ * @param now - Milliseconds since the epoch, stamped as the start time.
+ * @returns The new board, see `Game`.
+ */
+export function newGame(now: number): Game {
+  return { size: SIZE, mineCount: MINES, mines: [], revealed: [], flagged: [], status: 'ready', isFlagMode: false, startedAt: now }
+}