@cmodjs/core 2.0.0 → 2.1.0

package/src/runtime/conversations.ts

@@ -9,7 +9,7 @@ import { GoalChange } from '../session/goal/goal.js'
 import { receivedMatcher } from '../utils/matcher.js'
 import { ifMissing } from '../utils/paths.js'
 import { formatExit, messageOf } from '../utils/text.js'
-import { foldAnswers, installBefore, relayOf, type Place } from './before.js'
+import { foldBefore, installBefore, relayOf, type Place } from './before.js'
 import type { Claude } from './claude.js'
 import { cmodPluginName } from './dependencies.js'
 import { readLines, runCmod } from './programs.js'
@@ -80,7 +80,7 @@ export function serveConversations({ claude, router, store, project, report }: {
   router.add('classic.StopFailure', async (e, next) => endTurn({ reason: 'error', failure: { type: String(e.error), text: e.error_details ?? e.last_assistant_message ?? String(e.error) } })(await next(e)))
   router.add('classic.SubagentStop', async (e, next) => endTurn({ reason: 'answer', ...(e.last_assistant_message === undefined ? {} : { answer: e.last_assistant_message }) }, e.agent_id)(await next(e)))
 
-  const json = async <Value>(args: readonly string[]): Promise<Value> => JSON.parse(await runCmod(claude, [...args, '--json', '--project', project()], session === '' ? await claude.session.id() : session)) as Value
+  const json = async <Value>(args: readonly string[]): Promise<Value> => JSON.parse(await runCmod(claude, [...args, '--json', '--project', project()], await claude.session.id())) as Value
 
   const isGranted = async (caller: string | undefined, item: string) => {
     if (caller === cmodPluginName) return true
@@ -90,6 +90,7 @@ export function serveConversations({ claude, router, store, project, report }: {
     return (parseConsent(JSON.parse(text), path)[caller] ?? []).includes(item)
   }
 
+
   const ended = (id: string) => new Error(`session ${id} has ended`)
 
   const isRunning = async (id: string) => (await json<SessionData[]>(['history', 'sessions', '--running', '--all'])).some((each) => each.id === id)
@@ -144,17 +145,36 @@ export function serveConversations({ claude, router, store, project, report }: {
     if (sent.isDelivered !== true) throw ended(to)
   }
 
+  const waitingOn = new Map<Asked, string>()
+  let liveness: { cancel(): void } | undefined
+  let isChecking = false
+  const checkLiveness = async () => {
+    if (isChecking) return
+    isChecking = true
+    try {
+      const waiting = [...waitingOn]
+      const running = new Set((await json<SessionData[]>(['history', 'sessions', '--running', '--all'])).map((each) => each.id))
+      for (const [settle, to] of waiting) if (!running.has(to)) settle.reject(ended(to))
+    } finally {
+      isChecking = false
+    }
+  }
+  const watchLife = (settle: Asked, to: string) => {
+    waitingOn.set(settle, to)
+    liveness ??= claude.clock.every(livenessMs, () => void checkLiveness().catch((error: unknown) => report('liveness', 'Could not check which sessions still run', error)))
+    return {
+      cancel() {
+        waitingOn.delete(settle)
+        if (waitingOn.size > 0) return
+        liveness?.cancel()
+        liveness = undefined
+      },
+    }
+  }
+
   const ask = (to: string, relay: Question, deadlineMs?: number) =>
     new Promise<unknown>((resolve, reject) => {
       const id = `${session}:${(asks += 1)}`
-      const timer =
-        deadlineMs === undefined
-          ? claude.clock.every(livenessMs, () => {
-              void isRunning(to).then((isLive) => {
-                if (!isLive) settle.reject(ended(to))
-              })
-            })
-          : claude.clock.after(deadlineMs, () => settle.reject(new Error(`session ${to} did not answer within ${deadlineMs / 1000} s`)))
       const settle: Asked = {
         resolve(value) {
           if (asked.delete(id)) timer.cancel()
@@ -165,6 +185,7 @@ export function serveConversations({ claude, router, store, project, report }: {
           reject(error)
         },
       }
+      const timer = deadlineMs === undefined ? watchLife(settle, to) : claude.clock.after(deadlineMs, () => settle.reject(new Error(`session ${to} did not answer within ${deadlineMs / 1000} s`)))
       asked.set(id, settle)
       post(to, { ...relay, id, from: session }).catch((error: unknown) => settle.reject(error instanceof Error ? error : new Error(messageOf(error))))
     })
@@ -244,7 +265,7 @@ export function serveConversations({ claude, router, store, project, report }: {
         return deciders(event).length > 0
       },
       decide: (event, change) =>
-        foldAnswers(
+        foldBefore(
           event,
           change,
           deciders(event).map((watcher) => (latest: SessionChange) => (watcher.from === session ? askHere(watcher.mod, event, latest) : askAway(watcher, event, latest))),
@@ -556,7 +577,7 @@ export function serveConversations({ claude, router, store, project, report }: {
       const action = String(request['action']) as Act
       const task = typeof request['task'] === 'string' ? request['task'] : undefined
       if (!isAct(action)) throw new Error(`cmod takes no action named ${action}.`)
-      if (target === session) return perform(caller, action, request['input'], task)
+      if (target === (await claude.session.id())) return perform(caller, action, request['input'], task)
       return actElsewhere(caller, target, action, request['input'], task)
     },
   }
@@ -572,7 +593,8 @@ export function serveConversations({ claude, router, store, project, report }: {
       const method = methods[e.method]
       if (method === undefined) return undefined
       const input = isObject(e.input) ? e.input : {}
-      if (e.method !== conversationMethods.act && input['session'] !== session && !(await isGranted(e.caller, 'conversation'))) return { deny: `${e.caller ?? 'A mod'} reads your conversations without your grant. Turn it on in /mods ${e.caller ?? ''}.`.trim() }
+      const isDropping = (e.method === conversationMethods.subscribe || e.method === conversationMethods.watchBefore) && Array.isArray(input['subscriptions']) && input['subscriptions'].length === 0
+      if (e.method !== conversationMethods.act && !isDropping && input['session'] !== (await claude.session.id()) && !(await isGranted(e.caller, 'conversation'))) return { deny: `${e.caller ?? 'A mod'} reads your conversations without your grant. Turn it on in /mods ${e.caller ?? ''}.`.trim() }
       try {
         return { value: await method(input, e.caller) }
       } catch (error) {

package/src/runtime/engine.ts

@@ -8,6 +8,7 @@ export type Engine = {
   readonly router: Router
   readonly toolCalls: ToolCalls
   readonly report: (failure: Failure) => void
+  readonly hasPermissionCheck: () => boolean
 }
 
 const engines = new WeakMap<object, Engine>()

package/src/runtime/hooks.ts

@@ -1,4 +1,4 @@
-import type { ClassicHookEvent, ClassicHookInputs, PermissionRequestDecision } from 'claude-code'
+import type { ClassicHookEvent, ClassicHookInputs } from 'claude-code'
 import { configFolders } from '../records.js'
 import type { Claude } from './claude.js'
 import type { RoutedHook } from './router.js'
@@ -10,26 +10,9 @@ import { messageOf } from '../utils/text.js'
 
 export type Hook = Exclude<ClassicHookEvent, 'PreToolUse'>
 
-export type HookAnswer = {
-  decision?: 'block'
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName?: Hook
-    additionalContext?: string
-    permissionDecision?: 'deny' | 'ask'
-    permissionDecisionReason?: string
-    sessionTitle?: string
-    initialUserMessage?: string
-    watchPaths?: string[]
-    reloadSkills?: boolean
-    decision?: PermissionRequestDecision
-    retry?: boolean
-    displayContent?: string
-    worktreePath?: string
-  }
-}
+export type HookFields = Readonly<Record<string, unknown>>
 
-export type HookListener<H extends Hook> = (input: ClassicHookInputs[H]) => HookAnswer | void | Promise<HookAnswer | void>
+export type HookListener<H extends Hook> = (input: ClassicHookInputs[H]) => HookFields | undefined | Promise<HookFields | undefined>
 
 export type RoutedEvent =
   | `classic.${Hook}`
@@ -52,63 +35,18 @@ export type RoutedEvent =
   | 'agent.spawn'
   | 'turn.start'
 
-export const permissionEvents: readonly RoutedEvent[] = ['tool.check', 'classic.PermissionRequest']
-
-type ClassicFields = Record<string, unknown>
-
 type CallFiles = { readonly read: string[]; readonly changed: string[] }
 
-const flags: readonly string[] = ['reloadSkills', 'retry']
-
-const readFields: Record<Hook, readonly string[]> = {
-  Setup: ['additionalContext'],
-  SessionStart: ['additionalContext', 'initialUserMessage', 'sessionTitle', 'watchPaths', 'reloadSkills'],
-  SessionEnd: [],
-  UserPromptSubmit: ['additionalContext', 'sessionTitle'],
-  UserPromptExpansion: ['additionalContext'],
-  InstructionsLoaded: [],
-  ConfigChange: [],
-  DirectoryAdded: [],
-  PreModelSwitch: ['permissionDecision', 'permissionDecisionReason'],
-  PostModelSwitch: ['additionalContext'],
-  PermissionRequest: ['decision'],
-  PermissionDenied: ['retry'],
-  PostToolUse: ['additionalContext'],
-  PostToolUseFailure: ['additionalContext'],
-  PostToolBatch: ['additionalContext'],
-  MessageDisplay: ['displayContent'],
-  SubagentStart: ['additionalContext'],
-  SubagentStop: ['additionalContext'],
-  TaskCreated: [],
-  TaskCompleted: [],
-  TeammateIdle: [],
-  Elicitation: [],
-  ElicitationResult: [],
-  Notification: [],
-  PreCompact: [],
-  PostCompact: [],
-  Stop: ['additionalContext'],
-  StopFailure: [],
-  CwdChanged: [],
-  FileChanged: [],
-  WorktreeCreate: ['worktreePath'],
-  WorktreeRemove: [],
-}
-
-export function classicHook<H extends Hook>(name: string, event: H, hook: HookListener<H>, report: (failure: Failure) => void): RoutedHook<RoutedEvent> {
+export function classicHook<H extends Hook>(event: H, hook: HookListener<H>, report: (failure: Failure) => void): RoutedHook<RoutedEvent> {
   const routed = async (e: unknown, next: (e: unknown) => Promise<unknown>) => {
     const ours = await Promise.resolve()
-      .then(async () => {
-        const answer = await hook(e as ClassicHookInputs[H])
-        return answer === undefined ? undefined : classicResult(event, answer)
-      })
-      .catch((error: unknown): ClassicFields | undefined => {
-        if (event === 'PermissionRequest') return { decision: { behavior: 'deny', message: `${name}: the ${event} listener failed: ${messageOf(error)}` } }
+      .then(() => hook(e as ClassicHookInputs[H]))
+      .catch((error: unknown) => {
         report({ id: `hook:${event}`, message: `The ${event} listener failed`, error })
         return undefined
       })
     if (ours === undefined) return next(e)
-    return mergeClassic((await next(e)) as ClassicFields, ours)
+    return mergeClassic((await next(e)) as HookFields, ours)
   }
   return routed as unknown as RoutedHook<RoutedEvent>
 }
@@ -134,9 +72,11 @@ export function userSkillHook(claude: Claude): RoutedHook<'skill.prompt'> {
   }
 }
 
-export async function callFiles(name: string, claude: Claude, use: CallBase, cwd: string): Promise<CallFiles> {
+export type HomeFolders = { readonly home: string | undefined; readonly configRoot: string | undefined }
+
+export async function callFiles(name: string, claude: Claude, folders: Promise<HomeFolders>, use: CallBase, cwd: string): Promise<CallFiles> {
   try {
-    const [home, configRoot] = await Promise.all([claude.env.home(), claude.env.configHome()])
+    const { home, configRoot } = await folders
     if (home === undefined) throw new Error('HOME is not set, so ~ in a path has no meaning.')
     const { shell, reads, writes } = callEffects(use, { cwd, home, ...(configRoot === undefined ? {} : { configRoot }), fs: claude.fs })
     const known = (accesses: FileAccess[]) => accesses.map(({ path }) => path).filter((path) => shell === undefined || !dynamicPattern.test(path))
@@ -152,21 +92,8 @@ export async function callFiles(name: string, claude: Claude, use: CallBase, cwd
   }
 }
 
-function classicResult(event: Hook, answer: HookAnswer): ClassicFields {
-  const result: ClassicFields = {}
-  if (answer.decision === 'block') result['block'] = answer.reason ?? ''
-  const specific = answer.hookSpecificOutput ?? {}
-  for (const [field, value] of Object.entries(specific)) {
-    if (field === 'hookEventName' || (value === false && flags.includes(field))) continue
-    if (!readFields[event].includes(field)) throw new Error(`it answered ${field}, which ${event} does not read.`)
-    result[field] = field === 'additionalContext' ? [value] : value
-  }
-  return result
-}
-
-
-function mergeClassic(below: ClassicFields, ours: ClassicFields): ClassicFields {
-  const merged: ClassicFields = { ...below, ...ours }
+function mergeClassic(below: HookFields, ours: HookFields): HookFields {
+  const merged: Record<string, unknown> = { ...below, ...ours }
   const context = [...((below['additionalContext'] as string[] | undefined) ?? []), ...((ours['additionalContext'] as string[] | undefined) ?? [])]
   if (context.length > 0) merged['additionalContext'] = context
   return merged

package/src/runtime/lifecycle.ts

@@ -4,7 +4,7 @@ import type { Allowed, FileChange, Disposable, Imports, Mod, ModDefinition, Pane
 import type { Options, OptionValues } from '../options.js'
 import { changelogPage, consentPath, dataFolder, finishStepsMethod, isAtLeast, marketplaceOf, oldestCmodFor, openPageMethod, parseConsent, pendingStepsMethod, parseEvent, permissionWords, readRecord, readSteps, recordPath, scriptsSha256, settingsPagesMethod, storeFolder, updatesToTurnOn, type ReadFile, type RunnerEvent, type Steps } from '../records.js'
 import { homePrefix, ifMissing, relativePath } from '../utils/paths.js'
-import { firstLine, formatExit, listed, messageOf } from '../utils/text.js'
+import { firstLine, formatExit, messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
 import { beforeDeadline } from './deadline.js'
 import { announcedOf, announcementMs, announcementOf } from './announce.js'
@@ -12,7 +12,8 @@ import { bind } from './bound.js'
 import { serveConversations } from './conversations.js'
 import { answerCall, answeringOwnCalls, cmodPluginName, dependencyCalls, withBareRefusals } from './dependencies.js'
 import { keepEngine } from './engine.js'
-import { classicHook, permissionEvents, userSkillHook, type Hook, type HookListener, type RoutedEvent } from './hooks.js'
+import { classicHook, userSkillHook, type Hook, type HookListener, type RoutedEvent } from './hooks.js'
+import type { PermissionRoutes } from './permission-check.js'
 import { checkedAnswer, checkingGrants, checkSettings, checksAnswers, checkWrite, isCovered, itemOf, passedDown, programAddresses, type AnswerCheck, type Grants } from './grants.js'
 import { cmodError, lastLineOf, locatingPrograms, readLines, type Programs } from './programs.js'
 import { createModFiles, resolvedPath, type Places } from './metadata.js'
@@ -63,7 +64,7 @@ type ModRuntime = {
   readonly steps: Steps
   readonly granted: ReadonlySet<string>
   readonly refreshGrants: () => Promise<void>
-  readonly checksPermissions: () => boolean
+  readonly permissionRoutes: () => PermissionRoutes | undefined
   readonly options: PluginOptions
 }
 
@@ -85,6 +86,8 @@ const cmodCheckMs = 1000
 
 const cmodWaitMs = 60_000
 
+const cmodSlowCheckMs = 10_000
+
 const startHoldMs = (10_000 satisfies HookBudget['ms']) - 1_000
 
 const dependencyCallMs = 30_000
@@ -153,7 +156,7 @@ async function cmodVersion(claude: Claude): Promise<string | undefined> {
 
 export function createLifecycle<State extends object, Declared extends Options = Options>(
   definition: ModDefinition<State, string, Declared>,
-  checksPermissions: () => boolean = () => true,
+  permissionRoutes: () => PermissionRoutes | undefined = () => undefined,
   options: PluginOptions = {},
   asksPerson = true,
 ): Lifecycle<State> {
@@ -319,7 +322,7 @@ export function createLifecycle<State extends object, Declared extends Options =
   const activate = async (): Promise<void> => {
     if (runtime === undefined || plugin === undefined) return
     const activeRouter = createRouter()
-    const active = await createMod(definition, { ...runtime, router: activeRouter, dataFolder: dataFolder(plugin.store, plugin.name), store: plugin.store, steps: plugin.steps, granted, refreshGrants, checksPermissions, options: pluginOptions }).catch(async (error: unknown) => {
+    const active = await createMod(definition, { ...runtime, router: activeRouter, dataFolder: dataFolder(plugin.store, plugin.name), store: plugin.store, steps: plugin.steps, granted, refreshGrants, permissionRoutes, options: pluginOptions }).catch(async (error: unknown) => {
       if (error instanceof MissingOptions && (await askOptions(error))) return undefined
       fail(messageOf(error), error instanceof MissingOptions ? `Set ${error.keys.length === 1 ? 'it' : 'them'} in /config.` : undefined, begin)
       throw error
@@ -335,12 +338,18 @@ export function createLifecycle<State extends object, Declared extends Options =
     void runSteps(active.mod).catch((error: unknown) => toastFailure({ id: 'cmod:steps', message: 'Its installer stopped', error }))
     const missed = missedSessionStart
     missedSessionStart = undefined
-    const lateAnswer = missed === undefined ? {} : await activeRouter.dispatch('classic.SessionStart', missed, async () => ({})).catch((error: unknown) => {
+    const replay = (e: Frozen<Args<'classic.SessionStart'>>) => (definition.name === cmodPluginName ? activeRouter.dispatch('classic.SessionStart', e, async () => ({})) : checkedRoute('classic.SessionStart', e, async () => ({})))
+    const lateAnswer = missed === undefined ? {} : await replay(missed).catch((error: unknown) => {
       toastFailure({ id: 'classic.SessionStart', message: 'The SessionStart hook failed', error })
       return {}
     })
-    if (Object.keys(lateAnswer).length > 0) {
-      runtime.claude.ui.log(`${definition.name} started after Claude Code's SessionStart, so Claude Code did not read the answer of its SessionStart hooks.`, { to: 'debug' })
+    const { additionalContext, ...unread } = lateAnswer as { readonly additionalContext?: readonly string[] } & Record<string, unknown>
+    for (const text of additionalContext ?? []) {
+      const added = await runtime.claude.session.append({ message: { type: 'user', content: [{ type: 'text', text }] } })
+      if (added.deny !== undefined) runtime.claude.ui.log(`${definition.name}: Claude Code refused its SessionStart note: ${added.deny}`, { to: 'debug' })
+    }
+    if (Object.keys(unread).length > 0) {
+      runtime.claude.ui.log(`${definition.name} started after Claude Code's SessionStart, so Claude Code did not read ${Object.keys(unread).join(', ')} from its SessionStart hooks.`, { to: 'debug' })
     }
     const version = plugin.version ?? ''
     const announced = announcedOf(await runtime.claude.store.get(announcedKey))
@@ -422,27 +431,31 @@ export function createLifecycle<State extends object, Declared extends Options =
       timer.cancel()
       longWait.cancel()
     }
-    const timer = claude().clock.every(cmodCheckMs, () => {
-      check ??= cmodVersion(claude())
-        .then((version) => {
-          check = undefined
-          latest = version
-          if (!fits(version)) return
-          stop()
-          return install()
-        })
-        .catch((error: unknown) => {
-          stop()
-          report(error)
-        })
-    })
-    const longWait = claude().clock.after(cmodWaitMs, () =>
+    const poll = (ms: number) =>
+      claude().clock.every(ms, () => {
+        check ??= cmodVersion(claude())
+          .then((version) => {
+            check = undefined
+            latest = version
+            if (!fits(version)) return
+            stop()
+            return install()
+          })
+          .catch((error: unknown) => {
+            stop()
+            report(error)
+          })
+      })
+    let timer = poll(cmodCheckMs)
+    const longWait = claude().clock.after(cmodWaitMs, () => {
+      timer.cancel()
+      timer = poll(cmodSlowCheckMs)
       installing(
         latest === undefined
           ? "Still waiting for cmod to download cmod. See cmod's own line."
           : `PATH finds cmod ${latest}, and ${definition.name} needs cmod ${oldestCmodFor(plugin?.steps ?? {})} or later. Run npm i -g @cmodjs/cli, or put ~/.local/bin ahead of the old cmod on PATH.`,
-      ),
-    )
+      )
+    })
   }
 
   const bootstrap = async (root: string) => {
@@ -595,7 +608,10 @@ export function createLifecycle<State extends object, Declared extends Options =
       const isCallToThisMod = event === 'cmod.call' && (e as Frozen<Args<'cmod.call'>>).to === definition.name
       if (event === 'cmod.call' && !isCallToThisMod) return next(e)
       await (event === 'classic.SessionStart' || isCallToThisMod ? holdUntilStarted() : whenActive())
-      if (event === 'classic.SessionStart' && phase !== 'active') missedSessionStart = e as Frozen<Args<'classic.SessionStart'>>
+      if (event === 'classic.SessionStart' && phase !== 'active') {
+        missedSessionStart = e as Frozen<Args<'classic.SessionStart'>>
+        return next(e)
+      }
       if (isCallToThisMod && phase !== 'active') {
         const isStopped = phase === 'declined' || phase === 'failed'
         return { deny: isStopped ? `${definition.name} is not set up. Its toast says why.` : `${definition.name} is installing. Try again when it's ready.` } as EventResult<N>
@@ -688,7 +704,7 @@ async function createMod<State extends object, Declared extends Options>(definit
     }))
   const modState = createState<State>({ name: definition.name, initial: definition.state ?? {}, session, root, claude, report, changed: area.changed, forkParent })
   const modOptions = createOptions({ name: definition.name, declared: definition.options ?? {}, fromClaude: runtime.options, claude, report, changed: modState.changed })
-  const hookOn = <H extends Hook>(hook: H, listener: HookListener<H>): Disposable => router.add(`classic.${hook}`, classicHook(definition.name, hook, listener, report))
+  const hookOn = <H extends Hook>(hook: H, listener: HookListener<H>): Disposable => router.add(`classic.${hook}`, classicHook(hook, listener, report))
   const expand = (path: string) => (homePrefix.test(path) ? resolvedPath(path, places) : path)
   const settingsFile = (source: 'user' | 'project' | 'local'): SettingsFile => ({
     read: () => checked.settings.read({ source }),
@@ -704,6 +720,7 @@ async function createMod<State extends object, Declared extends Options>(definit
     isGranted: (permission) => flag(permission),
     hookOn: (hook, listener) => hookOn(hook as Hook, listener as HookListener<Hook>),
     routeOn: (event, hook) => router.add(event, hook as never),
+    permissionRoutes: runtime.permissionRoutes,
   })
   let followed: Parameters<typeof client.follow>[0] | undefined
   let isSetUp = false
@@ -747,8 +764,8 @@ async function createMod<State extends object, Declared extends Options>(definit
         return hookOn('ConfigChange', async ({ source, file_path }) => {
           const change: SettingsFileChange = { source: source === 'skills' ? 'skills' : (source.replace('_settings', '') as SettingsFileChange['source']), ...(file_path === undefined ? {} : { path: file_path }) }
           if (matcher !== undefined && !matches(change, matcher)) return undefined
-          const answer = await listener(change)
-          return answer === undefined ? undefined : { decision: 'block', reason: answer.refuse }
+          const refuse = (await listener(change))?.refuse
+          return typeof refuse === 'string' ? { block: refuse } : undefined
         })
       },
     },
@@ -769,9 +786,10 @@ async function createMod<State extends object, Declared extends Options>(definit
         const watch = { paths, listener }
         watches.add(watch)
         if (watches.size === 1) {
-          hookOn('SessionStart', () => ({ hookSpecificOutput: { watchPaths: [...new Set([...watches].flatMap((each) => each.paths))] } }))
+          hookOn('SessionStart', () => ({ watchPaths: [...new Set([...watches].flatMap((each) => each.paths))] }))
           hookOn('FileChanged', ({ file_path, event }) => {
             for (const each of watches) if (each.paths.some((watched) => relativePath(watched, file_path) !== undefined)) void Promise.resolve(each.listener({ path: file_path, type: event })).catch((error: unknown) => report({ id: 'fs:onChange', message: 'The fs.onChange listener failed', error }))
+            return undefined
           })
         }
         return { dispose: () => void watches.delete(watch) }
@@ -939,7 +957,7 @@ async function createMod<State extends object, Declared extends Options>(definit
     return served ?? answerCall(definition.name, api, e)
   })
   const agents = toolCalls(claude, router)
-  keepEngine(mod, { claude: checked, router, toolCalls: agents, report })
+  keepEngine(mod, { claude: checked, router, toolCalls: agents, report, hasPermissionCheck: () => runtime.permissionRoutes() !== undefined })
   const names = new Set<string>()
   const reserveName = (type: string, name: string, taken: string): Disposable => {
     const key = `${type}:${name}`
@@ -954,10 +972,6 @@ async function createMod<State extends object, Declared extends Options>(definit
   await failsAs('the details of its session did not load', () => followCurrent(undefined))
   await failsAs('its setup function threw', () => definition.setup(mod))
   isSetUp = true
-  const permissionHooks = permissionEvents.filter((event) => router.has(event))
-  if (permissionHooks.length > 0 && !runtime.checksPermissions()) {
-    throw new Error(`it decides permissions on ${listed(permissionHooks)}, so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod`)
-  }
   await failsAs('its open panes did not load', () => area.restorePanes())
   return { mod, added, imports, raise: client.raise }
 }
@@ -965,7 +979,7 @@ async function createMod<State extends object, Declared extends Options>(definit
 function checkingKeys(claude: Claude, toast: Toast, keys: Readonly<Record<string, string>>): Claude {
   const bound = Object.entries(keys)
   if (bound.length === 0) return claude
-  const register: Claude['command']['register'] = (command) => {
+  const addCommand: Claude['command']['register'] = (command) => {
     for (const [key, commandName] of bound) {
       if (commandName === command.name && command.immediate !== true) {
         toast.warning(`${key} runs /${command.name}, which waits for Claude's turn to end`, { id: `key:${key}`, description: `It adds a row to the conversation. Give /${command.name} immediate: true.`, duration: Infinity })
@@ -973,7 +987,7 @@ function checkingKeys(claude: Claude, toast: Toast, keys: Readonly<Record<string
     }
     return claude.command.register(command)
   }
-  return { ...claude, command: { ...claude.command, register } }
+  return { ...claude, command: { ...claude.command, register: addCommand } }
 }
 
 const longestTimerMs = 2_147_483_647

package/src/runtime/permission-check.ts

@@ -0,0 +1,47 @@
+import type { Disposable } from '../mod.js'
+import type { HookFields } from './hooks.js'
+import { defined, processPayloadOf, recordOf, type HookOn, type RouteOn, type ToolCheck } from './sessions.js'
+
+export type PermissionUse = {
+  readonly raise: (method: string, payload: HookFields) => Promise<HookFields | undefined>
+  readonly hookOn: HookOn
+  readonly routeOn: RouteOn
+  readonly current: () => { readonly id: string; readonly cwd: string }
+}
+
+export type PermissionRoutes = (method: string, use: PermissionUse) => Disposable
+
+type Verdict = { readonly decision: 'allow' | 'ask' | 'deny'; readonly reason?: string; readonly rule?: string }
+
+const verdictName = (decision: Verdict['decision']) => (decision === 'deny' ? 'refuse' : decision)
+
+export const permissionRoutes: PermissionRoutes = (method, { raise, hookOn, routeOn, current }) => {
+  const isBefore = method.startsWith('before')
+  if (method.endsWith('PermissionCheck')) {
+    return routeOn('tool.check', async (e: ToolCheck, next) => {
+      const below = (await next(e)) as Verdict
+      const { id, cwd } = current()
+      const payload = { session: id, cwd, ...defined({ task: e.agentId, callId: e.tool_use_id, reason: below.reason, rule: below.rule, ceiling: e.ceiling === undefined ? undefined : verdictName(e.ceiling) }), name: e.tool, input: recordOf(e.input), decision: verdictName(below.decision) }
+      if (!isBefore) {
+        void raise(method, payload)
+        return below
+      }
+      const answer = await raise(method, payload)
+      if (answer === undefined || below.decision === 'deny') return below
+      if (typeof answer['refuse'] === 'string') return { decision: 'deny', reason: answer['refuse'] }
+      if (typeof answer['ask'] === 'string') return { decision: 'ask', reason: answer['ask'] }
+      return answer['allow'] === true ? { decision: 'allow' } : below
+    })
+  }
+  return hookOn('PermissionRequest', async (input) => {
+    const payload = processPayloadOf('PermissionRequest', input)
+    if (!isBefore) {
+      void raise(method, payload)
+      return undefined
+    }
+    const answer = await raise(method, payload)
+    if (answer === undefined) return undefined
+    if (typeof answer['refuse'] === 'string') return { decision: defined({ behavior: 'deny', message: answer['refuse'], interrupt: answer['interrupt'] }) }
+    return answer['allow'] === true ? { decision: defined({ behavior: 'allow', updatedInput: answer['input'], updatedPermissions: answer['updates'] }) } : undefined
+  })
+}

package/src/runtime/router.ts

@@ -8,7 +8,6 @@ export type RoutedHook<N extends RoutedEvent> = (e: Frozen<Args<N>>, next: Route
 
 export type Router = {
   add<N extends RoutedEvent>(event: N, hook: RoutedHook<N>): Disposable
-  has(event: RoutedEvent): boolean
   dispatch<N extends RoutedEvent>(event: N, e: Frozen<Args<N>>, next: RouterNext<N>): Promise<EventResult<N>>
 }
 
@@ -29,7 +28,6 @@ export function createRouter(): Router {
         },
       }
     },
-    has: (event) => hooks.has(event),
     dispatch<N extends RoutedEvent>(event: N, e: Frozen<Args<N>>, next: RouterNext<N>): Promise<EventResult<N>> {
       const chain = hooks.get(event)
       const call = async (index: number, current: unknown): Promise<unknown> => {