@g3nomaly/g3n-mods 0.1.2 → 0.1.4

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,9 +132,10 @@ 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 })
     $.clock.every(1000, () => void tick($))
     return next(e)
   })
@@ -140,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)
@@ -175,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']
 
 /**
@@ -187,6 +190,7 @@ export const register: Register = on => {
     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 })
     $.clock.every(1000, () => void tick($))
     return next(e)
   })
@@ -223,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>
@@ -245,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/mods/tool-timeline/hooks/register.tsx

@@ -28,6 +28,15 @@ const TOOL_COLORS: ReadonlyArray<[RegExp, string]> = [
   [/^(Agent|Task)$/, '#f09bb5'],
 ]
 
+/** Background of a row's hover card. */
+const CARD = '#1b1f27'
+
+/** Idle time between calls, in milliseconds, kept on the bars' axis; longer idle stretches shrink to this. */
+const IDLE_MS = 200
+
+/** Most characters of a call's input the hover card keeps. */
+const DETAIL_MAX = 2000
+
 /** Input fields that say most about a call, tried in order. */
 const LABEL_FIELDS = ['command', 'file_path', 'notebook_path', 'pattern', 'url', 'query', 'description', 'skill', 'prompt'] as const
 
@@ -59,6 +68,47 @@ export function labelOf(input: Record<string, unknown>): string {
   return first?.replace(/\s+/g, ' ').trim() ?? ''
 }
 
+/**
+ * @brief Finds a call's whole input text for the row's hover card: the full command, path, pattern or first text field.
+ *
+ * @param input - Arguments of the tool call.
+ * @returns The text with its line breaks, cut at `DETAIL_MAX` characters.
+ */
+export function detailOf(input: Record<string, unknown>): string {
+  const field = LABEL_FIELDS.find(name => typeof input[name] === 'string' && input[name] !== '')
+  const value = field === undefined ? Object.values(input).find((one): one is string => typeof one === 'string') : (input[field] as string)
+  const text = value?.trim() ?? ''
+  return text.length > DETAIL_MAX ? `${text.slice(0, DETAIL_MAX - 1)}…` : text
+}
+
+/** Where a call sits on the bars' axis, in milliseconds from the first shown call's start. */
+type Span = { from: number; to: number }
+
+/**
+ * @brief Places calls on one time axis, shrinking idle stretches between them to `IDLE_MS`, so the bars read as a waterfall.
+ *
+ * @param list - Calls in start order.
+ * @param now - Current time, the end of calls still running.
+ * @returns Each call's span, in `list` order, and the axis length (at least 1).
+ */
+export function placeCalls(list: readonly TimelineCall[], now: number): { spans: Span[]; length: number } {
+  const origin = list[0]?.startedAt ?? now
+  let busyUntil = origin
+  let shift = 0
+  let length = 1
+  const spans = list.map(call => {
+    const end = Math.max(call.startedAt, call.endedAt ?? now)
+    const idle = call.startedAt - busyUntil
+    if (idle > IDLE_MS) shift += idle - IDLE_MS
+    busyUntil = Math.max(busyUntil, end)
+    const from = call.startedAt - origin - shift
+    const to = end - origin - shift
+    length = Math.max(length, to)
+    return { from, to }
+  })
+  return { spans, length }
+}
+
 /**
  * @brief Joins the text of a tool result's content, which is a string or a list of text blocks.
  *
@@ -146,16 +196,16 @@ function replacementOf(list: readonly TimelineCall[], index: number): TimelineCa
 }
 
 /**
- * @brief Builds the SVG of a track with a bar filled to `fill` pixels.
+ * @brief Builds the SVG of a track with a bar from `x` that is `fill` pixels long.
  *
  * @param width - Width of the track in pixels.
- * @param fill - Filled length in pixels, clamped to the width.
+ * @param x - Start of the bar in pixels.
+ * @param fill - Length of the bar in pixels.
  * @param color - Fill color.
  * @returns The SVG markup.
  */
