@cmodjs/core 0.1.13 → 0.2.0

package/src/options.ts

@@ -0,0 +1,91 @@
+export type OptionKind = 'text' | 'secret' | 'number' | 'toggle' | 'choice' | 'folder' | 'file' | 'list'
+
+export type OptionValue = string | number | boolean | readonly string[]
+
+type Described = { readonly title: string; readonly description: string }
+
+export type Option<Value extends OptionValue = OptionValue> = Described & {
+  readonly kind: OptionKind
+  readonly default?: Value
+  readonly min?: number
+  readonly max?: number
+  readonly choices?: readonly string[]
+}
+
+export type Options = Readonly<Record<string, Option>>
+
+export type OptionValues<Declared extends Options> = { readonly [Key in keyof Declared]: Declared[Key] extends Option<infer Value> ? Value : never }
+
+export type UserConfigField = Described & {
+  readonly type: 'string' | 'number' | 'boolean' | 'directory' | 'file'
+  readonly sensitive?: true
+  readonly multiple?: true
+  readonly default?: OptionValue
+  readonly min?: number
+  readonly max?: number
+  readonly options?: readonly string[]
+}
+
+export const option = {
+  text: (field: Described & { readonly default?: string }): Option<string> => ({ ...field, kind: 'text' }),
+  secret: (field: Described): Option<string> => ({ ...field, kind: 'secret' }),
+  number: (field: Described & { readonly default?: number; readonly min?: number; readonly max?: number }): Option<number> => ({ ...field, kind: 'number' }),
+  toggle: (field: Described & { readonly default?: boolean }): Option<boolean> => ({ ...field, kind: 'toggle', default: field.default ?? false }),
+  choice: <const Choice extends string>(choices: readonly Choice[], field: Described & { readonly default?: Choice }): Option<Choice> => ({ ...field, kind: 'choice', choices }),
+  folder: (field: Described & { readonly default?: string }): Option<string> => ({ ...field, kind: 'folder' }),
+  file: (field: Described & { readonly default?: string }): Option<string> => ({ ...field, kind: 'file' }),
+  list: (field: Described & { readonly default?: readonly string[] }): Option<readonly string[]> => ({ ...field, kind: 'list' }),
+}
+
+const types: Readonly<Record<OptionKind, UserConfigField['type']>> = { text: 'string', secret: 'string', number: 'number', toggle: 'boolean', choice: 'string', folder: 'directory', file: 'file', list: 'string' }
+
+const optionKey = /^[A-Za-z_]\w*$/
+
+export function checkOptions(name: string, options: Options): Options {
+  for (const [key, declared] of Object.entries(options)) {
+    const at = `${name}: options.${key}`
+    if (!optionKey.test(key)) throw new Error(`${at} is not an option name. Use letters, digits, and _, starting with a letter, as Claude Code passes each option on as CLAUDE_PLUGIN_OPTION_${key.toUpperCase()}.`)
+    if (declared.title.trim() === '') throw new Error(`${at} needs a title, the label /config shows.`)
+    if (declared.kind === 'choice' && (declared.choices ?? []).length === 0) throw new Error(`${at} is a choice with no choices. Give option.choice(['a', 'b'], { ... }).`)
+    if (declared.kind === 'choice' && declared.default !== undefined && !(declared.choices ?? []).includes(declared.default as string)) throw new Error(`${at} defaults to ${String(declared.default)}, which is not one of its choices: ${(declared.choices ?? []).join(', ')}.`)
+  }
+  return options
+}
+
+export function userConfigOf(options: Options): Record<string, UserConfigField> {
+  return Object.fromEntries(
+    Object.entries(options).map(([key, declared]) => [
+      key,
+      {
+        type: types[declared.kind],
+        title: declared.title,
+        description: declared.description,
+        ...(declared.kind === 'secret' ? { sensitive: true } : {}),
+        ...(declared.kind === 'list' ? { multiple: true } : {}),
+        ...(declared.kind === 'choice' ? { options: declared.choices } : {}),
+        ...(declared.default === undefined ? {} : { default: declared.default }),
+        ...(declared.min === undefined ? {} : { min: declared.min }),
+        ...(declared.max === undefined ? {} : { max: declared.max }),
+      } satisfies UserConfigField,
+    ]),
+  )
+}
+
+export function isUnset(value: unknown): boolean {
+  return value === undefined || value === '' || (Array.isArray(value) && value.length === 0)
+}
+
+export function fitsOption(declared: Option, value: unknown): string | undefined {
+  const kind = declared.kind
+  if (kind === 'toggle') return typeof value === 'boolean' ? undefined : 'takes true or false'
+  if (kind === 'number') {
+    if (typeof value !== 'number' || !Number.isFinite(value)) return 'takes a number'
+    if (declared.min !== undefined && value < declared.min) return `takes ${declared.min} or more`
+    if (declared.max !== undefined && value > declared.max) return `takes ${declared.max} or less`
+    return undefined
+  }
+  if (kind === 'list') return Array.isArray(value) && value.every((item) => typeof item === 'string') ? undefined : 'takes a list of text'
+  if (typeof value !== 'string') return 'takes text'
+  if (kind === 'choice' && !(declared.choices ?? []).includes(value)) return `takes one of: ${(declared.choices ?? []).join(', ')}`
+  return undefined
+}

