@g3nomaly/g3n-mods 0.1.3 → 0.1.4

package/.claude-plugin/marketplace.json

@@ -19,19 +19,19 @@
     {
       "name": "custom-crab-agents",
       "source": "./mods/custom-crab-agents",
-      "description": "Each subagent as a crab with a hat: effort tier, model, steps, context, tokens, cost and time.",
+      "description": "Draws each subagent in the agents panel as a crab with a hat: effort tier, model, steps, context, tokens, cost and time.",
       "version": "0.1.0"
     },
     {
       "name": "delete-guard",
       "source": "./mods/delete-guard",
-      "description": "Denies rm -rf and other permanent deletes and points Claude to the trash.",
+      "description": "Holds rm -rf and other permanent deletes on a card that lists what they remove, until you press Delete or Cancel.",
       "version": "0.1.0"
     },
     {
       "name": "focus-mode",
       "source": "./mods/focus-mode",
-      "description": "A timed focus block with a countdown, a progress bar and an end button.",
+      "description": "A timed focus block in which you're away: Claude asks no questions and gets no permission prompts. Countdown, progress bar and end button.",
       "version": "0.1.0"
     },
     {

package/README.md

@@ -22,16 +22,16 @@ Then open the project in VS Code and trust the workspace. New sessions load the
 |---|---|---|
 | `agents-panel` | The agents in `.claude/agents` with their model and a run button. A running agent shows a spinner, and a toast says when it starts and finishes | `/agents-panel` |
 | `context-bar` | One bar of context-window use split by source, with the total and where compaction starts | `/context-bar` |
-| `custom-crab-agents` | Each subagent as a crab with a hat: effort tier, model, steps, context, tokens, cost and time | `/crabs` |
-| `delete-guard` | Denies `rm -rf` and other permanent deletes and tells Claude which trash command to use instead | `/delete-guard on \| off` |
-| `focus-mode` | A timed focus block with a countdown, a progress bar and an end button. 25 minutes unless you pass a number | `/focus-mode [minutes] \| end` |
+| `custom-crab-agents` | Adds each subagent to the agents panel as a crab with a hat: effort tier, model, steps, context, tokens, cost and time. Needs `agents-panel`, which installing it adds | `/agents-panel` |
+| `delete-guard` | Off by default: deletes run unasked. Turn it on with the switch in its pane, or `/delete-guard on`; it stays on in later sessions. While on, `rm -rf` and other permanent deletes wait on a card listing the files, their sizes and whether git can restore them, until you press **Delete** or **Cancel**. Cancel tells Claude which trash command to use instead. With nothing to draw the card on, the delete is refused | `/delete-guard on \| off` |
+| `focus-mode` | A timed focus block in which you're away: Claude's questions are refused, so it picks for itself and says what it assumed, and permission prompts are refused, so it works around the step and lists it for later. Countdown, progress bar and end button. 25 minutes unless you pass a number | `/focus-mode [minutes] \| end` |
 | `handoff` | Writes a handoff with the `handoff` skill, clears the session, and attaches the handoff to your next prompt | `/handoff-new [what the next session is for]` |
 | `hide-personal-data` | Masks names, emails, phone numbers, IBANs and card numbers in replies. Hover a mask to read it | `/hide-personal-data on \| off` |
 | `mini-game` | Minesweeper, to play while Claude works | `/mini-game` |
 | `tool-timeline` | Each tool call with its duration. A denied call is struck through, next to the call that replaced it | `/tool-timeline` |
 | `you-should-know` | A card under long replies with their key point, a headline and one supporting line. It costs one small Haiku call per reply of 1500 characters or more | none |
 
-For `agents-panel`, `context-bar`, `custom-crab-agents` and `tool-timeline`, the command opens the pane and running it again closes it.
+For `agents-panel`, `context-bar` and `tool-timeline`, the command opens the pane and running it again closes it.
 
 Three mods take settings, declared under `userConfig` in their `.claude-plugin/plugin.json`:
 

package/mods/agents-panel/hooks/register.tsx

@@ -1,6 +1,6 @@
 // packages/g3n-mods/mods/agents-panel/hooks/register.tsx
 import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register } from 'claude-code'
+import type { EngineInterface, Register, RenderElement } from 'claude-code'
 
 import type { AgentDef, RunningAgent } from '../types'
 
@@ -20,6 +20,27 @@ const NAMED_COLORS: Readonly<Record<string, string>> = {
 const SPINNER = ['◐', '◓', '◑', '◒']
 const DONE_STATUSES = new Set(['completed', 'failed', 'killed', 'idle'])
 
+/** Key prefix of the panel's own elements; an add-on looks for it to find the panel's tree. */
+export const OWN_KEY = 'agents:'
+
+/** Key prefix an add-on's section carries, such as custom-crab-agents' crabs, so the panel knows to show it. */
+export const ADDON_KEY = 'addon:'
+
+/**
+ * Tells whether a drawn tree holds an element whose key starts with `prefix`.
+ *
+ * @param tree - Tree as a `ui.render` chain returned it, or one of its children.
+ * @param prefix - Key prefix to look for, e.g. `addon:`.
+ * @returns True when some element's key starts with `prefix`.
+ */
+export function holdsKey(tree: unknown, prefix: string): boolean {
+  if (Array.isArray(tree)) return tree.some(child => holdsKey(child, prefix))
+  if (typeof tree !== 'object' || tree === null) return false
+  const { props, children } = tree as { props?: { key?: unknown }; children?: unknown }
+  if (typeof props?.key === 'string' && props.key.startsWith(prefix)) return true
+  return holdsKey(children, prefix)
+}
+
 /**
  * Parses the frontmatter of a Markdown file into flat `key: value` pairs.
  *
@@ -184,8 +205,13 @@ export const register: Register = on => {
     return result
   }).catch(($, e, next) => next(e))
 
-  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e, next) => {
     const { Box, Text, Button } = $.ui.resolve(e)
+    // An add-on that depends on this panel, such as custom-crab-agents, may draw beneath this hook; its section joins the panel.
+    const below: RenderElement | undefined = await next(e).catch(() => undefined)
+    const addOn = below !== undefined && holdsKey(below, ADDON_KEY) ? below : undefined
+    /** Puts an add-on's section under the panel's own tree, when one was drawn beneath. */
+    const withAddOn = (own: RenderElement) => (addOn === undefined ? own : <Box flexDirection="column" gap={1}>{own}{addOn}</Box>)
     const list = await read($, agents)
     const runs = await read($, running)
     const now = await $.clock.now()
@@ -203,11 +229,11 @@ export const register: Register = on => {
     )
 
     if (list.length === 0) {
-      return (
-        <Box flexDirection="column" gap={1}>
+      return withAddOn(
+        <Box key={`${OWN_KEY}body`} flexDirection="column" gap={1}>
           {header}
           <Text dimColor>No agents in {AGENTS_DIR} or ~/{AGENTS_DIR}. Add one with /agents.</Text>
-        </Box>
+        </Box>,
       )
     }
 
@@ -265,14 +291,14 @@ export const register: Register = on => {
           )
         })()
 
