@cmodjs/core 0.3.0 → 1.5.0

package/src/jobs/permissions/match-target.ts

@@ -1,6 +1,6 @@
 import { matchesGlob } from '../../utils/matches-glob.js'
 import { parseShell } from '../../utils/parse-shell.js'
-import { callBaseOf, type CallBase, type CallEffects, type CommandCall, type FetchCall, type FileAccess, type FileCall, type ToolCall } from '../../utils/call-effects.js'
+import { callBaseOf, type CallBase, type CallEffects, type CommandCall, type FetchCall, type FileAccess, type FileCall, type Call } from '../../utils/call-effects.js'
 import type { Workspace } from './find-project-scope.js'
 import { realPathOf, relativePath } from '../../utils/paths.js'
 import { basename } from '../../vendor.js'
@@ -9,7 +9,7 @@ export type TargetCalls = { command: CommandCall; read: FileCall; write: FileCal
 export type TargetKey = keyof TargetCalls
 export type TargetOf<Key extends TargetKey> = Record<Key, string | string[]> & Partial<Record<Exclude<TargetKey, Key>, never>>
 export type Target = { [Key in TargetKey]: TargetOf<Key> }[TargetKey]
-export type MatchedCall = { call: ToolCall; access: FileAccess | undefined; folder: string }
+export type MatchedCall = { call: Call; access: FileAccess | undefined; folder: string }
 
 const targetKeys: readonly TargetKey[] = ['command', 'read', 'write', 'fetch', 'subagent', 'tool']
 
@@ -29,7 +29,7 @@ export function targetOf(target: Target): { key: TargetKey; patterns: string[];
 export async function matchTarget(target: Target, call: CallBase, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
   const { key, patterns, exclusions } = targetOf(target)
   const base = callBaseOf(call)
-  const only = (matched: ToolCall, folder = workspace.cwd): MatchedCall[] => [{ call: matched, access: undefined, folder }]
+  const only = (matched: Call, folder = workspace.cwd): MatchedCall[] => [{ call: matched, access: undefined, folder }]
   const isNamed = (value: string) => matchesAny(value, patterns) && !matchesAny(value, exclusions)
   if (key === 'read' || key === 'write') {
     const matched: MatchedCall[] = []

package/src/jobs/permissions.ts

@@ -1,13 +1,14 @@
 import type { Args, Frozen } from 'claude-code'
 import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { inputOf } from '../utils/call-effects.js'
 import { decidePermission, stricterVerdict, type PermissionRules as RulesFor, type Rule as RuleFor, type Verdict } from './permissions/decide-permission.js'
 import { targetOf } from './permissions/match-target.js'
 import { messageOf } from '../utils/text.js'
-import { modOf, workspaceReader } from './context.js'
+import { withinDeadline, workspaceReader } from './context.js'
 
-export type { CommandCall, FetchCall, FileCall, ToolCall } from '../utils/call-effects.js'
+export type { CommandCall, FetchCall, FileCall, Call } from '../utils/call-effects.js'
 export type { Target } from './permissions/match-target.js'
 export type Rule<State extends object = Record<never, never>> = RuleFor<Mod<State>>
 export type PermissionRules<State extends object = Record<never, never>> = RulesFor<Mod<State>>
@@ -19,25 +20,26 @@ export function permissions<State extends object = Record<never, never>>(rules:
   if (count === 0) throw new Error('permissions: give it a deny or an ask rule, or remove it from setup.')
 
   return (job) => {
+    const { router, toolCalls } = engineOf(job.mod)
     const readWorkspace = workspaceReader(job)
 
     const verdictOf = async (e: Frozen<Args<'tool.check'>>): Promise<Verdict | undefined> => {
       let current: PermissionRules<State>
       try {
-        current = typeof rules === 'function' ? rules(job.mod.state as State) : rules
+        current = typeof rules === 'function' ? rules(job.mod.state) : rules
         checkedCount(current)
       } catch (error) {
         return { decision: 'deny', reason: `The permission rules of ${job.mod.name} failed, so it denies the call: ${messageOf(error)}` }
       }
       try {
-        const [agent, workspace] = await Promise.all([job.toolCalls.agentOf(e.tool_use_id), readWorkspace()])
-        return await decidePermission(current, { tool: e.tool, input: inputOf(e.input), ...agent }, workspace, (call, folder) => modOf(job, { call, folder }, workspace, deadline))
+        const [agent, workspace] = await Promise.all([toolCalls.agentOf(e.tool_use_id), readWorkspace()])
+        return await decidePermission(current, { tool: e.tool, input: inputOf(e.input), ...agent }, workspace, job.mod, (run) => withinDeadline(job.mod, deadline, 'it', run))
       } catch (error) {
         return { decision: 'deny', reason: `The permissions job could not read the session, so it denies the call: ${messageOf(error)}` }
       }
     }
 
-    job.mod.claude.on('tool.check', async (e, next) => {
+    router.add('tool.check', async (e, next) => {
       const [below, ours] = await Promise.all([next(e), verdictOf(e)])
       return ours === undefined ? below : stricterVerdict<Verdict>(below, ours)
     })

package/src/jobs/program.ts

@@ -1,5 +1,6 @@
 import type { Job } from '../mod.js'
-import { PermissionRefused } from '../runtime/grants.js'
+import { PermissionRefused, programAddresses } from '../runtime/grants.js'
+import { engineOf } from '../runtime/engine.js'
 import { messageOf } from '../utils/text.js'
 
 export type Program = {
@@ -14,7 +15,7 @@ const backoffSeconds = [1, 2, 4, 8, 16] as const
 export function program(options: { readonly command: readonly string[]; readonly environment?: Record<string, string> }): Job<Program> {
   const { command, environment } = options
   return ({ mod, announce }) => {
-    const { claude } = mod
+    const { claude, report } = engineOf(mod)
     const [executable] = command
     if (executable === undefined) throw new Error(`${mod.name}: the program has no command. Name the program on PATH and its arguments, such as ['preview-server', '--port', '0'].`)
     let state: Program['state'] = 'stopped'
@@ -22,11 +23,17 @@ export function program(options: { readonly command: readonly string[]; readonly
     let failure: Error | undefined
     let exits = 0
     const waiting: { resolve: (address: Address) => void; reject: (error: Error) => void }[] = []
+    const ownAddresses = programAddresses(mod)
 
     const stop = (reason: string) => {
       state = 'fatal'
       failure = new Error(`${mod.name}: the ${executable} program stopped: ${reason}`)
-      claude.ui.log(failure.message)
+      const retry = () => {
+        exits = 0
+        failure = undefined
+        void start()
+      }
+      report({ id: `program:${executable}`, message: `The ${executable} program stopped`, description: reason, retry })
       for (const waiter of waiting.splice(0)) waiter.reject(failure)
     }
 
@@ -52,17 +59,19 @@ export function program(options: { readonly command: readonly string[]; readonly
           }
           state = 'running'
           exits = 0
+          ownAddresses.add(address.socketPath ?? new URL(address.url).host)
           for (const waiter of waiting.splice(0)) waiter.resolve(address)
         }
       } catch (error) {
         if (error instanceof PermissionRefused) return stop(`${messageOf(error)} Add it, then run /reload-plugins.`)
         lastError = messageOf(error)
       }
+      if (address !== undefined) ownAddresses.delete(address.socketPath ?? new URL(address.url).host)
       address = undefined
       exits += 1
       const wait = backoffSeconds[exits - 1]
       if (wait === undefined) {
-        stop(`it did not start again after ${backoffSeconds.length} tries: ${lastError === '' ? 'no standard error' : lastError}. Fix it, then run /reload-plugins.`)
+        stop(`it did not start again after ${backoffSeconds.length} tries: ${lastError === '' ? 'no standard error' : lastError}.`)
         return
       }
       state = 'backoff'

package/src/jobs/prompt.ts

@@ -1,12 +1,13 @@
 import type { Job, JobContext, Mod } from '../mod.js'
-import { longestMs, type Deadline } from '../runtime/deadline.js'
+import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { onStateChange } from '../runtime/state.js'
 import { listed, messageOf } from '../utils/text.js'
-import { callEffects, type ToolCall } from '../utils/call-effects.js'
+import { callEffects, type Call } from '../utils/call-effects.js'
 import { matchTarget, targetOf, type Target } from './permissions/match-target.js'
-import { afterCall, modOf, modWithin, targetWords } from './context.js'
+import { afterCall, inFolder, targetWords, withinDeadline } from './context.js'
 
-type PromptInput = { userPrompt?: string; call?: ToolCall }
+type PromptInput = { userPrompt?: string; call?: Call & { readonly folder: string } }
 
 type PromptOptions<State extends object> = {
   name: string
@@ -15,7 +16,7 @@ type PromptOptions<State extends object> = {
   after?: Target | Target[]
 }
 
-const deadline: Deadline = { ms: 5000, longestMs, job: 'prompt' }
+const deadline: Deadline = { ms: 5000, job: 'prompt' }
 
 export function prompt<State extends object = Record<never, never>>({ name, prompt: text, when, after }: PromptOptions<State>): Job<void, State> {
   if (name.trim() === '') throw new Error('prompt: give the block a name. Claude reads the text under it.')
@@ -26,10 +27,10 @@ export function prompt<State extends object = Record<never, never>>({ name, prom
   return (job) => {
     job.reserveName('prompt', name, `prompt: ${job.mod.name} adds the name "${name}" two times. Give each prompt its own name.`)
 
-    const log = (reason: string) => job.mod.claude.ui.log(`prompt "${name}" added nothing: ${reason}`, { to: 'debug' })
-    const textFor = async (input: PromptInput, mod: Mod<State>) => {
+    const log = (reason: string) => job.mod.log(`prompt "${name}" added nothing: ${reason}`)
+    const textFor = async (input: PromptInput) => {
       try {
-        const value = typeof text === 'string' ? text : await text(input, mod)
+        const value = typeof text === 'string' ? text : await withinDeadline(job.mod, deadline, `the ${name} prompt`, () => text(input, job.mod))
         return value === '' ? undefined : value
       } catch (error) {
         log(messageOf(error))
@@ -37,36 +38,37 @@ export function prompt<State extends object = Record<never, never>>({ name, prom
       }
     }
 
-    const headedText = async (input: PromptInput, mod: Mod<State>) => {
-      const value = await textFor(input, mod)
+    const headedText = async (input: PromptInput) => {
+      const value = await textFor(input)
       return value === undefined ? undefined : `# ${name}\n${value}`
     }
 
     if (when !== undefined) {
-      addAfterUserPrompts(job, when, (userPrompt) => headedText({ userPrompt }, modWithin(job, deadline)), log)
+      addAfterUserPrompts(job, when, (userPrompt) => headedText({ userPrompt }), log)
       job.announce(`the ${name} prompt after matching user prompts`)
     } else if (targets.length > 0) {
       addAfterCalls(job, targets, headedText, log)
       job.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`)
     } else {
-      addKeptCurrent(job, name, () => textFor({}, modWithin(job, deadline)), log)
+      addKeptCurrent(job, name, () => textFor({}), log)
       job.announce(`the ${name} prompt`)
     }
   }
 }
 
 function addKeptCurrent<State extends object>(job: JobContext<State>, name: string, textFor: () => Promise<string | undefined>, log: (reason: string) => void): void {
+  const { claude, router } = engineOf(job.mod)
   let given: string | undefined
   let hasStarted = false
   let isQueued = false
   let updates = Promise.resolve()
 
-  job.mod.claude.on('classic.SessionStart', (e, next) => {
+  router.add('classic.SessionStart', (e, next) => {
     hasStarted = e.source === 'resume' || e.source === 'compact'
     if (!hasStarted) given = undefined
     return next(e)
   })
-  job.mod.claude.on('prompt.context', async (e, next) => {
+  router.add('prompt.context', async (e, next) => {
     const below = await next(e)
     hasStarted = true
     if (below.blocks.some((block) => block.name === name)) {
@@ -83,7 +85,7 @@ function addKeptCurrent<State extends object>(job: JobContext<State>, name: stri
     const value = await textFor()
     if (value === undefined || value === given) return
     given = value
-    await job.mod.claude.session.append({ message: { type: 'user', content: [{ type: 'text', text: `# ${name}\n${value}` }] } }).then((added) => {
+    await claude.session.append({ message: { type: 'user', content: [{ type: 'text', text: `# ${name}\n${value}` }] } }).then((added) => {
       if (added.deny !== undefined) log(`Claude Code refused the new text: ${added.deny}`)
     })
   }
@@ -94,8 +96,8 @@ function addKeptCurrent<State extends object>(job: JobContext<State>, name: stri
   })
 }
 
-function addAfterUserPrompts(job: JobContext, when: RegExp | ((userPrompt: string) => boolean), textFor: (userPrompt: string) => Promise<string | undefined>, log: (reason: string) => void): void {
-  job.mod.claude.on('prompt.submit', async (e, next) => {
+function addAfterUserPrompts<State extends object>(job: JobContext<State>, when: RegExp | ((userPrompt: string) => boolean), textFor: (userPrompt: string) => Promise<string | undefined>, log: (reason: string) => void): void {
+  engineOf(job.mod).router.add('prompt.submit', async (e, next) => {
     let value: string | undefined
     try {
       if (typeof when === 'function' ? when(e.text) : e.text.search(when) >= 0) value = await textFor(e.text)
@@ -106,12 +108,7 @@ function addAfterUserPrompts(job: JobContext, when: RegExp | ((userPrompt: strin
   })
 }
 
-function addAfterCalls<State extends object>(
-  job: JobContext<State>,
-  targets: Target[],
-  textFor: (input: PromptInput, mod: Mod<State>) => Promise<string | undefined>,
-  log: (reason: string) => void,
-): void {
+function addAfterCalls<State extends object>(job: JobContext<State>, targets: Target[], textFor: (input: PromptInput) => Promise<string | undefined>, log: (reason: string) => void): void {
   afterCall(
     job,
     async (use, workspace) => {
@@ -119,7 +116,7 @@ function addAfterCalls<State extends object>(
       for (const target of targets) {
         const [matched] = await matchTarget(target, use, effects, workspace)
         if (matched === undefined) continue
-        const value = await textFor({ call: matched.call }, modOf(job, matched, workspace, deadline))
+        const value = await textFor({ call: await inFolder(matched.call, matched.folder, workspace) })
         return value === undefined ? [] : [value]
       }
       return []

package/src/jobs/schedule.ts

@@ -1,37 +1,37 @@
 import type { Job } from '../mod.js'
 import { onStateChange } from '../runtime/state.js'
-import { messageOf } from '../utils/text.js'
+import { engineOf } from '../runtime/engine.js'
 
-export type Schedule = { readonly cron: string; readonly prompt: string }
+export type ScheduledPrompt = { readonly cron: string; readonly prompt: string }
 
 const scheduleCounts = new WeakMap<object, number>()
 
-export function schedule<State extends object = Record<never, never>>(entry: Schedule | ((state: State) => Schedule | undefined)): Job<void, State> {
+export function schedule<State extends object = Record<never, never>>(entry: ScheduledPrompt | ((state: State) => ScheduledPrompt | undefined)): Job<void, State> {
   if (typeof entry !== 'function') checked(entry)
 
   return (job) => {
     const { mod } = job
-    const { claude } = mod
+    const { claude, report: reportFailure } = engineOf(mod)
     const order = scheduleCounts.get(mod) ?? 0
     scheduleCounts.set(mod, order + 1)
     const storeKey = `cmod:schedule:${order}`
-    const log = (reason: string) => claude.ui.log(`${mod.name}: the schedule ${reason}`)
+    const report = (message: string, error: unknown) => reportFailure({ id: storeKey, message: `The schedule ${message}`, error })
     let current: { readonly id: string; readonly wanted: string } | undefined
     let isQueued = false
 
     const remove = async (id: string) => {
-      await claude.tool.call({ tool: 'CronDelete', id }).catch(() => undefined)
+      await claude.tool.call({ tool: 'CronDelete', id }).catch((error: unknown) => report(`could not delete its last cron ${id}`, error))
       await claude.store.delete(storeKey)
     }
 
     const update = async () => {
       isQueued = false
-      let next: Schedule | undefined
+      let next: ScheduledPrompt | undefined
       try {
-        next = typeof entry === 'function' ? entry(mod.state as State) : entry
+        next = typeof entry === 'function' ? entry(mod.state) : entry
         if (next !== undefined) checked(next)
       } catch (error) {
-        log(`kept its last cron: ${messageOf(error)}`)
+        report('kept its last cron', error)
         return
       }
       const wanted = next === undefined ? undefined : JSON.stringify([next.cron, next.prompt])
@@ -40,8 +40,8 @@ export function schedule<State extends object = Record<never, never>>(entry: Sch
       current = undefined
       if (next === undefined) return
       const answer = await claude.tool.call({ tool: 'CronCreate', cron: next.cron, prompt: next.prompt, recurring: true })
-      if (answer.deny !== undefined) return log(`was refused: ${answer.deny}`)
-      if (answer.isError === true) return log(`failed: ${answer.text ?? 'CronCreate answered an error'}`)
+      if (answer.deny !== undefined) return report('was refused', answer.deny)
+      if (answer.isError === true) return report('failed', answer.text ?? 'CronCreate answered an error')
       current = { id: answer.result.id, wanted: wanted as string }
       await claude.store.set(storeKey, current.id)
     }
@@ -50,17 +50,17 @@ export function schedule<State extends object = Record<never, never>>(entry: Sch
       .get(storeKey)
       .then((left) => (typeof left === 'string' ? remove(left) : undefined))
       .then(update)
-      .catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+      .catch((error: unknown) => report('failed', error))
     onStateChange(mod.state, () => {
       if (isQueued) return
       isQueued = true
-      updates = updates.then(update).catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+      updates = updates.then(update).catch((error: unknown) => report('failed', error))
     })
     job.announce(typeof entry === 'function' ? 'a schedule from its state' : `a schedule at ${entry.cron}`)
   }
 }
 
-function checked(entry: Schedule): void {
+function checked(entry: ScheduledPrompt): void {
   if (entry.cron.trim() === '') throw new Error('schedule: give it a cron, such as "*/10 * * * *" for every 10 minutes.')
   if (entry.prompt.trim() === '') throw new Error('schedule: give it the prompt Claude gets at each fire.')
 }

package/src/jobs/slash-command.ts

@@ -1,13 +1,14 @@
 import type { CommandRunResult } from 'claude-code'
-import type { Job, Mod } from '../mod.js'
+import type { Disposable, Job, Mod } from '../mod.js'
 import { parse } from '../vendor.js'
-import { longestMs, type Deadline } from '../runtime/deadline.js'
+import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
+import { withinDeadline } from './context.js'
 
-export type Reply = string | { text?: string; context?: string } | undefined
+export type CommandReply = string | { text?: string; context?: string } | undefined
 
-const deadline: Deadline = { ms: 30000, longestMs, job: 'slashCommand' }
+const deadline: Deadline = { ms: 30000, job: 'slashCommand' }
 
 const commandName = /^[A-Za-z0-9_-]{1,64}$/
 
@@ -16,14 +17,14 @@ export function slashCommand<State extends object = Record<never, never>>(option
   readonly description: string
   readonly argumentHint?: string
   readonly immediate?: true
-  readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => Reply | void | Promise<Reply | void>
-}): Job<void, State> {
+  readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => CommandReply | void | Promise<CommandReply | void>
+}): Job<Disposable, State> {
   const { name, description, argumentHint, immediate, reply } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router, report } = engineOf(mod)
     if (!commandName.test(name)) throw new Error(`${mod.name}: "${name}" is not a slash command name. Use 1 to 64 letters, digits, "_", or "-", without the slash.`)
-    reserveName('slashCommand', name, `${mod.name}: the slash command /${name} is already added. Give each slashCommand its own name.`)
+    const reserved = reserveName('slashCommand', name, `${mod.name}: the slash command /${name} is already added. Give each slashCommand its own name.`)
 
     let registered: string | undefined
     claude.command.register({ name, description, ...(argumentHint === undefined ? {} : { argumentHint }), ...(immediate === undefined ? {} : { immediate }) }).then(
@@ -31,24 +32,29 @@ export function slashCommand<State extends object = Record<never, never>>(option
         registered = command
       },
       (error: unknown) => {
-        claude.ui.log(`${mod.name}: /${name} is not added: ${oneLine(error)}`)
+        report({ id: `command:${name}`, message: `/${name} is not added`, error })
       },
     )
     announce(`/${name}`)
 
-    const replyMod = modWithin(job, deadline)
-    claude.on('command.run', async (e, next) => {
+    const answering = router.add('command.run', async (e, next) => {
       if (e.command !== registered) return next(e)
       try {
-        return answerOf(await reply({ args: e.args, positionals: splitWords(e.args) }, replyMod))
+        return answerOf(await withinDeadline(mod, deadline, `/${name}`, () => reply({ args: e.args, positionals: splitWords(e.args) }, mod)))
       } catch (error) {
         return { text: `/${name} failed: ${oneLine(error)}` }
       }
     })
+    return {
+      dispose() {
+        answering.dispose()
+        reserved.dispose()
+      },
+    }
   }
 }
 
-function answerOf(reply: Reply | void): CommandRunResult {
+function answerOf(reply: CommandReply | void): CommandRunResult {
   if (reply === undefined) return {}
   if (typeof reply === 'string') return { text: reply }
   return { ...(reply.text === undefined ? {} : { text: reply.text }), ...(reply.context === undefined ? {} : { context: [reply.context] }) }

package/src/jobs/status-line.ts

@@ -1,13 +1,10 @@
 import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
+import { usageOf } from '../runtime/sessions.js'
+import type { Usage } from '../session/session.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
-
-export type Usage = {
-  model: string
-  context: { tokens?: number; window: number; percent?: number }
-  cost?: { usd: number }
-}
+import { withinDeadline } from './context.js'
 
 const deadline: Deadline = { ms: 2000, job: 'statusLine' }
 
@@ -18,30 +15,21 @@ export function statusLine<State extends object = Record<never, never>>(options:
   const { text, interval = 10000 } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router } = engineOf(mod)
     if (!(interval >= 1)) throw new Error(`${mod.name}: the status line interval is ${interval}. Give it in milliseconds, 1 or more.`)
     reserveName('statusLine', '', `${mod.name}: a status line is already added. A mod has one status line: join the texts in one statusLine.`)
 
-    const textMod = modWithin(job, deadline)
     let shown: string | undefined
     let queue = Promise.resolve()
     const update = async () => {
       try {
-        const [model, usage] = await Promise.all([claude.session.model(), claude.session.usage()])
-        const { tokens, window, percent } = usage.context
-        const next = await text(
-          {
-            model,
-            context: { window, ...(tokens === undefined ? {} : { tokens }), ...(percent === undefined ? {} : { percent }) },
-            ...(usage.cost === undefined ? {} : { cost: { usd: usage.cost.usd } }),
-          },
-          textMod,
-        )
+        const usage = await usageOf(claude)
+        const next = await withinDeadline(mod, deadline, 'the status line', () => text(usage, mod))
         if (next === shown) return
         shown = next
         claude.ui.status(next)
       } catch (error) {
-        claude.ui.log(`${mod.name}: the status line kept its last text: ${messageOf(error)}`, { to: 'debug' })
+        mod.log(`the status line kept its last text: ${messageOf(error)}`)
       }
     }
     const refresh = () => {
@@ -49,7 +37,7 @@ export function statusLine<State extends object = Record<never, never>>(options:
     }
 
     announce('a status line')
-    claude.on('session.measure', (e, next) => {
+    router.add('session.measure', (e, next) => {
       refresh()
       return next(e)
     })

package/src/jobs/tool.ts

@@ -1,10 +1,11 @@
 import type { FromSchema, JSONSchema } from 'json-schema-to-ts'
-import type { Job, Mod } from '../mod.js'
+import type { Disposable, Job, Mod } from '../mod.js'
 import { Validator } from '../vendor.js'
 import { toolDeadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { reservedKeys, toolInputOf } from '../runtime/tool-calls.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
+import { withinDeadline } from './context.js'
 
 const toolName = /^[A-Za-z0-9_-]{1,64}$/
 
@@ -13,42 +14,47 @@ export function tool<const Schema extends object = { type: 'object' }, State ext
   readonly description: string
   readonly inputSchema?: Schema
   readonly execute: (input: Schema extends JSONSchema ? FromSchema<Schema> : never, mod: Mod<State>) => unknown
-}): Job<{ readonly name: string }, State> {
+}): Job<Disposable & { readonly name: string }, State> {
   const { name, description, inputSchema, execute } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router, report } = engineOf(mod)
     if (!toolName.test(name)) throw new Error(`${mod.name}: "${name}" is not a tool name. Use 1 to 64 letters, digits, "_", or "-".`)
     const properties = (inputSchema as { properties?: object } | undefined)?.properties ?? {}
     const reserved = reservedKeys.filter((key) => Object.hasOwn(properties, key))
     if (reserved.length > 0) throw new Error(`${mod.name}: the ${name} tool's inputSchema has the property ${reserved.join(', ')}, which Claude Code keeps for itself. Rename it.`)
-    reserveName('tool', name, `${mod.name}: the tool ${name} is already added. Give each tool its own name.`)
+    const named = reserveName('tool', name, `${mod.name}: the tool ${name} is already added. Give each tool its own name.`)
 
-    const validator = new Validator((inputSchema ?? { type: 'object' }) as ConstructorParameters<typeof Validator>[0], '2020-12', false)
+    const validator = new Validator(inputSchema ?? { type: 'object' }, '2020-12', false)
     let registered: string | undefined
     claude.tool.register({ name, description, ...(inputSchema === undefined ? {} : { inputSchema: inputSchema as Record<string, unknown> }) }).then(
       (answer) => {
         registered = answer.tool
       },
       (error: unknown) => {
-        claude.ui.log(`${mod.name}: the ${name} tool is not added: ${messageOf(error)}`)
+        report({ id: `tool:${name}`, message: `The ${name} tool is not added`, error })
       },
     )
     announce(`the ${name} tool`)
 
-    const executeMod = modWithin(job, toolDeadline)
-    claude.on('tool.call', async (e, next) => {
+    const answering = router.add('tool.call', async (e, next) => {
       if (e.tool !== registered) return next(e)
       const input = toolInputOf(e)
       const { valid, errors } = validator.validate(input)
       if (!valid) return { deny: `The ${name} tool input is not valid:\n${errors.map((error) => `- ${error.instanceLocation}: ${error.error}`).join('\n')}` }
       try {
-        return { result: resultOf(await execute(input as Parameters<typeof execute>[0], executeMod)) }
+        return { result: resultOf(await withinDeadline(mod, toolDeadline, `the ${name} tool`, () => execute(input as Parameters<typeof execute>[0], mod))) }
       } catch (error) {
         return { deny: `The ${name} tool failed: ${messageOf(error)}` }
       }
     })
-    return { name: `mcp__${claude.plugin.name}__${name}` }
+    return {
+      name: `mcp__${claude.plugin.name}__${name}`,
+      dispose() {
+        answering.dispose()
+        named.dispose()
+      },
+    }
   }
 }