-function barSvg(width: number, fill: number, color: string): string {
-  const w = Math.max(0, Math.min(width, fill))
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="8" viewBox="0 0 ${width} 8"><rect width="${width}" height="8" rx="2" fill="${TRACK}"/><rect width="${w.toFixed(1)}" height="8" rx="2" fill="${color}"/></svg>`
+function barSvg(width: number, x: number, fill: number, color: string): string {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="8" viewBox="0 0 ${width} 8"><rect width="${width}" height="8" rx="2" fill="${TRACK}"/><rect x="${x.toFixed(1)}" width="${fill.toFixed(1)}" height="8" rx="2" fill="${color}"/></svg>`
 }
 
 /**
@@ -182,12 +232,15 @@ export const register: Register = on => {
 
   on('tool.call', async ($, e, next) => {
     const startedAt = await $.clock.now()
-    const label = labelOf(e as unknown as Record<string, unknown>)
+    const input = e as unknown as Record<string, unknown>
+    const label = labelOf(input)
+    const detail = detailOf(input)
     await patchCall($, e.tool_use_id, call => ({
       ...call,
       id: e.tool_use_id,
       tool: e.tool,
       label,
+      detail,
       status: 'running',
       startedAt,
       agentId: e.agentId,
@@ -209,7 +262,7 @@ export const register: Register = on => {
         const input = typeof block.input === 'object' && block.input !== null ? (block.input as Record<string, unknown>) : {}
         const id = block.id
         const tool = block.name
-        await patchCall($, id, call => call ?? { id, tool, label: labelOf(input), status: 'queued', startedAt: now, agentId: e.agentId })
+        await patchCall($, id, call => call ?? { id, tool, label: labelOf(input), detail: detailOf(input), status: 'queued', startedAt: now, agentId: e.agentId })
       }
     }
     if (e.door === 'tool-result') {
@@ -236,27 +289,32 @@ export const register: Register = on => {
     const shown = list.slice(-room)
     /** Length of a call so far, or up to its end when it has one. */
     const durationOf = (call: TimelineCall): number => (call.endedAt ?? now) - call.startedAt
-    const longest = Math.max(1, ...shown.map(durationOf))
     const total = list.reduce((sum, call) => sum + (call.status === 'denied' ? 0 : durationOf(call)), 0)
+    const axis = placeCalls(shown, now)
     const barCells = Math.max(8, Math.floor(e.props.bodyColumns * 0.3))
     const labelCells = Math.max(12, e.props.bodyColumns - barCells - 12)
 
-    /** Draws the bar showing a call's share of the longest call's time. */
-    const bar = (call: TimelineCall) => {
+    /** Draws a call's bar on the shared axis: where it started and how long it ran, idle time between calls shrunk. */
+    const bar = (call: TimelineCall, span: Span) => {
       const color = call.status === 'error' ? ERROR : call.status === 'ok' && /^Bash$/.test(call.tool) ? '#5fae6e' : colorOf(call.tool)
-      const share = call.status === 'denied' ? 0.04 : Math.max(0.03, durationOf(call) / longest)
+      const start = span.from / axis.length
+      const share = call.status === 'denied' ? 0.03 : Math.max(0.02, (span.to - span.from) / axis.length)
       if (e.surface === 'terminal') {
         const filled = Math.max(1, Math.round(share * barCells))
+        const before = Math.min(barCells - filled, Math.round(start * barCells))
         return (
           <Text>
+            <Text color={TRACK}>{'▬'.repeat(before)}</Text>
             <Text color={color}>{'▬'.repeat(filled)}</Text>
-            <Text color={TRACK}>{'▬'.repeat(barCells - filled)}</Text>
+            <Text color={TRACK}>{'▬'.repeat(barCells - before - filled)}</Text>
           </Text>
         )
       }
       const { Svg } = $.ui.resolve(e)
       const width = barCells * CELL_PX
-      return <Svg source={barSvg(width, share * width, color)} alt={`${call.tool} ${seconds(durationOf(call))}`} width={width} height={8} />
+      const fill = Math.max(3, share * width)
+      const x = Math.min(width - fill, start * width)
+      return <Svg source={barSvg(width, x, fill, color)} alt={`${call.tool} ${seconds(durationOf(call))}`} width={width} height={8} />
     }
 
     /** Renders a call's status at the end of its row: its time, `denied`, `queued` or a mark for an error. */
@@ -270,32 +328,37 @@ export const register: Register = on => {
       }
     }
 
