@cmodjs/core 1.6.0 → 2.0.0

package/src/runtime/conversations.ts

@@ -3,8 +3,8 @@ import { consentPath, dataFolder, isObject, parseConsent } from '../records.js'
 import { Message, rowOfAppend, type Row } from '../session/context/turn/message/message.js'
 import { Note } from '../session/context/turn/message/note.js'
 import { Person } from '../session/context/turn/message/sender.js'
-import { createConversation, emptyConversation, type Conversation, type ConversationState, type ContextData, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
-import { Session, UsageChange, type BeforeEvent, type Client, type SessionSend, type TaskStartArgs, type ToolCallArgs } from '../session/session.js'
+import { createConversation, emptyConversation, type Conversation, type ConversationState, type ContextData, type SessionChange, type SessionData, type TaskData, type TurnData, type TurnEnding } from '../session/conversation.js'
+import { Session, UsageChange, type BeforeEvent, type Surface, type SessionSend, type TaskStartArgs, type ToolCallArgs } from '../session/session.js'
 import { GoalChange } from '../session/goal/goal.js'
 import { receivedMatcher } from '../utils/matcher.js'
 import { ifMissing } from '../utils/paths.js'
@@ -14,7 +14,7 @@ import type { Claude } from './claude.js'
 import { cmodPluginName } from './dependencies.js'
 import { readLines, runCmod } from './programs.js'
 import type { Router } from './router.js'
-import { actPermission, beforePermission, conversationMethods, everySession, isAct, isHeardBy, resultOf, usageOf, type Act, type Subscription } from './sessions.js'
+import { actPermission, conversationMethods, everySession, isAct, isHeardBy, resultOf, spawnTask, usageOf, type Act, type Subscription } from './sessions.js'
 
 type Request = Readonly<Record<string, unknown>>
 
@@ -64,6 +64,21 @@ export function serveConversations({ claude, router, store, project, report }: {
   const liveIds = new Set<string>()
   const waitingRows = new Map<string, Row[]>()
   let follower: { readonly sessions: string; stop(): void } | undefined
+  const engineTurns = new Map<string, string>()
+  router.add('turn.start', async (e, next) => {
+    const agent = (e as typeof e & { readonly agentId?: string }).agentId ?? ''
+    engineTurns.set(agent, e.turnId)
+    return next(e)
+  })
+  const endTurn = (ending: TurnEnding, task?: string) => <Below extends { readonly block?: string }>(below: Below): Below => {
+    if (below.block !== undefined) return below
+    engineTurns.delete(task ?? '')
+    dispatch(session, conversation.endTurn(new Date().toISOString(), ending, task))
+    return below
+  }
+  router.add('classic.Stop', async (e, next) => endTurn({ reason: 'answer', ...(e.last_assistant_message === undefined ? {} : { answer: e.last_assistant_message }) })(await next(e)))
+  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
 
@@ -94,6 +109,7 @@ export function serveConversations({ claude, router, store, project, report }: {
   }
 
   const restartFollower = async () => {
+    if (session === '') return
     const wantsEvery = [...heard.values()].some((sessions) => (sessions.get(everySession) ?? []).length > 0)
     const named = [...heard.values()].flatMap((sessions) => [...sessions].filter(([id, list]) => id !== session && id !== everySession && list.length > 0).map(([id]) => id))
     const others = [...new Set(named)].sort()
@@ -189,8 +205,8 @@ export function serveConversations({ claude, router, store, project, report }: {
   }
 
   const place = (): Place => {
-    const { context, contextOpenedAt, turn, tasks, taskTurns } = conversation.state
-    return { session, context, contextOpenedAt, ...(turn === undefined ? {} : { turn }), tasks, taskTurns }
+    const { context, contextOpenedAt, turn, tasks, taskTurns, openCalls } = conversation.state
+    return { session, context, contextOpenedAt, ...(turn === undefined ? {} : { turn }), tasks, taskTurns, ...(openCalls === undefined ? {} : { openCalls }) }
   }
 
   const deciders = (event: string): Watcher[] => {
@@ -199,7 +215,7 @@ export function serveConversations({ claude, router, store, project, report }: {
   }
 
   const askHere = async (mod: string, event: BeforeEvent, change: SessionChange, from = session, isInProject = true) => {
-    for (const needed of ['conversation', beforePermission(event)]) if (!(await isGranted(mod, needed))) throw new Error(`${mod} needs the ${needed} permission for before(${event}). Turn it on in /mods ${mod}.`)
+    if (from !== session && !(await isGranted(mod, 'conversation'))) throw new Error(`${mod} needs the conversation permission to change what happens in another session. Turn it on in /mods ${mod}.`)
     return claude.cmod.call({ to: mod, method: conversationMethods.before, input: { session: from, event, change, isInProject } })
   }
 
@@ -360,9 +376,10 @@ export function serveConversations({ claude, router, store, project, report }: {
   const perform = async (caller: string, action: Act, input: unknown, task: string | undefined): Promise<unknown> => {
     await checkAct(caller, action, input)
     await starting
+    if (action === 'abort') return abortTurn(input, task)
     if (task !== undefined) return performInTask(action, input, task)
     if (action === 'usage') return usageOf(claude)
-    if (action === 'clients') return [...(await claude.session.surfaces())] satisfies Client[]
+    if (action === 'surfaces') return [...(await claude.session.surfaces())] satisfies Surface[]
     if (action === 'send') {
       const { type, text, as } = input as SessionSend
       if (as === Session) throw new Error(`session ${session} cannot send as itself to itself.`)
@@ -371,26 +388,25 @@ export function serveConversations({ claude, router, store, project, report }: {
       if ('drop' in delivered && typeof delivered.drop === 'string') throw new Error(`Claude Code dropped the prompt: ${delivered.drop}`)
       return null
     }
-    if (action === 'startTask') {
-      const args = input as TaskStartArgs
-      const started = await claude.agent.spawn({
-        prompt: args.prompt,
-        ...(args.name === undefined ? {} : { description: args.name, name: args.name }),
-        ...(args.agentType === undefined ? {} : { subagentType: args.agentType }),
-        ...(args.model === undefined ? {} : { model: args.model }),
-        ...(args.cwd === undefined ? {} : { cwd: args.cwd }),
-      })
-      if (started.deny !== undefined) throw new Error(`Claude Code refused the task: ${started.deny}`)
-      return { id: started.agentId ?? '', title: args.name ?? '', agentType: args.agentType ?? 'general-purpose', model: started.model, openedBy: '', openedAt: new Date().toISOString() } satisfies TaskData
-    }
+    if (action === 'startTask') return spawnTask(claude, input as TaskStartArgs)
     const { name, input: toolInput } = input as ToolCallArgs
-    return resultOf(place(), await claude.tool.call({ ...toolInput, tool: name } as never))
+    return resultOf(place(), { name, input: toolInput, cwd: await claude.session.cwd() }, await claude.tool.call({ ...toolInput, tool: name } as never))
+  }
+
+  const abortTurn = async (input: unknown, task: string | undefined) => {
+    const turnId = engineTurns.get(task ?? '')
+    if (turnId === undefined) throw new Error(`no turn is running in ${task === undefined ? `session ${session}` : `task ${task}`}.`)
+    const asked = isObject(input) ? input['turn'] : undefined
+    const open = task === undefined ? conversation.state.turn : conversation.state.taskTurns[task]
+    if (open?.prompt.id !== asked) throw new Error(`turn ${String(asked)} has ended, so there is nothing to abort.`)
+    await claude.turn.abort({ turnId })
+    return null
   }
 
   const performInTask = async (action: Act, input: unknown, task: string): Promise<unknown> => {
     const running = conversation.state.tasks[task]
     if (action === 'usage') return json(['history', 'usage', session, '--task', task])
-    if (action === 'clients') return running === undefined || running.closedAt !== undefined ? [] : [...(await claude.session.surfaces())]
+    if (action === 'surfaces') return running === undefined || running.closedAt !== undefined ? [] : [...(await claude.session.surfaces())]
     if (action !== 'send') throw new Error(`cmod: ${action} runs only on a session's own main loop.`)
     if (running === undefined || running.closedAt !== undefined) throw ended(task)
     const sent = await claude.session.send({ to: { agentId: task }, text: (input as SessionSend).text })
@@ -402,7 +418,7 @@ export function serveConversations({ claude, router, store, project, report }: {
     await checkAct(caller, action, input)
     const isLive = await isRunning(target)
     if (!isLive && action === 'usage') return json(['history', 'usage', target, ...(task === undefined ? [] : ['--task', task])])
-    if (!isLive && action === 'clients') return []
+    if (!isLive && action === 'surfaces') return []
     if (!isLive) throw ended(task ?? target)
     if (action === 'send' && task === undefined && (input as SessionSend).as === Session) {
       const sent = await claude.session.send({ to: { sessionId: target }, text: (input as SessionSend).text })
@@ -452,8 +468,8 @@ export function serveConversations({ claude, router, store, project, report }: {
     },
     async [conversationMethods.search](request) {
       const before = isObject(request['before']) ? request['before'] : undefined
-      const record = [...textArg('--session', request['session']), ...textArg('--task', request['task']), ...textArg('--turn', request['turn']), ...countArg('--context', request['context']), ...(request['isGoal'] === true ? ['--goal'] : [])]
-      return json(['history', 'search', String(request['text']), ...scopeArgs(request), ...record, ...(request['running'] === true ? ['--running'] : []), ...countArg('--limit', request['limit']), ...(before === undefined ? [] : ['--before', `${String(before['session'])}:${String(before['id'])}`])])
+      const record = [...textArg('--session', request['session']), ...textArg('--task', request['task']), ...textArg('--turn', request['turn']), ...countArg('--context', request['context']), ...(request['isAgent'] === true ? ['--agent'] : [])]
+      return json(['history', 'search', String(request['text']), ...scopeArgs(request), ...record, ...(request['running'] === true ? ['--running'] : []), ...(before === undefined ? [] : ['--before', `${String(before['session'])}:${String(before['id'])}`])])
     },
     async [conversationMethods.messages](request) {
       const id = String(request['session'])
@@ -556,7 +572,7 @@ 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 && !(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() }
+      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() }
       try {
         return { value: await method(input, e.caller) }
       } catch (error) {

package/src/runtime/deadline.ts

@@ -6,6 +6,44 @@ export const longestMs = 600_000
 
 export const toolDeadline: Deadline = { ms: 30000, job: 'tool' }
 
+export type ListenOptions = { readonly timeoutMs?: number; readonly onFailure?: 'pass' | 'refuse' }
+
+export type ListenTime = { readonly deadline: number; readonly signal: AbortSignal }
+
+export const listenerMs = 10_000
+
+export class PassedTimeout extends Error {}
+
+const timers = globalThis as unknown as { setTimeout(run: () => void, ms: number): unknown; clearTimeout(timer: unknown): void }
+
+export function listenerOf(name: string, method: string, args: readonly unknown[]): { readonly matcher: unknown; readonly listener: (payload: never, time: ListenTime) => unknown; readonly options: ListenOptions } {
+  const hasMatcher = typeof args[1] === 'function'
+  const listener = (hasMatcher ? args[1] : args[0]) as (payload: never, time: ListenTime) => unknown
+  const options = ((hasMatcher ? args[2] : args[1]) ?? {}) as ListenOptions
+  if (typeof listener !== 'function') throw new Error(`${name}: ${method} takes a listener, or a matcher and then a listener.`)
+  const { timeoutMs, onFailure } = options as { readonly timeoutMs?: unknown; readonly onFailure?: unknown }
+  if (timeoutMs !== undefined && (typeof timeoutMs !== 'number' || !Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > longestMs)) throw new Error(`${name}: ${method}'s timeoutMs is ${String(timeoutMs)}. Give a whole number of milliseconds above 0 and at most ${longestMs}.`)
+  if (onFailure !== undefined && onFailure !== 'pass' && onFailure !== 'refuse') throw new Error(`${name}: ${method}'s onFailure is ${String(onFailure)}. Give 'pass' or 'refuse'.`)
+  return { matcher: hasMatcher ? args[0] : undefined, listener, options }
+}
+
+export async function withinTime<Value>(clock: Pick<Claude['clock'], 'now'>, method: string, { timeoutMs = listenerMs }: ListenOptions, run: (time: ListenTime) => Value | Promise<Value>): Promise<Value> {
+  const controller = new AbortController()
+  const deadline = (await clock.now()) + timeoutMs
+  let timer: unknown
+  const passed = new Promise<never>((_resolve, reject) => {
+    timer = timers.setTimeout(() => {
+      controller.abort()
+      reject(new PassedTimeout(`${method} passed its ${timeoutMs / 1000} s timeout`))
+    }, timeoutMs)
+  })
+  try {
+    return await Promise.race([Promise.resolve().then(() => run({ deadline, signal: controller.signal })), passed])
+  } finally {
+    timers.clearTimeout(timer)
+  }
+}
+
 export function beforeDeadline<Value>(claude: Claude, { ms, job }: Deadline, call: string, task: Promise<Value>): Promise<Value> {
   return new Promise<Value>((resolve, reject) => {
     const passed = job === undefined ? `its ${ms / 1000} s deadline` : `the ${ms / 1000} s deadline of ${job}`

package/src/runtime/dependencies.ts

@@ -1,6 +1,7 @@
 import type { Args, CmodDependencies, EventResult, Frozen } from 'claude-code'
 import { messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
+import type { Router } from './router.js'
 
 export const cmodPluginName = 'cmod'
 
@@ -33,6 +34,17 @@ export function withBareRefusals(claude: Claude): Claude {
   return { ...claude, cmod: { call } }
 }
 
+export function answeringOwnCalls(claude: Claude, router: Router): Claude {
+  const name = claude.plugin.name
+  const call: Claude['cmod']['call'] = async (input) => {
+    if (input.to !== name) return claude.cmod.call(input)
+    const answer = await router.dispatch('cmod.call', { ...input, caller: name } as Frozen<Args<'cmod.call'>>, async () => ({ deny: `${name} has no method ${input.method}.` }))
+    if (answer.deny !== undefined) throw new Error(answer.deny)
+    return answer.value
+  }
+  return { ...claude, cmod: { call } }
+}
+
 export function notInstalled(name: string): string {
   return `${name} is not installed. Add it with /plugin.`
 }

package/src/runtime/grants.ts

@@ -90,10 +90,6 @@ export function checkingGrants(claude: Claude, grants: Grants): Claude {
     },
     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('send', 'prompt')
         return claude.session.append(args)
@@ -109,12 +105,22 @@ export function checkingGrants(claude: Claude, grants: Grants): Claude {
         return claude.prompt.submit(args)
       },
     },
+    command: {
+      ...claude.command,
+      run: async (args: Parameters<Claude['command']['run']>[0]) => {
+        await gate(`commands.run(${args.command})`, 'prompt')
+        return claude.command.run(args)
+      },
+    },
     cmod: {
       async call(args) {
         const named = args.to === cmodPluginName ? conversationCalls[args.method] : undefined
         const given = args.method === conversationMethods.act && isObject(args.input) ? String(args.input['action']) : undefined
         const action = given !== undefined && isAct(given) ? given : undefined
-        if (named !== undefined) await gate(action ?? named, action === undefined ? 'conversation' : actPermission(action, isObject(args.input) ? args.input['input'] : undefined))
+        const isThisSession = isObject(args.input) && args.input['session'] === (await claude.session.id())
+        const isDropping = (args.method === conversationMethods.subscribe || args.method === conversationMethods.watchBefore) && isObject(args.input) && Array.isArray(args.input['subscriptions']) && args.input['subscriptions'].length === 0
+        if (named !== undefined && action !== undefined) await gate(action, actPermission(action, isObject(args.input) ? args.input['input'] : undefined))
+        else if (named !== undefined && !isThisSession && !isDropping) await gate(named, 'conversation')
         return claude.cmod.call(args)
       },
     },
@@ -211,10 +217,8 @@ 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',
 }
 

package/src/runtime/hooks.ts

@@ -1,17 +1,38 @@
-import type { Args, ClassicHookInputs, EventResult, Frozen } from 'claude-code'
-import type { Hook, HookAnswer, HookInput, HookListener } from '../mod.js'
+import type { ClassicHookEvent, ClassicHookInputs, PermissionRequestDecision } from 'claude-code'
 import { configFolders } from '../records.js'
 import type { Claude } from './claude.js'
 import type { RoutedHook } from './router.js'
 import type { Failure } from './toaster.js'
-import { reservedKeys, toolInputOf, type ToolCalls } from './tool-calls.js'
-import { callEffects, inputOf, type CallBase, type FileAccess } from '../utils/call-effects.js'
+import { callEffects, type CallBase, type FileAccess } from '../utils/call-effects.js'
 import { dynamicPattern } from '../utils/parse-shell.js'
 import { isMissing } from '../utils/paths.js'
 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 HookListener<H extends Hook> = (input: ClassicHookInputs[H]) => HookAnswer | void | Promise<HookAnswer | void>
+
 export type RoutedEvent =
-  | `classic.${Exclude<Hook, 'PreToolUse'>}`
+  | `classic.${Hook}`
   | 'tool.check'
   | 'tool.call'
   | 'prompt.submit'
@@ -29,30 +50,30 @@ export type RoutedEvent =
   | 'session.compact'
   | 'session.receive'
   | 'agent.spawn'
+  | 'turn.start'
 
 export const permissionEvents: readonly RoutedEvent[] = ['tool.check', 'classic.PermissionRequest']
 
 type ClassicFields = Record<string, unknown>
 
-type CallFiles = HookInput<'PreToolUse'>['files']
+type CallFiles = { readonly read: string[]; readonly changed: string[] }
 
-const flags: readonly string[] = ['suppressOriginalPrompt', 'reloadSkills', 'retry']
+const flags: readonly string[] = ['reloadSkills', 'retry']
 
 const readFields: Record<Hook, readonly string[]> = {
   Setup: ['additionalContext'],
   SessionStart: ['additionalContext', 'initialUserMessage', 'sessionTitle', 'watchPaths', 'reloadSkills'],
   SessionEnd: [],
-  UserPromptSubmit: ['additionalContext', 'sessionTitle', 'suppressOriginalPrompt'],
-  UserPromptExpansion: ['additionalContext', 'suppressOriginalPrompt'],
+  UserPromptSubmit: ['additionalContext', 'sessionTitle'],
+  UserPromptExpansion: ['additionalContext'],
   InstructionsLoaded: [],
   ConfigChange: [],
   DirectoryAdded: [],
   PreModelSwitch: ['permissionDecision', 'permissionDecisionReason'],
   PostModelSwitch: ['additionalContext'],
-  PreToolUse: ['additionalContext', 'permissionDecision', 'permissionDecisionReason', 'updatedInput'],
   PermissionRequest: ['decision'],
   PermissionDenied: ['retry'],
-  PostToolUse: ['additionalContext', 'updatedToolOutput', 'updatedMCPToolOutput'],
+  PostToolUse: ['additionalContext'],
   PostToolUseFailure: ['additionalContext'],
   PostToolBatch: ['additionalContext'],
   MessageDisplay: ['displayContent'],
@@ -74,80 +95,24 @@ const readFields: Record<Hook, readonly string[]> = {
   WorktreeRemove: [],
 }
 
-export function classicHook<E extends Exclude<Hook, 'PreToolUse'>>(name: string, event: E, hook: HookListener<E>, claude: Claude, calls: ToolCalls, report: (failure: Failure) => void): RoutedHook<RoutedEvent> {
-  const hookInputOf = async (e: unknown): Promise<unknown> => {
-    if (event !== 'PostToolUse' && event !== 'PostToolUseFailure') return e
-    const input = e as ClassicHookInputs['PostToolUse' | 'PostToolUseFailure']
-    const cwd = calls.cwdOf(input.tool_use_id) ?? input.cwd
-    return { ...input, files: await callFiles(name, claude, { tool: input.tool_name, input: inputOf(input.tool_input) }, cwd) }
-  }
-  const resultOf = async (e: unknown): Promise<ClassicFields | undefined> => {
-    const answer = await hook((await hookInputOf(e)) as HookInput<E>)
-    if (answer === undefined) return undefined
-    if (answer.systemMessage !== undefined) claude.ui.log(answer.systemMessage)
-    return classicResult(event, answer)
-  }
+export function classicHook<H extends Hook>(name: string, event: H, hook: HookListener<H>, report: (failure: Failure) => void): RoutedHook<RoutedEvent> {
   const routed = async (e: unknown, next: (e: unknown) => Promise<unknown>) => {
-    const ours = await resultOf(e).catch((error: unknown): ClassicFields | undefined => {
-      if (event === 'PermissionRequest') return { decision: { behavior: 'deny', message: `${name}: the ${event} hook failed: ${messageOf(error)}` } }
-      report({ id: `hook:${event}`, message: `The ${event} hook failed`, error })
-      return undefined
-    })
+    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)}` } }
+        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 routed as unknown as RoutedHook<RoutedEvent>
 }
 
-type HeldDecision = { readonly decision: 'allow' | 'ask'; readonly reason?: string }
-
-export type HeldDecisions = Map<string, HeldDecision>
-
-export function preToolUseHook(name: string, hook: HookListener<'PreToolUse'>, claude: Claude, calls: ToolCalls, held: HeldDecisions | undefined): RoutedHook<'tool.call'> {
-  return async (e, next) => {
-    let ours: ClassicFields
-    try {
-      const answer = await hook(await preToolUseInput(name, e, claude, calls.agentOf))
-      if (answer?.systemMessage !== undefined) claude.ui.log(answer.systemMessage)
-      ours = answer === undefined ? {} : classicResult('PreToolUse', answer)
-    } catch (error) {
-      return { deny: `${name}: the PreToolUse hook failed: ${messageOf(error)}` }
-    }
-    if (typeof ours['deny'] === 'string') return { deny: ours['deny'] }
-    const decided = heldDecisionOf(ours)
-    if (decided !== undefined && held === undefined) {
-      return { deny: `${name}: the PreToolUse hook answered permissionDecision "${decided.decision}", so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod.` }
-    }
-    const updated = ours['updatedInput'] as Record<string, unknown> | undefined
-    const reserved = Object.fromEntries(Object.entries(e).filter(([key]) => reservedKeys.includes(key)))
-    const earlier = held?.get(e.tool_use_id)
-    if (decided !== undefined) held?.set(e.tool_use_id, earlier !== undefined && strictness.indexOf(earlier.decision) >= strictness.indexOf(decided.decision) ? earlier : decided)
-    let result: EventResult<'tool.call'>
-    try {
-      result = await next(updated === undefined ? e : ({ ...reserved, ...updated } as Frozen<Args<'tool.call'>>))
-    } finally {
-      if (decided !== undefined) held?.delete(e.tool_use_id)
-    }
-    const context = ours['additionalContext'] as string[] | undefined
-    if (context === undefined || result.deny !== undefined) return result
-    return { ...result, context: [...(result.context ?? []), ...context] }
-  }
-}
-
-export function heldDecisionHook(held: HeldDecisions): RoutedHook<'tool.check'> {
-  return async (e, next) => {
-    const below = await next(e)
-    const ours = e.tool_use_id === undefined ? undefined : held.get(e.tool_use_id)
-    return ours === undefined || below.decision === 'deny' ? below : ours
-  }
-}
-
-function heldDecisionOf(ours: ClassicFields): HeldDecision | undefined {
-  if (ours['allow'] !== undefined) return { decision: 'allow' }
-  if (typeof ours['ask'] !== 'string') return undefined
-  return ours['ask'] === '' ? { decision: 'ask' } : { decision: 'ask', reason: ours['ask'] }
-}
-
 const frontmatter = /^---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/
 
 const baseDirectoryLine = /^Base directory for this skill: [^\n]*\n\n/
@@ -169,24 +134,7 @@ export function userSkillHook(claude: Claude): RoutedHook<'skill.prompt'> {
   }
 }
 
-async function preToolUseInput(name: string, envelope: Frozen<Args<'tool.call'>>, claude: Claude, agentOf: ToolCalls['agentOf']): Promise<HookInput<'PreToolUse'>> {
-  const { tool, tool_use_id } = envelope
-  const [session_id, cwd, { agentId, agentType }] = await Promise.all([claude.session.id(), claude.session.cwd(), agentOf(tool_use_id)])
-  const tool_input = toolInputOf(envelope)
-  return {
-    session_id,
-    cwd,
-    hook_event_name: 'PreToolUse',
-    tool_name: tool,
-    tool_input,
-    tool_use_id,
-    ...(agentId === undefined ? {} : { agent_id: agentId }),
-    ...(agentType === undefined ? {} : { agent_type: agentType }),
-    files: await callFiles(name, claude, { tool, input: tool_input }, cwd),
-  }
-}
-
-async function callFiles(name: string, claude: Claude, use: CallBase, cwd: string): Promise<CallFiles> {
+export async function callFiles(name: string, claude: Claude, use: CallBase, cwd: string): Promise<CallFiles> {
   try {
     const [home, configRoot] = await Promise.all([claude.env.home(), claude.env.configHome()])
     if (home === undefined) throw new Error('HOME is not set, so ~ in a path has no meaning.')
@@ -206,32 +154,16 @@ async function callFiles(name: string, claude: Claude, use: CallBase, cwd: strin
 
 function classicResult(event: Hook, answer: HookAnswer): ClassicFields {
   const result: ClassicFields = {}
-  const unread = (field: string) => new Error(`it answered ${field}, which ${event} does not read. Remove it from the answer.`)
-  if (event === 'PreToolUse') {
-    if (answer.continue === false || answer.stopReason !== undefined) throw unread('continue or stopReason')
-    if (answer.decision === 'block') result['deny'] = answer.reason ?? ''
-  } else {
-    if (answer.continue === false) result['preventContinuation'] = true
-    if (answer.stopReason !== undefined) result['stopReason'] = answer.stopReason
-    if (answer.decision === 'block') result['block'] = answer.reason ?? ''
-  }
+  if (answer.decision === 'block') result['block'] = answer.reason ?? ''
   const specific = answer.hookSpecificOutput ?? {}
-  if (specific.hookEventName !== undefined && specific.hookEventName !== event) {
-    throw new Error(`it answered hookSpecificOutput.hookEventName "${specific.hookEventName}". Set it to "${event}" or leave it out.`)
-  }
   for (const [field, value] of Object.entries(specific)) {
-    if (field === 'hookEventName' || value === undefined || (value === false && flags.includes(field))) continue
-    if (!readFields[event].includes(field)) throw unread(`hookSpecificOutput.${field}`)
-    if (field === 'additionalContext') result['additionalContext'] = [value]
-    else if (field === 'permissionDecision' && event === 'PreToolUse') {
-      const reason = specific.permissionDecisionReason ?? ''
-      result[value as string] = value === 'allow' ? true : reason
-    } else if (field !== 'permissionDecisionReason' || event !== 'PreToolUse') result[field] = value
+    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
 }
 
-export const strictness = ['allow', 'ask', 'deny'] as const
 
 function mergeClassic(below: ClassicFields, ours: ClassicFields): ClassicFields {
   const merged: ClassicFields = { ...below, ...ours }