package/src/records.ts

@@ -11,14 +11,28 @@ export type InstallRecord = {
   keys: Readonly<Record<string, string>>
 }
 
-export type Steps = { install?: string; uninstall?: string; program?: string; keys?: Readonly<Record<string, string>> }
+export type Steps = {
+  install?: string
+  uninstall?: string
+  program?: string
+  keys?: Readonly<Record<string, string>>
+  permissions?: readonly string[]
+}
+
+export const listPermissions = ['network', 'run', 'files'] as const
+export const flagPermissions = ['conversation', 'prompt', 'model', 'agents', 'tools', 'config', 'approve'] as const
+export type ListPermission = (typeof listPermissions)[number]
+export type FlagPermission = (typeof flagPermissions)[number]
+const permissionNames: readonly string[] = [...listPermissions, ...flagPermissions]
+const hostName = /^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)*$/
+const programName = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/
 
 export type ReadFile = (path: string) => Promise<string | undefined>
 
 export type RunnerEvent =
   | { kind: 'progress'; done: number; total: number; label: string }
   | { kind: 'log'; text: string }
-  | { kind: 'needs-consent'; sha256: string; install: string; uninstall: string; keys: string }
+  | { kind: 'needs-consent'; sha256: string; install: string; uninstall: string; keys: string; permissions: readonly string[] }
   | { kind: 'done'; name: string; version?: string }
   | { kind: 'missing'; name: string }
   | { kind: 'failed'; code: number; message: string }