-    return (
-      <Box flexDirection="column" gap={1}>
+    return withAddOn(
+      <Box key={`${OWN_KEY}body`} flexDirection="column" gap={1}>
         {header}
         {input}
         {section('project')}
         {section('user')}
         <Text dimColor>click ▶ run to start one · /agents-panel to hide</Text>
-      </Box>
+      </Box>,
     )
   })
 }

package/mods/custom-crab-agents/.claude-plugin/plugin.json

@@ -1,9 +1,12 @@
 {
   "name": "custom-crab-agents",
   "version": "0.1.0",
-  "description": "Each subagent as a crab with a hat: effort tier, model, steps, context, tokens, cost and time.",
+  "description": "Draws each subagent in the agents panel as a crab with a hat: effort tier, model, steps, context, tokens, cost and time.",
   "author": {
     "name": "g3ntrovert"
   },
-  "types": "./types/index.d.ts"
+  "types": "./types/index.d.ts",
+  "dependencies": [
+    "agents-panel"
+  ]
 }

package/mods/custom-crab-agents/hooks/register.tsx

@@ -1,11 +1,15 @@
 // packages/g3n-mods/mods/custom-crab-agents/hooks/register.tsx
 import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register } from 'claude-code'
+import type { EngineInterface, Register, RenderElement } from 'claude-code'
 
 import type { Crab, CrabSteps, PlannedItem } from '../types'
 
-const PANE = 'crabs'
-const TITLE = 'Crabs'
+/** The agents-panel mod's pane, which this mod depends on and draws its crabs into. */
+const PANEL = 'agents-panel'
+
+/** Key prefix of the agents panel's own elements, and the one this section carries so the panel shows it. */
+const PANEL_KEY = 'agents:'
+const ADDON_KEY = 'addon:'
 const crabs = atom({ plugin: 'custom-crab-agents', key: 'crabs' } as const, [])
 const planned = atom({ plugin: 'custom-crab-agents', key: 'planned' } as const, [])
 const contextWindow = atom({ plugin: 'custom-crab-agents', key: 'window' } as const, 1_000_000)
@@ -178,6 +182,21 @@ const isNumber = (v: unknown): v is number => typeof v === 'number'
 /** Tells whether `v` is a non-null object. */
 const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null
 