-    const rows = shown.map((call, index) => {
-      const replacement = call.status === 'denied' ? replacementOf(shown, index) : undefined
-      return (
-        <Box flexDirection="column">
-          <Box flexDirection="row" columnGap={1}>
-            <Text bold color="#1b1f27" backgroundColor={colorOf(call.tool)}> {badgeOf(call.tool)} </Text>
-            <Box width={labelCells}>
-              <Text wrap="truncate-end" strikethrough={call.status === 'denied'} color={call.status === 'denied' ? ERROR : undefined}>
-                {call.agentId === undefined ? '' : '↳ '}{call.tool} <Text dimColor>{call.label}</Text>
-              </Text>
-            </Box>
-            {bar(call)}
-            <Box width={8} justifyContent="flex-end">{outcome(call)}</Box>
-          </Box>
-          {call.status === 'denied' && (
-            <Box borderStyle="round" borderColor="#7a3b3b" paddingX={1} flexDirection="row" justifyContent="space-between">
-              <Text wrap="truncate-end">
-                <Text color={ERROR}>⊘ </Text>
-                <Text strikethrough dimColor>{call.label}</Text>
-                {replacement === undefined ? '' : <Text> → <Text color="#7cc47f">{replacement.label}</Text></Text>}
-              </Text>
-              <Text color={ERROR}>denied{call.note === undefined ? '' : ` · ${shortNote(call.note)}`}</Text>
-            </Box>
-          )}
+    // One line per call; the keyed row reveals a card with the call's whole input while the pointer is on it.
+    const rows = shown.map((call, index) => (
+      <Box key={call.id} flexDirection="row" columnGap={1}>
+        <Text bold color={CARD} backgroundColor={colorOf(call.tool)}> {badgeOf(call.tool)} </Text>
+        <Box width={labelCells}>
+          <Text wrap="truncate-end" strikethrough={call.status === 'denied'} color={call.status === 'denied' ? ERROR : undefined}>
+            {call.agentId === undefined ? '' : '↳ '}{call.tool} <Text dimColor>{call.label}</Text>
+          </Text>
+        </Box>
+        {bar(call, axis.spans[index] ?? { from: 0, to: 0 })}
+        <Box width={8} justifyContent="flex-end">{outcome(call)}</Box>
+        <Box position="absolute" top={1} left={4} right={0} display="none" hover={{ display: 'flex' }} backgroundColor={CARD} borderStyle="round" borderColor={DIM} paddingX={1}>
+          <Text wrap="wrap">{call.tool} <Text dimColor>{call.detail ?? call.label}</Text></Text>
         </Box>
-      )
+      </Box>
+    ))
+
+    // Denied calls get their callout under the list, so every call keeps to its one line.
+    const callouts = shown.flatMap((call, index) => {
+      if (call.status !== 'denied') return []
+      const replacement = replacementOf(shown, index)
+      return [
+        <Box borderStyle="round" borderColor="#7a3b3b" paddingX={1} flexDirection="row" justifyContent="space-between">
+          <Text wrap="truncate-end">
+            <Text color={ERROR}>⊘ </Text>
+            <Text strikethrough dimColor>{call.label}</Text>
+            {replacement === undefined ? '' : <Text> → <Text color="#7cc47f">{replacement.label}</Text></Text>}
+          </Text>
+          <Text color={ERROR}>denied{call.note === undefined ? '' : ` · ${shortNote(call.note)}`}</Text>
+        </Box>,
+      ]
     })
 
     return (
@@ -305,6 +368,7 @@ export const register: Register = on => {
           <Text dimColor>{list.length} call{list.length === 1 ? '' : 's'} · {seconds(total)}</Text>
         </Box>
         {rows}
+        {callouts.length > 0 && <Box flexDirection="column" marginTop={1}>{callouts}</Box>}
       </Box>
     )
   })

package/mods/tool-timeline/types/index.d.ts

@@ -9,6 +9,8 @@ export type TimelineCall = {
   tool: string
   /** Short form of the call's input, e.g. `rm -rf dist` or `package.json` */
   label: string
+  /** The call's whole input text for the row's hover card, e.g. the full command or path */
+  detail?: string
   status: CallStatus
   startedAt: number
   endedAt?: number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@g3nomaly/g3n-mods",
-  "version": "0.1.2",
+  "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.' }))
-}