@@ -112,7 +126,92 @@ export function readSteps(pkg: unknown): Steps | undefined {
   if (!isObject(steps)) throw new Error('package.json has a "cmod" key that is not an object. Write "cmod": { "install": "./setup/install.sh", "uninstall": "./setup/uninstall.sh" }.')
   const program = steps['program']
   if (program !== undefined && (typeof program !== 'string' || !pluginName.test(program))) throw new Error('package.json "cmod.program" must be the program\'s command, such as "hello".')
-  return { ...readCommand(steps, 'install'), ...readCommand(steps, 'uninstall'), ...(program === undefined ? {} : { program }), ...readKeys(steps['keys']) }
+  const permissions = readPermissions(steps)
+  return {
+    ...readCommand(steps, 'install'),
+    ...readCommand(steps, 'uninstall'),
+    ...(program === undefined ? {} : { program }),
+    ...readKeys(steps['keys']),
+    ...(permissions.length === 0 ? {} : { permissions }),
+  }
+}
+
+function readPermissions(steps: Record<string, unknown>): string[] {
+  const declared = steps['permissions']
+  if (declared === undefined) return []
+  const at = 'package.json "cmod.permissions"'
+  if (!isObject(declared)) throw new Error(`${at} must be an object, such as { "network": ["api.github.com"], "prompt": true }.`)
+  const items: string[] = []
+  for (const [name, value] of Object.entries(declared)) {
+    if (!permissionNames.includes(name)) throw new Error(`${at} names "${name}", which is not a permission. Use ${listed(permissionNames.map((each) => `"${each}"`))}.`)
+    if ((flagPermissions as readonly string[]).includes(name)) {
+      if (value !== true) throw new Error(`${at} sets "${name}" to ${JSON.stringify(value)}. Write "${name}": true, or leave it out.`)
+      items.push(name)
+      continue
+    }
+    if (name === 'run' && value === '*') {
+      items.push('run:*')
+      continue
+    }
+    const example = name === 'network' ? '["api.github.com"]' : name === 'run' ? '["gh"], or "*" for any program' : '["~/.zshrc"]'
+    if (!Array.isArray(value) || value.length === 0 || !value.every((each) => typeof each === 'string')) throw new Error(`${at} sets "${name}" to ${JSON.stringify(value)}. Write a list, such as "${name}": ${example}.`)
+    for (const each of value as string[]) {
+      const isPath = /^(~\/|\/)/.test(each) && !each.split('/').includes('..')
+      const isValid = name === 'network' ? hostName.test(each) || isPath : name === 'run' ? programName.test(each) : isPath
+      if (!isValid) throw new Error(`${at} lists "${each}" under "${name}". Write ${name === 'network' ? 'a host alone, such as "api.github.com", or a socket path, such as "/var/run/docker.sock"' : name === 'run' ? 'a program\'s command, such as "gh"' : 'a path that starts with ~/ or /, such as "~/.zshrc"'}.`)
+      items.push(`${name}:${each}`)
+    }
+  }
+  return items
+}
+
+export function permissionWords(item: string): string {
+  const split = item.indexOf(':')
+  const target = item.slice(split + 1)
+  switch (split === -1 ? item : item.slice(0, split)) {
+    case 'network':
+      return `Connect to ${target}`
+    case 'run':
+      return target === '*' ? 'Run any program on your computer' : `Run ${target} on your computer`
+    case 'files':
+      return `Change ${target}`
+    case 'conversation':
+      return 'Read this conversation'
+    case 'prompt':
+      return 'Add text Claude reads and start turns'
+    case 'model':
+      return 'Ask a model, which uses your plan'
+    case 'agents':
+      return 'Start agents'
+    case 'tools':
+      return "Use and change Claude's tool calls"
+    case 'config':
+      return 'Change your Claude Code settings'
+    case 'approve':
+      return "Approve Claude's tool calls for you"
+    default:
+      return item
+  }
+}
+
+export const settingsPagesMethod = 'cmod:settingsPages'
+
+export const openPageMethod = 'cmod:openPage'
+
+export const pendingStepsMethod = 'cmod:pendingSteps'
+
+export const finishStepsMethod = 'cmod:finishSteps'
+
+export function consentPath(store: string): string {
+  return `${store}/consent.json`
+}
+
+export function parseConsent(value: unknown, path: string): Record<string, string[]> {
+  if (value === undefined) return Object.create(null)
+  if (!isObject(value) || Object.values(value).some((items) => !Array.isArray(items) || items.some((item) => typeof item !== 'string'))) {
+    throw new Error(`${path} is not a map of plugin names to what each was approved for. Delete it, and cmod asks again.`)
+  }
+  return Object.assign(Object.create(null), value) as Record<string, string[]>
 }
 
 function readKeys(keys: unknown): Steps {
@@ -127,8 +226,9 @@ function readKeys(keys: unknown): Steps {
   return { keys: commands }
 }
 
-export function oldestCmodFor(keys: Readonly<Record<string, string>>): string {
-  return Object.keys(keys).length > 0 ? '0.1.12' : '0.0.0'
+export function oldestCmodFor(steps: Steps): string {
+  if (steps.permissions !== undefined) return '0.2.0'
+  return Object.keys(steps.keys ?? {}).length > 0 ? '0.1.12' : '0.0.0'
 }
 
 export function keyWords(keys: Readonly<Record<string, string>> | undefined): string {
@@ -169,7 +269,13 @@ export async function scriptsSha256(steps: Steps, files: { read: ReadFile; list:
     if (scriptFolders.length === 0) throw new Error(`package.json "cmod.${key}" runs "${command}", which names no script file in the mod, so consent cannot cover what it runs. Put the commands in a script, such as ./setup/${key}.sh.`)
     for (const folder of scriptFolders) folders.add(folder)
   }
-  let text = [steps.install ?? '', steps.uninstall ?? '', steps.program ?? '', ...(steps.keys === undefined ? [] : [JSON.stringify(Object.entries(steps.keys).sort())])].join('\0')
+  let text = [
+    steps.install ?? '',
+    steps.uninstall ?? '',
+    steps.program ?? '',
+    ...(steps.keys === undefined ? [] : [JSON.stringify(Object.entries(steps.keys).sort())]),
+    ...(steps.permissions === undefined ? [] : [JSON.stringify([...steps.permissions].sort())]),
+  ].join('\0')
   for (const folder of [...folders].sort()) {
     for (const name of (await files.list(folder)).sort()) {
       const path = `${folder}/${name}`
@@ -189,7 +295,7 @@ export function formatEvent(event: RunnerEvent): string {
     case 'log':
       return `log ${event.text}`
     case 'needs-consent':
-      return `needs-consent ${event.sha256}\t${event.install}\t${event.uninstall}\t${event.keys}`
+      return `needs-consent ${[event.sha256, event.install, event.uninstall, event.keys, ...event.permissions].join('\t')}`
     case 'done':
       return event.version === undefined ? `done ${event.name}` : `done ${event.name} ${event.version}`
     case 'missing':
@@ -203,7 +309,10 @@ export function parseEvent(line: string): RunnerEvent {
   const progress = /^progress (\d+) (\d+)(?: (.*))?$/.exec(line)
   if (progress !== null) return { kind: 'progress', done: Number(progress[1]), total: Number(progress[2]), label: progress[3] ?? '' }
   const consent = /^needs-consent (\S+)\t([^\t]*)\t([^\t]*)(?:\t(.*))?$/.exec(line)
-  if (consent !== null) return { kind: 'needs-consent', sha256: consent[1] as string, install: consent[2] as string, uninstall: consent[3] as string, keys: consent[4] ?? '' }
+  if (consent !== null) {
+    const [keys = '', ...permissions] = (consent[4] ?? '').split('\t')
+    return { kind: 'needs-consent', sha256: consent[1] as string, install: consent[2] as string, uninstall: consent[3] as string, keys, permissions: permissions.filter((item) => item !== '') }
+  }
   const done = /^done (\S+)(?: (\S+))?$/.exec(line)
   if (done !== null) return { kind: 'done', name: done[1] as string, ...(done[2] === undefined ? {} : { version: done[2] }) }
   const missing = /^missing (\S+)$/.exec(line)

package/src/register.ts

@@ -1,5 +1,6 @@
-import type { Args, EngineInterface, EventResult, Frozen, Next, On, ToolCallArgs } from 'claude-code'
+import type { Args, EngineInterface, EventResult, Frozen, Next, On, PluginOptions, ToolCallArgs } from 'claude-code'
 import type { ModDefinition } from './mod.js'
+import type { Options } from './options.js'
 import type { Claude } from './runtime/claude.js'
 import type { RoutedEvent } from './runtime/hooks.js'
 import { createLifecycle, readPlugin, type Lifecycle } from './runtime/lifecycle.js'
@@ -8,6 +9,12 @@ let lifecycle: Lifecycle<object>
 
 let checksPermissions = false
 
+let registered: ModDefinition<object> | undefined
+
+export function registeredMod(): ModDefinition<object> | undefined {
+  return registered
+}
+
 async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.start'>>, passOn: Next<'session.start'>): Promise<EventResult<'session.start'>> {
   const claude: Claude = {
     plugin: { name: $.plugin.name, root: $.plugin.root },
@@ -37,6 +44,7 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
     },
     http: { fetch: (url, init) => $.http.fetch(url, init) },
     settings: { read: (args) => $.settings.read(args) },
+    config: { list: () => $.config.list(), set: (args) => $.config.set(args) },
     store: {
       get: (key) => $.store.get(key),
       set: (key, value) => $.store.set(key, value),
@@ -81,9 +89,10 @@ function routeToMod<N extends RoutedEvent>(_$: EngineInterface, eventInput: Froz
   return lifecycle.route(passOn.event, eventInput, (passed: unknown) => passOn(passed as Args<N>) as Promise<EventResult<N>>)
 }
 
-export function registerMod<State extends object>(addHook: On, definition: ModDefinition<State>): void {
+export function registerMod<State extends object, Declared extends Options>(addHook: On, definition: ModDefinition<State, string, Declared>, options: PluginOptions): void {
   checksPermissions = false
-  lifecycle = createLifecycle(definition, () => checksPermissions)
+  registered = definition as ModDefinition<object>
+  lifecycle = createLifecycle(definition, () => checksPermissions, options)
   addHook('session.start', startMod)
   addHook('classic.SessionStart', routeToMod)
   addHook('classic.SessionEnd', routeToMod)

package/src/runtime/claude.ts

@@ -6,6 +6,7 @@ import type {
   EngineInterface,
   AskOptions,
   CommandSpec,
+  ConfigRow,
   ElementTable,
   FsEntry,
   FsStat,
@@ -64,6 +65,7 @@ export type Claude = {
   }
   readonly http: { fetch(url: string, init?: HttpInit): Promise<HttpResponse> }
   readonly settings: { read(args?: SettingsReadArgs): Promise<Settings> }
+  readonly config: { list(): Promise<ConfigRow[]>; set: EngineInterface['config']['set'] }
   readonly store: {
     get(key: string): Promise<unknown>
     set(key: string, value: unknown): Promise<void>

package/src/runtime/grants.ts

@@ -0,0 +1,306 @@
+import { permissionWords } from '../records.js'
+import { relativePath } from '../utils/paths.js'
+import type { Claude } from './claude.js'
+import type { RoutedEvent } from './hooks.js'
+
+export type Grants = {
+  readonly name: string
+  readonly declared: readonly string[]
+  readonly granted: () => ReadonlySet<string>
+  readonly refresh: () => Promise<void>
+  readonly home: string | undefined
+  readonly configRoot: string | undefined
+  readonly projectRoot: () => string
+  readonly freeFolders: () => readonly string[]
+}
+
+export class PermissionRefused extends Error {}
+
+const configFiles: readonly string[] = ['.claude/settings.json', '.claude/settings.local.json', '.mcp.json']
+
+const startsTurns: readonly string[] = ['CronCreate']
+
+const ownSchedule: readonly string[] = ['CronDelete', 'CronList']
+
+async function checkGrant(grants: Grants, call: string, item: string | undefined): Promise<void> {
+  if (item === undefined) return
+  await grants.refresh()
+  if (!isCovered(grants.granted(), item, grants.home)) throw new PermissionRefused(refusal(grants, call, item))
+}
+
+export function checkWrite(grants: Grants, call: string, path: string): Promise<void> {
+  return checkGrant(grants, call, writeItem(grants, path))
+}
+
+export function checkingGrants(claude: Claude, grants: Grants): Claude {
+  const gate = (call: string, item: string | undefined) => checkGrant(grants, call, item)
+  return {
+    ...claude,
+    process: {
+      async run(argv, init) {
+        await gate(`process.run(${argv.join(' ')})`, `run:${programOf(argv)}`)
+        return claude.process.run(argv, init)
+      },
+      spawn(request) {
+        const started = gate(`process.spawn(${request.argv.join(' ')})`, `run:${programOf(request.argv)}`).then(() => claude.process.spawn(request))
+        return spawned(started)
+      },
+    },
+    fs: {
+      ...claude.fs,
+      async read(path) {
+        await gate(`fs.read(${path})`, readItem(grants, path))
+        return claude.fs.read(path)
+      },
+      async write(path, text) {
+        await gate(`fs.write(${path})`, writeItem(grants, path))
+        return claude.fs.write(path, text)
+      },
+    },
+    http: {
+      async fetch(url, init) {
+        await gate(`http.fetch(${url})`, `network:${init?.socketPath ?? hostOf(url)}`)
+        return claude.http.fetch(url, init)
+      },
+    },
+    config: {
+      ...claude.config,
+      set: (async (args: Parameters<Claude['config']['set']>[0]) => {
+        await gate('config.set', 'config')
+        return claude.config.set(args)
+      }) as Claude['config']['set'],
+    },
+    session: {
+      ...claude.session,
+      messages: (async (...args: Parameters<Claude['session']['messages']>) => {
+        await gate('session.messages', 'conversation')
+        return claude.session.messages(...args)
+      }) as Claude['session']['messages'],
+      append: (async (args: Parameters<Claude['session']['append']>[0]) => {
+        await gate('session.append', 'prompt')
+        return claude.session.append(args)
+      }) as Claude['session']['append'],
+    },
+    prompt: {
+      submit: (async (args: Parameters<Claude['prompt']['submit']>[0]) => {
+        await gate('session.submit', 'prompt')
+        return claude.prompt.submit(args)
+      }) as Claude['prompt']['submit'],
+    },
+    model: {
+      complete: (async (...args: Parameters<Claude['model']['complete']>) => {
+        await gate('model.complete', 'model')
+        return claude.model.complete(...args)
+      }) as Claude['model']['complete'],
+    },
+    agent: {
+      ...claude.agent,
+      async spawn(args) {
+        await gate('agent.spawn', 'agents')
+        return claude.agent.spawn(args)
+      },
+    },
+    tool: {
+      ...claude.tool,
+      call: (async (input: Parameters<Claude['tool']['call']>[0]) => {
+        const item = startsTurns.includes(input.tool) ? 'prompt' : ownSchedule.includes(input.tool) ? undefined : 'tools'
+        await gate(`tool.call(${input.tool})`, item)
+        return claude.tool.call(input)
+      }) as Claude['tool']['call'],
+    },
+  }
+}
+
+type Stream = ReturnType<Claude['process']['spawn']>
+
+function spawned(started: Promise<Stream>): Stream {
+  const result = started.then((stream) => stream.result)
+  result.catch(() => undefined)
+  const stream = {
+    next: async () => (await started).next(),
+    async return(value: never) {
+      const running = await started.catch(() => undefined)
+      return (await running?.return?.(value)) ?? { done: true as const, value }
+    },
+    [Symbol.asyncIterator]: () => stream,
+    result,
+  }
+  return stream as unknown as Stream
+}
+
+export function itemOf(name: string, value?: string): string {
+  return value === undefined ? name : `${name}:${value}`
+}
+
+export function isCovered(granted: ReadonlySet<string>, item: string, home: string | undefined): boolean {
+  if (granted.has(item)) return true
+  const split = item.indexOf(':')
+  if (split === -1) return false
+  const name = item.slice(0, split)
+  const target = expanded(item.slice(split + 1), home)
+  const values = [...granted].filter((each) => each.startsWith(`${name}:`)).map((each) => expanded(each.slice(name.length + 1), home))
+  if (name === 'run') return values.includes('*') || values.includes(target)
+  if (name === 'files') return values.some((each) => relativePath(each, target) !== undefined)
+  return values.includes(target)
+}
+
+function readItem(grants: Grants, path: string): string | undefined {
+  if (grants.configRoot === undefined) return undefined
+  return relativePath(`${grants.configRoot}/projects`, path) === undefined ? undefined : 'conversation'
+}
+
+function writeItem(grants: Grants, path: string): string | undefined {
+  const root = grants.projectRoot()
+  if (configFiles.some((file) => `${root}/${file}` === path)) return 'config'
+  if (grants.freeFolders().some((folder) => relativePath(folder, path) !== undefined)) return undefined
+  return `files:${path}`
+}
+
+export function refusal(grants: Pick<Grants, 'name' | 'declared' | 'home'>, call: string, item: string): string {
+  const { name } = grants
+  if (isCovered(new Set(grants.declared), item, grants.home)) return `${name} calls ${call} without your grant to "${permissionWords(item)}". Turn it on in /mods ${name}.`
+  return `${name} calls ${call}, which needs ${declaration(item, grants.home)} in package.json "cmod".`
+}
+
+function declaration(item: string, home: string | undefined): string {
+  const split = item.indexOf(':')
+  if (split === -1) return `"permissions": { "${item}": true }`
+  const name = item.slice(0, split)
+  const target = item.slice(split + 1)
+  const fromHome = home === undefined ? undefined : relativePath(home, target)
+  const shown = name !== 'run' && fromHome !== undefined ? `~/${fromHome}` : target
+  return `"permissions": { "${name}": ["${shown}"] }`
+}
+
+type Fields = Record<string, unknown>
+
+const classicParts: Readonly<Record<string, string>> = {
+  additionalContext: 'prompt',
+  initialUserMessage: 'prompt',
+  suppressOriginalPrompt: 'prompt',
+  updatedToolOutput: 'prompt',
+  updatedMCPToolOutput: 'prompt',
+  updatedInput: 'tools',
+  retry: 'approve',
+}
+
+const blocksKeepWorking: readonly RoutedEvent[] = ['classic.Stop', 'classic.PostToolUse']
+
+const reservedToolKeys: readonly string[] = ['tool', 'tool_use_id']
+
+export type AnswerCheck = {
+  readonly plugin: string
+  isGranted(item: string): boolean
+  dropped(item: string, part: string): void
+}
+
+export function checksAnswers(event: RoutedEvent): boolean {
+  return event.startsWith('classic.') || event === 'tool.check' || event === 'tool.call' || event === 'prompt.context' || event === 'prompt.submit'
+}
+
+export function passedDown(event: RoutedEvent, original: unknown, passed: unknown, check: AnswerCheck): unknown {
+  if (passed === original) return passed
+  if (event === 'tool.call') {
+    if (sameExcept(original, passed, reservedToolKeys) || check.isGranted('tools')) return passed
+    check.dropped('tools', 'a changed tool input')
+    return original
+  }
+  if (event === 'prompt.context' || event === 'prompt.submit') {
+    if (same(original, passed) || check.isGranted('prompt')) return passed
+    check.dropped('prompt', event === 'prompt.submit' ? 'a rewritten prompt' : 'changed context')
+    return original
+  }
+  return passed
+}
+
+export async function checkedAnswer(event: RoutedEvent, e: unknown, answer: unknown, below: () => Promise<unknown>, check: AnswerCheck): Promise<unknown> {
+  if (!isFields(answer)) return answer
+  if (event === 'tool.check') return decided(answer['decision'], answer, below, check)
+  if (event === 'classic.PermissionRequest') {
+    const decision = isFields(answer['decision']) ? answer['decision']['behavior'] : undefined
+    return decided(decision, answer, below, check)
+  }
+  if (event.startsWith('classic.')) return classicAnswer(event, answer, below, check)
+  if (event === 'tool.call') {
+    if (answer['deny'] !== undefined || check.isGranted('prompt')) return answer
+    const tool = isFields(e) ? e['tool'] : undefined
+    if (typeof tool === 'string' && tool.startsWith(`mcp__${check.plugin}__`)) {
+      if (answer['context'] === undefined) return answer
+      check.dropped('prompt', 'context after a tool call')
+      const { context: _context, ...rest } = answer
+      return rest
+    }
+    const theirs = await below()
+    if (same(answer, theirs)) return answer
+    check.dropped('prompt', same(contextOf(answer), contextOf(theirs)) ? 'a changed tool result' : 'context after a tool call')
+    return theirs
+  }
+  if (event === 'prompt.submit' && answer['drop'] !== undefined) return answer
+  if (event === 'prompt.context' || event === 'prompt.submit') {
+    if (check.isGranted('prompt')) return answer
+    const theirs = await below()
+    if (same(answer, theirs)) return answer
+    check.dropped('prompt', event === 'prompt.submit' ? 'a rewritten prompt' : 'changed context')
+    return theirs
+  }
+  return answer
+}
+
+async function decided(decision: unknown, answer: Fields, below: () => Promise<unknown>, check: AnswerCheck): Promise<unknown> {
+  if ((decision !== 'allow' && decision !== 'ask') || check.isGranted('approve')) return answer
+  const theirs = await below()
+  if (same(answer, theirs)) return answer
+  check.dropped('approve', `${decision} on a tool call`)
+  return theirs
+}
+
+async function classicAnswer(event: RoutedEvent, answer: Fields, below: () => Promise<unknown>, check: AnswerCheck): Promise<unknown> {
+  const blocks = blocksKeepWorking.includes(event) ? ([['block', 'prompt']] as const) : []
+  const parts = [...Object.entries(classicParts), ...blocks].filter(([part, item]) => answer[part] !== undefined && !check.isGranted(item))
+  if (parts.length === 0) return answer
+  const theirs = await below()
+  const kept: Fields = { ...answer }
+  const theirFields = isFields(theirs) ? theirs : {}
+  for (const [part, item] of parts) {
+    if (same(answer[part], theirFields[part])) continue
+    check.dropped(item, part)
+    if (theirFields[part] === undefined) delete kept[part]
+    else kept[part] = theirFields[part]
+  }
+  return kept
+}
+
+function contextOf(answer: unknown): unknown {
+  return isFields(answer) ? answer['context'] : undefined
+}
+
+function same(left: unknown, right: unknown): boolean {
+  return left === right || JSON.stringify(left) === JSON.stringify(right)
+}
+
+function sameExcept(left: unknown, right: unknown, keys: readonly string[]): boolean {
+  if (!isFields(left) || !isFields(right)) return same(left, right)
+  const without = (fields: Fields) => Object.fromEntries(Object.entries(fields).filter(([key]) => !keys.includes(key)))
+  return same(without(left), without(right))
+}
+
+function isFields(value: unknown): value is Fields {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function programOf(argv: readonly string[]): string {
+  const command = argv[0] ?? ''
+  return command.slice(command.lastIndexOf('/') + 1)
+}
+
+function hostOf(url: string): string {
+  try {
+    return new URL(url).hostname
+  } catch {
+    return url
+  }
+}
+
+function expanded(path: string, home: string | undefined): string {
+  return path.startsWith('~/') && home !== undefined ? `${home}${path.slice(1)}` : path
+}