+/**
+ * Tells whether a drawn tree holds an element whose key starts with `prefix`.
+ *
+ * @param tree - Tree as a `ui.render` chain returned it, or one of its children.
+ * @param prefix - Key prefix to look for, e.g. `agents:`.
+ * @returns True when some element's key starts with `prefix`.
+ */
+export function holdsKey(tree: unknown, prefix: string): boolean {
+  if (Array.isArray(tree)) return tree.some(child => holdsKey(child, prefix))
+  if (typeof tree !== 'object' || tree === null) return false
+  const { props, children } = tree as { props?: { key?: unknown }; children?: unknown }
+  if (typeof props?.key === 'string' && props.key.startsWith(prefix)) return true
+  return holdsKey(children, prefix)
+}
+
 /**
  * Applies `patch` to every crab that `match` selects.
  *
@@ -190,14 +209,13 @@ async function patchCrab($: EngineInterface, match: (crab: Crab) => boolean, pat
 }
 
 /**
- * Records a subagent the main thread just started and shows the pane.
+ * Records a subagent the main thread just started.
  *
  * @param $ - Engine handle the hook received, see `EngineInterface`.
  * @param crab - New running crab to add, see `Crab`.
  */
 async function startCrab($: EngineInterface, crab: Crab): Promise<void> {
   await update($, crabs, list => [...list.filter(one => one.id !== crab.id), crab].slice(-KEEP))
-  void $.ui.open({ id: PANE, title: TITLE })
 }
 
 /**
@@ -332,28 +350,17 @@ async function readWindow($: EngineInterface): Promise<void> {
 }
 
 /**
- * Registers this mod's `crabs` command, its session, tool, subagent and turn hooks, and its pane.
+ * Registers this mod's session, tool, subagent and turn hooks, and its section of the agents panel.
  *
  * @param on - Hook registration function the engine passes in.
  */
 export const register: Register = on => {
   on('session.start', async ($, e, next) => {
-    await $.command.register({ name: 'crabs', description: 'Show or hide the subagent crabs' })
     await readWindow($)
-    void $.ui.open({ id: PANE, title: TITLE })
     $.clock.every(1000, () => void tick($))
     return next(e)
   })
 
-  on('command.run', { command: 'crabs' }, async $ => {
-    if ((await $.ui.panes()).some(pane => pane.id === PANE)) {
-      await $.ui.close({ id: PANE })
-      return { text: 'Crabs hidden.' }
-    }
-    await $.ui.open({ id: PANE, title: TITLE })
-    return { text: 'Crabs shown.' }
-  })
-
   on('tool.call', { tool: 'Agent' }, async ($, e, next) => {
     if (e.agentId !== undefined) return next(e)
     const startedAt = await $.clock.now()
@@ -399,13 +406,22 @@ export const register: Register = on => {
     return result
   }).catch(($, e, next) => next(e))
 
-  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+  // Draws into the agents panel: under the panel's tree when the panel's hook lies beneath this one, or alone with an
+  // `addon:` key that the panel's hook picks up when it lies above. Either way the crabs end up under the agents.
+  on('ui.render', { component: 'Pane', requestId: PANEL }, async ($, e, next) => {
     const { Box, Text } = $.ui.resolve(e)
+    const below: RenderElement | undefined = await next(e).catch(() => undefined)
+    const panel = below !== undefined && holdsKey(below, PANEL_KEY) ? below : undefined
+    /** Puts the crabs' section under the panel's tree, when it was drawn beneath. */
+    const joined = (section: RenderElement) => (panel === undefined ? section : <Box flexDirection="column" gap={1}>{panel}{section}</Box>)
+
     const list = await read($, crabs)
     const plan = await read($, planned)
     const window = await read($, contextWindow)
     const now = await $.clock.now()
-    if (list.length === 0 && plan.length === 0) return <Text dimColor>No subagents yet. Each one shows up here as a crab.</Text>
+    if (list.length === 0 && plan.length === 0) {
+      return joined(<Box key={`${ADDON_KEY}crabs`}><Text dimColor>No subagents yet. Each one shows up here as a crab.</Text></Box>)
+    }
 
     const barWidth = Math.max(120, (e.props.bodyColumns - 10) * 7)
     /**
@@ -485,8 +501,9 @@ export const register: Register = on => {
     const running = list.filter(crab => crab.status === 'running')
     const done = list.filter(crab => crab.status !== 'running')
 
-    return (
-      <Box flexDirection="column">
+    return joined(
+      <Box key={`${ADDON_KEY}crabs`} flexDirection="column">
+        <Text bold>Subagents</Text>
         {running.map(card)}
         {done.length > 0 && <Text dimColor>▾ Finished · {done.length}</Text>}
         {done.slice().reverse().map(card)}
@@ -503,7 +520,7 @@ export const register: Register = on => {
             </Box>
           </Box>
         ))}
-      </Box>
+      </Box>,
     )
   })
 }

package/mods/delete-guard/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "delete-guard",
   "version": "0.1.0",
-  "description": "Denies rm -rf and other permanent deletes and points Claude to the trash.",
+  "description": "Holds rm -rf and other permanent deletes on a card that lists what they remove, until you press Delete or Cancel.",
   "author": {
     "name": "g3ntrovert"
   },

package/mods/delete-guard/hooks/hooks.json

@@ -1 +1 @@
-{ "modules": ["./register.ts"] }
+{ "modules": ["./register.tsx"] }

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

@@ -0,0 +1,585 @@
+// packages/g3n-mods/mods/delete-guard/hooks/register.tsx
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { Answer, BlastRadius, Deletion, DoomedFile } from '../types'
+
+const isOn = atom({ plugin: 'delete-guard', key: 'isOn' } as const, false)
+
+const PANE = 'delete-guard'
+const TITLE = 'Delete guard'
+const HOLD_TITLE = 'Delete?'
+
+/** Key in the plugin's store that remembers the switch between sessions. */
+const STORE_KEY = 'isOn'
+
+/** How long a delete waits on the card before it is refused unanswered. */
+const HOLD_MS = 5 * 60_000
+
+/** Most files one delete's walk counts before it stops. */
+const MAX_FILES = 5000
+
+/** File rows the card shows before its "Show more" button. */
+const SHOWN_FILES = 8
+
+/** Approximate pixel width of one cell of the editor's code font. */
+const CELL_PX = 7
+
+const RED = '#e06c6c'
+const ORANGE = '#e0775a'
+const TRACK = '#2b3240'
+const CHIP = '#4a2626'
+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+)*)+/
+
+const DELETERS = new Set(['rm', 'shred', 'unlink', 'rimraf', 'srm'])
+
+/** Trash commands in order of preference, with how each one is spelled. */
+const TRASH_COMMANDS = [
+  { probe: 'trash', spell: 'trash' },
+  { probe: 'trash-put', spell: 'trash-put' },
+  { probe: 'gio', spell: 'gio trash' },
+] as const
+
+/**
+ * Splits a shell command line into its commands, each trimmed.
+ *
+ * @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)
+}
+
+/**
+ * Splits one command into words, dropping its prefixes and the program's directory.
+ *
+ * @param segment - One command, as `segments` returns it.
+ * @returns The program name first, then its arguments.
+ */
+function words(segment: string): string[] {
+  const [program = '', ...rest] = segment.replace(PREFIX, '').split(/\s+/)
+  return [program.split('/').pop() ?? program, ...rest]
+}
+
+/**
+ * Picks the operands of a command: every word that is not a flag, and every word after `--`.
+ *
+ * @param args - Words after the program name.
+ * @returns The operands in order.
+ */
+function operands(args: readonly string[]): string[] {
+  const end = args.indexOf('--')
+  const flagged = end === -1 ? args : args.slice(0, end)
+  const after = end === -1 ? [] : args.slice(end + 1)
+  return [...flagged.filter(arg => !arg.startsWith('-')), ...after]
+}
+
+/**
+ * @brief Finds the first permanent delete in a shell command line.
+ *
+ * Recognises `rm`, `shred`, `unlink`, `rimraf`, `find -delete`, `find -exec rm`
+ * and a forced `git clean`.
+ *
+ * @param command - Full shell command line, as the Bash tool received it.
+ * @returns The delete and what it removes, or `undefined` when nothing is deleted for good.
+ */
+export function findDeletion(command: string): Deletion | undefined {
+  for (const segment of segments(command)) {
+    const [program = '', ...args] = words(segment)
+    if (DELETERS.has(program)) {
+      return { 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: [] }
+    }
+    if (program === 'git' && args[0] === 'clean' && args.some(arg => /^-\w*f/.test(arg) || arg === '--force')) {
+      return { segment, kind: 'git-clean', paths: [] }
+    }
+  }
+  return undefined
+}
+
+/**
+ * Builds the command Claude should run instead of a permanent delete.
+ *
+ * @param deletion - Delete to replace, see `Deletion`.
+ * @param trash - Trash command spelled as this machine has it, e.g. `gio trash`.
+ * @returns The suggested command, with `<paths>` where no path was named.
+ */
+function insteadOf(deletion: Deletion, trash: string): string {
+  switch (deletion.kind) {
+    case 'files':
+      return deletion.paths.length > 0 ? `${trash} ${deletion.paths.join(' ')}` : `${trash} <paths>`
+    case 'find':
+      return `${deletion.segment.replace(/\s-delete\b/, '').replace(/-exec(?:dir)?\s+.*$/, '')} -exec ${trash} {} +`.replace(/\s+/g, ' ')
+    case 'git-clean':
+      return `git clean -n to list the files, then ${trash} <paths>`
+  }
+}
+
+/**
+ * Finds the first trash command on this machine's PATH.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @returns The command as it should be spelled, or `undefined` when none is installed.
+ */
+async function detectTrash($: EngineInterface): Promise<string | undefined> {
+  for (const candidate of TRASH_COMMANDS) {
+    const found = await $.process.run(['sh', '-c', `command -v ${candidate.probe}`]).catch(() => undefined)
+    if (found?.exitCode === 0) return candidate.spell
+  }
+  return undefined
+}
+
+/**
+ * Strips one pair of matching quotes around a shell word.
+ *
+ * @param word - Word as the command spelled it, e.g. `"build dir"`.
+ * @returns The word without its quotes.
+ */
+function unquote(word: string): string {
+  return /^(['"]).*\1$/.test(word) ? word.slice(1, -1) : word
+}
+
+/**
+ * Writes a path relative to the session's directory when it lies inside it.
+ *
+ * @param cwd - Session's directory, absolute.
+ * @param path - Path to shorten, absolute or relative.
+ * @returns The path without `./` and without the `cwd` prefix.
+ */
+function relativeTo(cwd: string, path: string): string {
+  const prefix = cwd.endsWith('/') ? cwd : `${cwd}/`
+  const inside = path.startsWith(prefix) ? path.slice(prefix.length) : path
+  return inside.replace(/^(\.\/)+/, '')
+}
+
+/**
+ * Turns a shell glob's last segment into a regular expression: `*`, `?` and `[...]`.
+ *
+ * @param glob - One path segment, e.g. `*.log`.
+ * @returns The matching expression, anchored at both ends.
+ */
+function globRegExp(glob: string): RegExp {
+  const body = glob.replace(/[.+^${}()|\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.')
+  return new RegExp(`^${body}$`)
+}
+
+/**
+ * Expands one operand of a delete into the paths it names: `~` to the home directory, and a glob in its last segment.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param operand - Operand as the command spelled it.
+ * @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)
+  if (!/[*?[]/.test(path)) return [path]
+  const cut = path.lastIndexOf('/')
+  const dir = cut === -1 ? '.' : path.slice(0, cut) || '/'
+  const pattern = globRegExp(path.slice(cut + 1))
+  const entries = await $.fs.list(dir).catch(() => [])
+  return entries
+    .filter(entry => pattern.test(entry.name) && !entry.name.startsWith('.'))
+    .map(entry => (cut === -1 ? entry.name : `${path.slice(0, cut)}/${entry.name}`))
+}
+
+/**
+ * Walks a path as a recursive delete would and adds every file under it; links count as files and are not followed.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param path - File or directory to walk.
+ * @param found - Files found so far, as path and size; added to.
+ * @returns False once `MAX_FILES` is reached, so the caller stops.
+ */
+async function walk($: EngineInterface, path: string, found: { path: string; size: number }[]): Promise<boolean> {
+  const stat = await $.fs.stat(path).catch(() => undefined)
+  if (stat === undefined) return true
+  if (stat.isLink || stat.kind !== 'dir') {
+    found.push({ path, size: stat.isLink ? 0 : stat.size })
+    return found.length < MAX_FILES
+  }
+  for (const entry of await $.fs.list(path).catch(() => [])) {
+    const child = `${path.replace(/\/$/, '')}/${entry.name}`
+    if (entry.kind === 'dir' && !entry.isLink) {
+      if (!(await walk($, child, found))) return false
+    } else {
+      found.push({ path: child, size: entry.size })
+      if (found.length >= MAX_FILES) return false
+    }
+  }
+  return true
+}
+
+/**
+ * Lists the paths a `find` delete or a forced `git clean` would remove, by running the same command without deleting.
+ *
+ * @param $ - Engine handle the hook received.
+ * @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> {
+  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)
+    if (ran?.exitCode !== 0) return undefined
+    return ran.stdout.split('\n').map(line => line.replace(/^Would remove /, '').trim()).filter(line => line !== '')
+  }
+  const kept: string[] = []
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i] ?? ''
+    if (arg === '-delete') continue
+    if (arg === '-exec' || arg === '-execdir') {
+      while (i < argv.length && !/^(\\?;|\+)$/.test(argv[i] ?? '')) i++
+      continue
+    }
+    kept.push(arg)
+  }
+  const ran = await $.process.run([...kept, '-print'], { timeoutMs: 10_000 }).catch(() => undefined)
+  if (ran?.exitCode !== 0) return undefined
+  return ran.stdout.split('\n').filter(line => line !== '')
+}
+
+/**
+ * Finds the files under `paths` that git tracks, which `git checkout` can bring back.
+ *
+ * @param $ - Engine handle the hook received.
+ * @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)
+  if (ran?.exitCode !== 0) return new Set()
+  return new Set(ran.stdout.split('\0').filter(path => path !== ''))
+}
+
+/**
+ * @brief Measures what a delete would remove: every file, its size, and whether git can restore it.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param deletion - Delete to measure, see `findDeletion`.
+ * @param cwd - Session's directory, absolute.
+ * @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> {
+  const roots = deletion.kind === 'files'
+    ? (await Promise.all(deletion.paths.map(operand => expandOperand($, operand, home)))).flat()
+    : await listedPaths($, deletion)
+  if (roots === undefined) return { files: [], total: 0, isCut: false, isKnown: false }
+
+  const found: { path: string; size: number }[] = []
+  let isCut = false
+  for (const root of roots) {
+    if (!(await walk($, root, found))) {
+      isCut = true
+      break
+    }
+  }
+  const tracked = deletion.kind === 'git-clean' || roots.length === 0 ? new Set<string>() : await trackedFiles($, roots)
+  const files: DoomedFile[] = found
+    .map(file => {
+      const path = relativeTo(cwd, file.path)
+      return { path, size: file.size, isTracked: tracked.has(path) }
+    })
+    .sort((a, b) => b.size - a.size)
+  return { files, total: files.reduce((sum, file) => sum + file.size, 0), isCut, isKnown: true }
+}
+
+/** Formats bytes as the card shows them: `B`, whole `KB`, or `MB` and `GB` with one decimal. */
+function bytes(size: number): string {
+  if (size < 1024) return `${size} B`
+  if (size < 1024 ** 2) return `${Math.round(size / 1024)} KB`
+  if (size < 1024 ** 3) return `${(size / 1024 ** 2).toFixed(1)} MB`
+  return `${(size / 1024 ** 3).toFixed(1)} GB`
+}
+
+/** Counts files as `1 file` or `N files`, with `N+` when the walk was cut. */
+function fileCount(count: number, isCut = false): string {
+  return `${count}${isCut ? '+' : ''} file${count === 1 && !isCut ? '' : 's'}`
+}
+
+/**
+ * Says whether git can bring the files back, the warning under the card's header.
+ *
+ * @param radius - What the delete removes.
+ * @returns One sentence about how many of the files git tracks.
+ */
+function restoreNote(radius: BlastRadius): string {
+  if (!radius.isKnown) return "Couldn't list what this deletes, so its size is unknown."
+  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.'
+  return `${tracked} of these are tracked by git and can be restored; the other ${radius.files.length - tracked} cannot.`
+}
+
+/** The folder a file sits in, as the card groups them: `.` for the session's directory. */
+function folderOf(path: string): string {
+  const cut = path.lastIndexOf('/')
+  return cut === -1 ? '.' : path.slice(0, cut)
+}
+
+/**
+ * Builds the SVG of a size bar: a track with a fill `share` of its width.
+ *
+ * @param width - Width of the track in pixels.
+ * @param share - Filled part, from 0 to 1.
+ * @param color - Fill color.
+ * @returns The SVG markup.
+ */
+function barSvg(width: number, share: number, color: string): string {
+  const fill = Math.max(3, share * width)
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="8" viewBox="0 0 ${width} 8"><rect width="${width}" height="8" rx="4" fill="${TRACK}"/><rect width="${fill.toFixed(1)}" height="8" rx="4" fill="${color}"/></svg>`
+}
+
+/** A delete held for the person's answer: what it runs, what it removes, and how to settle it. */
+type Held = {
+  segment: string
+  folder: string
+  radius: BlastRadius
+  settle: (answer: Answer | 'timeout') => void
+}
+
+/** Deletes waiting on the card, oldest first; the card shows the first. */
+const held: Held[] = []
+
+/** The card lists every file instead of the first `SHOWN_FILES`. */
+let isExpanded = false
+
+/**
+ * Turns the guard on or off, for this session and every later one.
+ *
+ * @param $ - Engine handle the command or press came through.
+ * @param isGuarding - True to hold deletes on the card, false to let them run unasked.
+ */
+async function setGuard($: EngineInterface, isGuarding: boolean): Promise<void> {
+  await update($, isOn, () => isGuarding)
+  await $.store.set(STORE_KEY, isGuarding)
+}
+
+/**
+ * Shows the switch again once no delete waits: the pane's title goes back from the card's.
+ *
+ * @param $ - Engine handle the hook received.
+ */
+async function showSwitch($: EngineInterface): Promise<void> {
+  if (held.length === 0) await $.ui.open({ id: PANE, title: TITLE }).catch(() => undefined)
+  $.ui.invalidate('ui.render')
+}
+
+/**
+ * Answers the delete the card shows, then shows the next one or the switch.
+ *
+ * @param $ - Engine handle the press came through.
+ * @param answer - What the person chose.
+ */
+async function answerFirst($: EngineInterface, answer: Answer): Promise<void> {
+  const first = held.shift()
+  isExpanded = false
+  first?.settle(answer)
+  await showSwitch($)
+}
+
+/**
+ * @brief Holds a delete until the person answers its card, it waits `HOLD_MS`, or Claude's call is stopped.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param card - The delete and what it removes.
+ * @param signal - Aborts the wait when Claude's call is stopped.
+ * @returns `delete`, `cancel`, or `timeout` when no one answered in time.
+ */
+async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: AbortSignal | undefined): Promise<Answer | 'timeout'> {
+  let settle: (answer: Answer | 'timeout') => void = () => {}
+  const answered = new Promise<Answer | 'timeout'>(resolve => { settle = resolve })
+  const entry: Held = { ...card, settle }
+  held.push(entry)
+
+  /** Takes this delete off the card with `answer`, unless it was answered already. */
+  const drop = (answer: Answer | 'timeout'): void => {
+    const index = held.indexOf(entry)
+    if (index === -1) return
+    held.splice(index, 1)
+    settle(answer)
+    void showSwitch($)
+  }
+  const timer = $.clock.after(HOLD_MS, () => drop('timeout'))
+  const onAbort = (): void => drop('cancel')
+  signal?.addEventListener('abort', onAbort, { once: true })
+
+  // The switch's pane is usually open already: retitle and focus it, then redraw it as the card.
+  if (held.length === 1) await $.ui.open({ id: PANE, title: HOLD_TITLE, focus: true })
+  $.ui.invalidate('ui.render')
+
+  const answer = await answered
+  timer.cancel()
+  signal?.removeEventListener('abort', onAbort)
+  return answer
+}
+
+/**
+ * Registers this mod's `delete-guard` command, its session hook, its Bash tool hook, and its pane: the switch, or the card while a delete waits.
+ *
+ * @param on - Hook registration function the engine passes in.
+ */
+export const register: Register = on => {
+  let trash: string | undefined
+  let home = ''
+
+  on('session.start', async ($, e, next) => {
+    trash = await detectTrash($)
+    const found = await $.process.run(['printenv', 'HOME']).catch(() => undefined)
+    home = found?.stdout.trim() ?? ''
+    const remembered = await $.store.get(STORE_KEY).catch(() => undefined)
+    await update($, isOn, () => remembered === true)
+    await $.command.register({
+      name: 'delete-guard',
+      description: 'Turn the permanent-delete guard on or off; it stays that way in later sessions',
+      argumentHint: 'on | off',
+    })
+    void $.ui.open({ id: PANE, title: TITLE })
+    return next(e)
+  })
+
+  on('command.run', { command: 'delete-guard' }, async ($, e) => {
+    const wanted = e.args.trim()
+    if (wanted === 'on' || wanted === 'off') await setGuard($, wanted === 'on')
+    const isGuarding = await read($, isOn)
+    return { text: `delete-guard is ${isGuarding ? 'on: permanent deletes wait for your answer' : 'off: permanent deletes run unasked'}.` }
+  })
+
+  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
+    if (!(await read($, isOn))) return next(e)
+    const deletion = findDeletion(e.command)
+    if (deletion === undefined) return next(e)
+
+    const spelled = trash ?? 'trash'
+    const install = trash === undefined ? ' (install trash-cli: sudo apt install trash-cli)' : ''
+    const instead = `\`${insteadOf(deletion, spelled)}\`${install}`
+
+    // Nothing can draw the card, as in a -p run or VS Code without the viewer: refuse outright.
+    if ((await $.session.surfaces()).length === 0) {
+      return { deny: `delete-guard: \`${deletion.segment}\` deletes permanently. Move it to the trash instead: ${instead}.` }
+    }
+
+    const cwd = await $.session.cwd()
+    const radius = await measure($, deletion, cwd, home)
+    if (radius.isKnown && radius.files.length === 0) return next(e)
+
+    const folder = cwd.split('/').filter(Boolean).pop() ?? cwd
+    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.' }))
+
+  on('ui.close', async ($, e, next) => {
+    // Closing the card by hand answers every delete it holds with Cancel.
+    if (e.id === PANE && e.origin.kind === 'person') {
+      for (const entry of held.splice(0)) entry.settle('cancel')
+      isExpanded = false
+    }
+    return next(e)
+  })
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text, Button } = $.ui.resolve(e)
+    const card = held[0]
+    if (card === undefined) {
+      const isGuarding = await read($, isOn)
+      return (
+        <Box flexDirection="row" columnGap={2} alignItems="center">
+          <Button key="switch" label={isGuarding ? '● on' : '○ off'} variant={isGuarding ? 'primary' : 'secondary'} onPress={() => setGuard($, !isGuarding)} />
+          <Text dimColor wrap="truncate-end">{isGuarding ? 'Deletes wait here for Delete or Cancel.' : 'Deletes run without asking.'}</Text>
+        </Box>
+      )
+    }
+    const { radius } = card
+    const barCells = Math.max(8, Math.floor(e.props.bodyColumns * 0.22))
+
+    /** Draws a size bar with `share` of it filled: an SVG, or block characters in the terminal. */
+    const bar = (share: number, color: string) => {
+      if (e.surface === 'terminal') {
+        const filled = Math.max(1, Math.round(share * barCells))
+        return <Text><Text color={color}>{'▬'.repeat(filled)}</Text><Text color={TRACK}>{'▬'.repeat(barCells - filled)}</Text></Text>
+      }
+      const { Svg } = $.ui.resolve(e)
+      const width = barCells * CELL_PX
+      return <Svg source={barSvg(width, share, color)} alt={`${Math.round(share * 100)}%`} width={width} height={8} />
+    }
+
+    // Folders by size, each with its largest files under it, until SHOWN_FILES file rows are used.
+    const folders = new Map<string, DoomedFile[]>()
+    for (const file of radius.files) folders.set(folderOf(file.path), [...(folders.get(folderOf(file.path)) ?? []), file])
+    const groups = [...folders.entries()]
+      .map(([name, files]) => ({ name, files, size: files.reduce((sum, file) => sum + file.size, 0) }))
+      .sort((a, b) => b.size - a.size)
+    const largest = Math.max(1, groups[0]?.size ?? 1)
+    let budget = isExpanded ? radius.files.length : SHOWN_FILES
+    const rows = groups.flatMap(group => {
+      if (budget <= 0) return []
+      const files = group.files.slice(0, budget)
+      budget -= files.length
+      return [
+        <Box key={`dir:${group.name}`} flexDirection="row" columnGap={1} marginTop={1}>
+          <Box flexGrow={1}><Text wrap="truncate-end" bold>▭ {group.name === '.' ? './' : `${group.name}/`}</Text></Box>
+          <Box width={9} justifyContent="flex-end"><Text dimColor>{fileCount(group.files.length)}</Text></Box>
+          <Box width={8} justifyContent="flex-end"><Text bold>{bytes(group.size)}</Text></Box>
+          {bar(group.size / largest, '#d8d4c8')}
+        </Box>,
+        ...files.map(file => (
+          <Box key={`file:${file.path}`} flexDirection="row" columnGap={1} paddingLeft={2}>
+            <Box flexGrow={1}>
+              <Text wrap="truncate-end"><Text dimColor>▯ </Text><Text backgroundColor={file.isTracked ? undefined : UNTRACKED_BG}>{file.path.slice(file.path.lastIndexOf('/') + 1)}</Text></Text>
+            </Box>
+            <Box width={8} justifyContent="flex-end"><Text dimColor>{bytes(file.size)}</Text></Box>
+            {bar(file.size / largest, '#9a968c')}
+          </Box>
+        )),
+      ]
+    })
+    const hidden = isExpanded ? 0 : Math.max(0, radius.files.length - SHOWN_FILES)
+    const count = radius.isKnown ? `${fileCount(radius.files.length, radius.isCut)} · ${bytes(radius.total)}` : 'unknown files'
+    const waiting = held.length > 1 ? ` · ${held.length - 1} more waiting` : ''
+
+    return (
+      <Box flexDirection="column">
+        <Box flexDirection="row" columnGap={2} alignItems="center">
+          <Text bold color={RED} backgroundColor={CHIP}> 🗑 </Text>
+          <Box flexDirection="column" flexShrink={1}>
+            <Text wrap="truncate-end"><Text bold>{card.segment}</Text><Text dimColor> will delete </Text><Text bold color={ORANGE}>{count}</Text></Text>
+            <Text dimColor>in {card.folder}{waiting}</Text>
+          </Box>
+        </Box>
+        <Box borderStyle="round" borderColor={WARN_EDGE} backgroundColor={WARN_BG} paddingX={1} marginTop={1}>
+          <Text color={RED}>⛉ {restoreNote(radius)}</Text>
+        </Box>
+        {rows}
+        {hidden > 0 && (
+          <Box marginTop={1}>
+            <Button key="more" plain onPress={() => { isExpanded = true; $.ui.invalidate('ui.render') }}><Text dimColor>Show {hidden} more</Text></Button>
+          </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="cancel" label="Cancel" onPress={() => answerFirst($, 'cancel')} />
+          <Text dimColor>Held by delete-guard</Text>
+        </Box>
+      </Box>
+    )
+  })
+}

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

@@ -7,8 +7,33 @@ export type Deletion = {
   paths: string[]
 }
 
+/** One file a delete would remove: its path relative to the session's directory, its bytes, and whether git tracks it. */
+export type DoomedFile = {
+  path: string
+  size: number
+  isTracked: boolean
+}
+
+/**
+ * What a delete would remove, as the card shows it.
+ *
+ * @property files - Every file found, largest first.
+ * @property total - Bytes of all of them.
+ * @property isCut - The walk stopped early, so there are more than `files` lists.
+ * @property isKnown - The files could be listed at all; false when the listing failed.
+ */
+export type BlastRadius = {
+  files: DoomedFile[]
+  total: number
+  isCut: boolean
+  isKnown: boolean
+}
+
+/** The person's answer on the card: run the delete, or refuse it. */
+export type Answer = 'delete' | 'cancel'
+
 declare module 'claude-code' {
   interface PluginState {
-    'delete-guard': { isOff: boolean }
+    'delete-guard': { isOn: boolean }
   }
 }

package/mods/focus-mode/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "focus-mode",
   "version": "0.1.0",
-  "description": "A timed focus block with a countdown, a progress bar and an end button.",
+  "description": "A timed focus block in which you're away: Claude asks no questions and gets no permission prompts. Countdown, progress bar and end button.",
   "author": {
     "name": "g3ntrovert"
   },

package/mods/focus-mode/hooks/register.tsx

@@ -107,7 +107,20 @@ async function tick($: EngineInterface): Promise<void> {
 }
 
 /**
- * Registers this mod's `focus-mode` command, its session hook, its tick, and its pane.
+ * Finds the running block, if any: while one runs the person is away from the keyboard.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @returns The block, or `null` when none runs or its time is up.
+ */
+async function awayBlock($: EngineInterface): Promise<FocusBlock | null> {
+  const current = await read($, block)
+  if (current === null) return null
+  return (await $.clock.now()) < current.endsAt ? current : null
+}
+
+/**
+ * Registers this mod's `focus-mode` command, its session hook, its tick, its pane, and the hooks that keep Claude
+ * from asking anything during a block: questions are refused, and so are permission prompts.
  *
  * @param on - Hook registration function the engine passes in.
  * @param options - Plugin options; `minutes` sets the default block length.
@@ -119,7 +132,7 @@ export const register: Register = (on, options) => {
   on('session.start', async ($, e, next) => {
     await $.command.register({
       name: 'focus-mode',
-      description: `Start a focus block (${defaultMinutes} min by default), or end the running one`,
+      description: `Start a focus block (${defaultMinutes} min by default) in which Claude asks you nothing, or end the running one`,
       argumentHint: '[minutes] | end',
     })
     void $.ui.open({ id: PANE, title: TITLE })
@@ -141,6 +154,25 @@ export const register: Register = (on, options) => {
     return { text: `Focus block started: ${minutes} min.` }
   })
 
+  // While a block runs the person is away: a question Claude puts to them is refused, so Claude decides on its own.
+  on('tool.call', { tool: 'AskUserQuestion' }, async ($, e, next) => {
+    const away = await awayBlock($)
+    if (away === null) return next(e)
+    return { deny: `The user is in a focus block until ${wallTime(away.endsAt)} and cannot answer. Pick the option you would recommend, say in your reply what you assumed, and carry on.` }
+  }).catch(($, e, next) => next(e))
+
+  // A permission prompt would wait for the person too: refuse it, so Claude works around the step or leaves it for later.
+  on('classic.PermissionRequest', async ($, e, next) => {
+    const away = await awayBlock($)
+    if (away === null) return next(e)
+    return {
+      decision: {
+        behavior: 'deny',
+        message: `The user is in a focus block until ${wallTime(away.endsAt)} and cannot approve ${e.tool_name}. Do what you can without it, and list this step at the end of your reply for the user to approve later.`,
+      },
+    }
+  }).catch(($, e, next) => next(e))
+
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
     const { Box, Text, Button } = $.ui.resolve(e)
     const current = await read($, block)
@@ -176,7 +208,7 @@ export const register: Register = (on, options) => {
         <Text bold>{clock(remaining)}</Text>
         <Box flexDirection="column" flexGrow={1} gap={0}>
           {squares}
-          <Text dimColor>focus block · {current.minutes} min · ends {wallTime(current.endsAt)}</Text>
+          <Text dimColor>away until {wallTime(current.endsAt)} · Claude asks you nothing</Text>
         </Box>
         <Button key="end" label="end focus" onPress={() => endFocus($, false)} />
       </Box>

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

@@ -14,6 +14,9 @@ const MINES = 10
 const BEST_KEY = 'best-seconds'
 /** 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. */
+const CELL_WIDTH = 2
+
 const NUMBER_COLORS = [undefined, '#6b8fd6', '#7cc47f', '#e06c6c', '#9b87f5', '#e0775a', '#5fb3c4', '#d0d0d0', '#8a8f98']
 
 /**
@@ -224,21 +227,21 @@ export const register: Register = on => {
     const isOver = board.status === 'won' || board.status === 'lost'
 
     /**
-     * Draws one cell: a number, a flag, a mine, or a button that reveals or flags it.
+     * Draws what a cell shows: a number, a flag, a mine, or a button that reveals or flags it.
      *
      * @param cell - Cell number to draw.
-     * @returns The cell element.
+     * @returns The cell's content.
      */
-    const cellView = (cell: number) => {
+    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>
+        if (isMine) return <Text color="#e06c6c">✹</Text>
         const n = adjacentMines(board, cell)
-        return <Text color={NUMBER_COLORS[n]}>{n === 0 ? '  ' : `${n} `}</Text>
+        return <Text color={NUMBER_COLORS[n]}>{n === 0 ? ' ' : String(n)}</Text>
       }
       const label = board.flagged.includes(cell) ? '⚑' : '■'
-      if (isOver) return <Text dimColor>{label} </Text>
+      if (isOver) return <Text dimColor>{label}</Text>
       return (
         <Button key={`cell:${cell}`} plain onPress={() => pressCell($, cell)}>
           <Text color={label === '⚑' ? '#e0775a' : '#6b7280'}>{label}</Text>
@@ -246,6 +249,11 @@ export const register: Register = on => {
       )
     }
 
+    // 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>
+    )
+
     const rows = Array.from({ length: board.size }, (_, r) => (
       <Box flexDirection="row" columnGap={1}>
         {Array.from({ length: board.size }, (_, c) => cellView(r * board.size + c))}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@g3nomaly/g3n-mods",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "The g3n Claude Code mods: panes, status lines, commands and hooks, installed with @g3nomaly/mods.",
   "type": "module",
   "files": [
@@ -15,7 +15,7 @@
     "types": "bun scripts/sync-types.ts"
   },
   "devDependencies": {
-    "@g3nomaly/core": "^0.3.1",
+    "@g3nomaly/core": "^0.3.3",
     "@types/bun": "^1.4.0",
     "typescript": "~7.0.2",
     "zod": "^4.4.3"

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

@@ -1,151 +0,0 @@
-// packages/g3n-mods/mods/delete-guard/hooks/register.ts
-import { atom, read, update } from 'claude-code'
-import type { EngineInterface, Register } from 'claude-code'
-
-import type { Deletion } from '../types'
-
-const isOff = atom({ plugin: 'delete-guard', key: 'isOff' } as const, false)
-
-/** 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+)*)+/
-
-const DELETERS = new Set(['rm', 'shred', 'unlink', 'rimraf', 'srm'])
-
-/** Trash commands in order of preference, with how each one is spelled. */
-const TRASH_COMMANDS = [
-  { probe: 'trash', spell: 'trash' },
-  { probe: 'trash-put', spell: 'trash-put' },
-  { probe: 'gio', spell: 'gio trash' },
-] as const
-
-/**
- * Splits a shell command line into its commands, each trimmed.
- *
- * @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)
-}
-
-/**
- * Splits one command into words, dropping its prefixes and the program's directory.
- *
- * @param segment - One command, as `segments` returns it.
- * @returns The program name first, then its arguments.
- */
-function words(segment: string): string[] {
-  const [program = '', ...rest] = segment.replace(PREFIX, '').split(/\s+/)
-  return [program.split('/').pop() ?? program, ...rest]
-}
-
-/**
- * Picks the operands of a command: every word that is not a flag, and every word after `--`.
- *
- * @param args - Words after the program name.
- * @returns The operands in order.
- */
-function operands(args: readonly string[]): string[] {
-  const end = args.indexOf('--')
-  const flagged = end === -1 ? args : args.slice(0, end)
-  const after = end === -1 ? [] : args.slice(end + 1)
-  return [...flagged.filter(arg => !arg.startsWith('-')), ...after]
-}
-
-/**
- * @brief Finds the first permanent delete in a shell command line.
- *
- * Recognises `rm`, `shred`, `unlink`, `rimraf`, `find -delete`, `find -exec rm`
- * and a forced `git clean`.
- *
- * @param command - Full shell command line, as the Bash tool received it.
- * @returns The delete and what it removes, or `undefined` when nothing is deleted for good.
- */
-export function findDeletion(command: string): Deletion | undefined {
-  for (const segment of segments(command)) {
-    const [program = '', ...args] = words(segment)
-    if (DELETERS.has(program)) {
-      return { 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: [] }
-    }
-    if (program === 'git' && args[0] === 'clean' && args.some(arg => /^-\w*f/.test(arg) || arg === '--force')) {
-      return { segment, kind: 'git-clean', paths: [] }
-    }
-  }
-  return undefined
-}
-
-/**
- * Builds the command Claude should run instead of a permanent delete.
- *
- * @param deletion - Delete to replace, see `Deletion`.
- * @param trash - Trash command spelled as this machine has it, e.g. `gio trash`.
- * @returns The suggested command, with `<paths>` where no path was named.
- */
-function insteadOf(deletion: Deletion, trash: string): string {
-  switch (deletion.kind) {
-    case 'files':
-      return deletion.paths.length > 0 ? `${trash} ${deletion.paths.join(' ')}` : `${trash} <paths>`
-    case 'find':
-      return `${deletion.segment.replace(/\s-delete\b/, '').replace(/-exec(?:dir)?\s+.*$/, '')} -exec ${trash} {} +`.replace(/\s+/g, ' ')
-    case 'git-clean':
-      return `git clean -n to list the files, then ${trash} <paths>`
-  }
-}
-
-/**
- * Finds the first trash command on this machine's PATH.
- *
- * @param $ - Engine handle the hook received, see `EngineInterface`.
- * @returns The command as it should be spelled, or `undefined` when none is installed.
- */
-async function detectTrash($: EngineInterface): Promise<string | undefined> {
-  for (const candidate of TRASH_COMMANDS) {
-    const found = await $.process.run(['sh', '-c', `command -v ${candidate.probe}`]).catch(() => undefined)
-    if (found?.exitCode === 0) return candidate.spell
-  }
-  return undefined
-}
-
-/**
- * Registers this mod's `delete-guard` command, its session hook, and its Bash tool hook.
- *
- * @param on - Hook registration function the engine passes in.
- */
-export const register: Register = on => {
-  let trash: string | undefined
-
-  on('session.start', async ($, e, next) => {
-    trash = await detectTrash($)
-    await $.command.register({
-      name: 'delete-guard',
-      description: 'Turn the permanent-delete guard on or off for this session',
-      argumentHint: 'on | off',
-    })
-    return next(e)
-  })
-
-  on('command.run', { command: 'delete-guard' }, async ($, e) => {
-    const wanted = e.args.trim()
-    if (wanted === 'on' || wanted === 'off') await update($, isOff, () => wanted === 'off')
-    const off = await read($, isOff)
-    return { text: `delete-guard is ${off ? 'off: permanent deletes run' : 'on: permanent deletes are denied'}.` }
-  })
-
-  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
-    if (await read($, isOff)) return next(e)
-    const deletion = findDeletion(e.command)
-    if (deletion === undefined) return next(e)
-
-    const spelled = trash ?? 'trash'
-    const install = trash === undefined ? ' (install trash-cli: sudo apt install trash-cli)' : ''
-    return {
-      deny: `delete-guard: \`${deletion.segment}\` deletes permanently. Move it to the trash instead: \`${insteadOf(deletion, spelled)}\`${install}.`,
-    }
-  }).catch(($, e, next) => (next.called ? next(e) : { deny: 'delete-guard: the guard failed, so the command was not run.' }))
-}