@cmodjs/core 0.2.3 → 1.0.0

package/session/session.d.ts

@@ -0,0 +1,99 @@
+import type { Disposable } from '../mod.js';
+import type { Matcher } from '../utils/matcher.js';
+import type { Context, ContextEnd, ContextStart } from './context/context.js';
+import type { Document } from './context/turn/message/document.js';
+import type { Message, MessageType } from './context/turn/message/message.js';
+import type { Note } from './context/turn/message/note.js';
+import type { Notice } from './context/turn/message/notice.js';
+import type { Prompt } from './context/turn/message/prompt.js';
+import type { Reply } from './context/turn/message/reply.js';
+import type { Person } from './context/turn/message/sender.js';
+import type { Skill } from './context/turn/message/skill.js';
+import type { ToolCall } from './context/turn/message/tool-call.js';
+import type { ToolResult } from './context/turn/message/tool-result.js';
+import type { Turn, TurnEnd, TurnStart } from './context/turn/turn.js';
+import type { Goal, GoalChange } from './goal/goal.js';
+import type { Task, TaskEnd, TaskStart } from './goal/task.js';
+export declare const Session = "session";
+export type SessionEvent = typeof Message | MessageType | typeof ContextStart | typeof ContextEnd | typeof TurnStart | typeof TurnEnd | typeof TaskStart | typeof TaskEnd | typeof GoalChange;
+export type SessionPayload = {
+    readonly message: Message;
+    readonly prompt: Prompt;
+    readonly note: Note;
+    readonly reply: Reply;
+    readonly toolCall: ToolCall;
+    readonly toolResult: ToolResult;
+    readonly skill: Skill;
+    readonly document: Document;
+    readonly notice: Notice;
+    readonly contextStart: Context;
+    readonly contextEnd: Context;
+    readonly turnStart: Turn;
+    readonly turnEnd: Turn;
+    readonly taskStart: Task;
+    readonly taskEnd: Task;
+    readonly goalChange: Goal;
+};
+export type Usage = {
+    readonly model: string;
+    readonly context: {
+        readonly tokens?: number;
+        readonly window: number;
+        readonly percent?: number;
+    };
+    readonly cost?: {
+        readonly usd: number;
+    };
+};
+export type Listener<Event extends SessionEvent> = (payload: SessionPayload[Event]) => unknown;
+export type SessionSend = {
+    readonly type: typeof Prompt | typeof Note;
+    readonly text: string;
+    readonly as?: typeof Person | typeof Session;
+};
+export type TaskStartArgs = {
+    readonly prompt: string;
+    readonly agentType?: string;
+    readonly model?: string;
+    readonly name?: string;
+    readonly cwd?: string;
+};
+export type Session = {
+    readonly id: string;
+    readonly title: string;
+    readonly project: string;
+    readonly cwd: string;
+    readonly model: string;
+    readonly startedAt: string;
+    readonly lastAt: string;
+    readonly forkedFrom?: string;
+    readonly isRunning: boolean;
+    usage(): Promise<Usage>;
+    on<Event extends SessionEvent>(event: Event, listener: Listener<Event>): Disposable;
+    on<Event extends SessionEvent>(event: Event, matcher: Matcher<SessionPayload[Event]>, listener: Listener<Event>): Disposable;
+    send(message: SessionSend): Promise<void>;
+    startTask(task: TaskStartArgs): Promise<Task>;
+    messages(options?: {
+        readonly after?: string;
+        readonly last?: number;
+    }): Promise<Message[]>;
+    turns(options?: {
+        readonly last?: number;
+    }): Promise<Turn[]>;
+    contexts(): Promise<Context[]>;
+    goal(): Promise<Goal>;
+};
+export type SessionScope = {
+    readonly running?: boolean;
+    readonly since?: string;
+    readonly everyProject?: boolean;
+};
+export type Sessions = {
+    readonly current: Session;
+    list(options?: SessionScope): Promise<Session[]>;
+    search(text: string, options?: SessionScope & {
+        readonly limit?: number;
+        readonly before?: Pick<Message, 'session' | 'id'>;
+    }): Promise<Message[]>;
+};
+//# sourceMappingURL=session.d.ts.map

package/session/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session/session.ts"],"names":[],"mappings":"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"}

package/session/session.js

@@ -0,0 +1 @@
+export const Session = 'session';

package/src/jobs/check.ts

@@ -1,9 +1,10 @@
 import type { Job } from '../mod.js'
 import { longestMs, type Deadline } from '../runtime/deadline.js'
-import { callEffects, type ToolCall } from '../utils/call-effects.js'
+import { callEffects, type Call } from '../utils/call-effects.js'
 import { dirname } from '../vendor.js'
 import { listed, messageOf } from '../utils/text.js'
-import { afterCall, modOf, targetWords } from './context.js'
+import { engineOf } from '../runtime/engine.js'
+import { afterCall, targetWords, withinDeadline } from './context.js'
 import type { Workspace } from './permissions/find-project-scope.js'
 import { matchTarget, targetOf, type Target } from './permissions/match-target.js'
 
@@ -27,7 +28,9 @@ export function check<State extends object = Record<never, never>>(options: { re
         if (triggered === undefined) return []
         try {
           const { command, folder } = triggered
-          const { exitCode, stdout, stderr } = await modOf(job, { folder }, workspace, deadline).process.run(command)
+          const workTree = await workspace.scope?.workTreeOf(folder)
+          const { claude } = engineOf(job.mod)
+          const { exitCode, stdout, stderr } = await withinDeadline(job.mod, deadline, command.join(' '), () => claude.process.run(command, { ...(workTree === undefined ? {} : { cwd: workTree }), timeoutMs }))
           return exitCode === 0 ? [] : [`${command.join(' ')} exited with ${exitCode}:\n${`${stdout}${stderr}`.trim()}`]
         } catch (error) {
           return [`The ${named} failed: ${messageOf(error)}`]
@@ -39,7 +42,7 @@ export function check<State extends object = Record<never, never>>(options: { re
   }
 }
 
-async function triggeredRun(after: readonly Target[], run: readonly string[], use: ToolCall, workspace: Workspace): Promise<{ command: string[]; folder: string } | undefined> {
+async function triggeredRun(after: readonly Target[], run: readonly string[], use: Call, workspace: Workspace): Promise<{ command: string[]; folder: string } | undefined> {
   const effects = callEffects(use, workspace)
   const paths = new Set<string>()
   let commandFolder: string | undefined

package/src/jobs/context.ts

@@ -1,48 +1,42 @@
-import type { Args, Frozen, HookStream, ProcessSpawnChunk, ProcessSpawnResult } from 'claude-code'
-import type { JobContext, Mod } from '../mod.js'
-import type { Claude } from '../runtime/claude.js'
+import type { JobContext } from '../mod.js'
 import { beforeDeadline, type Deadline } from '../runtime/deadline.js'
-import { dependencyCalls } from '../runtime/dependencies.js'
+import { engineOf } from '../runtime/engine.js'
 import { toolInputOf } from '../runtime/tool-calls.js'
 import { listed } from '../utils/text.js'
-import type { ToolCall } from '../utils/call-effects.js'
+import type { Call } from '../utils/call-effects.js'
 import { findProjectScope, type Workspace } from './permissions/find-project-scope.js'
 import { targetOf, type Target } from './permissions/match-target.js'
 import type { FileSystem } from '../utils/paths.js'
 
 type Session = Omit<Workspace, 'projectRoot' | 'cwd'>
 
-type Stream = HookStream<ProcessSpawnChunk, ProcessSpawnResult>
-
-export function workspaceReader({ mod: { claude } }: JobContext): () => Promise<Workspace> {
+export function workspaceReader({ mod }: JobContext): () => Promise<Workspace> {
+  const { claude } = engineOf(mod)
   let session: Promise<Session> | undefined
   return async () => {
-    session ??= readSession(claude)
+    session ??= readSession()
     const [{ home, scope, fs }, projectRoot, cwd] = await Promise.all([session, claude.session.root(), claude.session.cwd()])
     return { projectRoot, cwd, home, fs, scope }
   }
-}
 
-async function readSession(claude: Claude): Promise<Session> {
-  const fs: FileSystem = {
-    read: (path) => claude.fs.read(path),
-    stat: (path) => claude.fs.stat(path, { resolve: true }),
-    exists: (path) => claude.fs.exists(path),
+  async function readSession(): Promise<Session> {
+    const fs: FileSystem = {
+      read: (path) => claude.fs.read(path),
+      stat: (path) => claude.fs.stat(path, { resolve: true }),
+      exists: (path) => claude.fs.exists(path),
+    }
+    const home = await claude.env.home()
+    if (home === undefined) throw new Error('HOME is not set, so ~ in a path has no meaning. Start Claude Code with HOME set.')
+    return { home, fs, scope: await findProjectScope(claude.plugin.root, home, fs) }
   }
-  const home = await claude.env.home()
-  if (home === undefined) throw new Error('HOME is not set, so ~ in a path has no meaning. Start Claude Code with HOME set.')
-  return { home, fs, scope: await findProjectScope(claude.plugin.root, home, fs) }
 }
 
-export function afterCall<State extends object>(
-  job: JobContext<State>,
-  contextAfter: (call: ToolCall, workspace: Workspace) => Promise<readonly string[]>,
-  failed: (error: unknown) => readonly string[],
-): void {
+export function afterCall<State extends object>(job: JobContext<State>, contextAfter: (call: Call, workspace: Workspace) => Promise<readonly string[]>, failed: (error: unknown) => readonly string[]): void {
+  const { router, toolCalls } = engineOf(job.mod)
   const readWorkspace = workspaceReader(job)
-  job.mod.claude.on('tool.call', async (e, next) => {
-    const before = Promise.all([useOf(job, e), readWorkspace()])
-    await before.catch(() => undefined)
+  router.add('tool.call', async (e, next) => {
+    const before = Promise.all([toolCalls.agentOf(e.tool_use_id).then((agent): Call => ({ tool: e.tool, input: toolInputOf(e), ...agent })), readWorkspace()])
+    await Promise.allSettled([before])
     const result = await next(e)
     if (result.deny !== undefined || result.isError === true) return result
     const added = await before.then(([use, workspace]) => contextAfter(use, workspace)).catch(failed)
@@ -50,64 +44,12 @@ export function afterCall<State extends object>(
   })
 }
 
-async function useOf({ toolCalls }: JobContext, e: Frozen<Args<'tool.call'>>): Promise<ToolCall> {
-  return { tool: e.tool, input: toolInputOf(e), ...(await toolCalls.agentOf(e.tool_use_id)) }
+export async function inFolder(call: Call, folder: string, workspace: Workspace): Promise<Call & { readonly folder: string }> {
+  return { ...call, folder: (await workspace.scope?.workTreeOf('path' in call ? call.path : folder)) ?? folder }
 }
 
-export function modOf<State extends object>(job: JobContext<State>, { call, folder }: { readonly call?: ToolCall; readonly folder: string }, workspace: Workspace, deadline: Deadline): Mod<State> {
-  return modWithin(job, deadline, async () => workspace.scope?.workTreeOf(call !== undefined && 'path' in call ? call.path : folder))
-}
-
-export function modWithin<State extends object>({ mod }: JobContext<State>, deadline: Deadline, workTree: () => Promise<string | undefined> = async () => undefined): Mod<State> {
-  const { claude } = mod
-  const within = <Value>(call: string, task: Promise<Value>) => beforeDeadline(claude, deadline, call, task)
-  const folderOf = async (cwd: string | undefined) => {
-    const folder = cwd ?? (await workTree())
-    return folder === undefined ? {} : { cwd: folder }
-  }
-  const overrides: Pick<Mod<State>, 'process' | 'fs' | 'http' | 'dependencies'> = {
-    process: {
-      async run(argv, init) {
-        const folder = await folderOf(init?.cwd)
-        const timeoutMs = Math.min(init?.timeoutMs ?? deadline.ms, deadline.longestMs ?? deadline.ms)
-        return beforeDeadline(claude, { ...deadline, ms: timeoutMs }, 'mod.process.run', mod.process.run(argv, { ...init, ...folder, timeoutMs }))
-      },
-      spawn: (argv, init) => spawnWithin(claude, deadline, folderOf(init?.cwd).then((folder) => mod.process.spawn(argv, { ...init, ...folder }))),
-    },
-    fs: {
-      read: (path) => within('mod.fs.read', mod.fs.read(path)),
-      write: (path, text) => within('mod.fs.write', mod.fs.write(path, text)),
-      list: (path) => within('mod.fs.list', mod.fs.list(path)),
-      exists: (path) => within('mod.fs.exists', mod.fs.exists(path)),
-      stat: (path, options) => within('mod.fs.stat', mod.fs.stat(path, options)),
-      find: (glob) => within('mod.fs.find', mod.fs.find(glob)),
-    },
-    http: { fetch: (url, init) => within('mod.http.fetch', mod.http.fetch(url, init)) },
-    dependencies: dependencyCalls(claude, within),
-  }
-  return Object.assign(Object.create(mod) as Mod<State>, overrides)
-}
-
-function spawnWithin(claude: Claude, deadline: Deadline, started: Promise<Stream>): Stream {
-  async function* pieces(): AsyncGenerator<ProcessSpawnChunk, ProcessSpawnResult> {
-    const stream: AsyncIterator<ProcessSpawnChunk, ProcessSpawnResult> = await started
-    let finish: () => void = () => undefined
-    const running = beforeDeadline(claude, deadline, 'mod.process.spawn', new Promise<void>((resolve) => (finish = resolve)))
-    const passed = running.then(() => new Promise<never>(() => undefined))
-    try {
-      for (;;) {
-        const piece = await Promise.race([stream.next(), passed])
-        if (piece.done === true) return piece.value
-        yield piece.value
-      }
-    } finally {
-      finish()
-      void stream.return?.()
-    }
-  }
-  const result = started.then((stream) => stream.result)
-  result.catch(() => undefined)
-  return Object.assign(pieces(), { result })
+export function withinDeadline<Value>(mod: object, deadline: Deadline, subject: string, run: () => Value | Promise<Value>): Promise<Value> {
+  return beforeDeadline(engineOf(mod).claude, deadline, subject, Promise.resolve().then(run))
 }
 
 export function targetWords(target: Target): string {

package/src/jobs/permissions/decide-permission.ts

@@ -1,17 +1,18 @@
 import { strictness } from '../../runtime/hooks.js'
 import { messageOf } from '../../utils/text.js'
-import { callBaseOf, callEffects, type CallEffects, type ToolCall } from '../../utils/call-effects.js'
+import { callBaseOf, callEffects, type CallEffects, type Call } from '../../utils/call-effects.js'
 import type { Workspace } from './find-project-scope.js'
 import { folderInScope, matchTarget, targetOf, type MatchedCall, type Target, type TargetCalls, type TargetKey, type TargetOf } from './match-target.js'
 import { resolve } from '../../vendor.js'
+import { inFolder } from '../context.js'
 
 export type Rule<Mod> = {
   [Key in TargetKey]: TargetOf<Key> & {
-    when?: (call: TargetCalls[Key], mod: Mod) => boolean | Promise<boolean>
+    when?: (call: TargetCalls[Key] & { readonly folder: string }, mod: Mod) => boolean | Promise<boolean>
     reason?: string
   }
 }[TargetKey]
-type WhenOf<Mod> = { when?(call: ToolCall, mod: Mod): boolean | Promise<boolean> }
+type WhenOf<Mod> = { when?(call: Call & { readonly folder: string }, mod: Mod): boolean | Promise<boolean> }
 export type PermissionRules<Mod> = { deny?: Rule<Mod>[]; ask?: Rule<Mod>[] }
 export type Decision = 'allow' | 'ask' | 'deny'
 export type Verdict = { decision: Decision; reason?: string }
@@ -22,12 +23,12 @@ export function stricterVerdict<Result extends Verdict>(first: Result, second: R
   return strictness.indexOf(second.decision) > strictness.indexOf(first.decision) ? second : first
 }
 
-export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: ToolCall, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<Verdict | undefined> {
+export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: Call, workspace: Workspace, mod: Mod, within: (run: () => boolean | Promise<boolean>) => Promise<boolean>): Promise<Verdict | undefined> {
   try {
     const effects = callEffects(use, workspace)
     for (const decision of ['deny', 'ask'] as const) {
       for (const rule of rules[decision] ?? []) {
-        const outcome = await ruleOutcome(rule, use, effects, workspace, modOf)
+        const outcome = await ruleOutcome(rule, use, effects, workspace, mod, within)
         if (outcome === undefined) continue
         const reason = [rule.reason, outcome.failure === undefined ? undefined : `Its when check failed: ${outcome.failure}`].filter((part) => part !== undefined).join(' ')
         return reason === '' ? { decision } : { decision, reason }
@@ -39,7 +40,7 @@ export async function decidePermission<Mod>(rules: PermissionRules<Mod>, use: To
   }
 }
 
-async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolCall, effects: CallEffects, workspace: Workspace, modOf: (call: ToolCall, folder: string) => Mod): Promise<{ failure: string | undefined } | undefined> {
+async function ruleOutcome<Mod>(rule: Rule<Mod>, use: Call, effects: CallEffects, workspace: Workspace, mod: Mod, within: (run: () => boolean | Promise<boolean>) => Promise<boolean>): Promise<{ failure: string | undefined } | undefined> {
   const matched = await matchTarget(rule, use, effects, workspace)
   const calls = matched.length > 0 ? matched : await unparsedMatches(rule, use, effects, workspace)
   if (calls.length === 0) return undefined
@@ -48,7 +49,8 @@ async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolCall, effects: CallEff
   for (const { call, access, folder } of calls) {
     const fullCall = access?.contents === undefined ? call : { ...call, ...(await access.contents()) }
     try {
-      if (await when(fullCall, modOf(fullCall, folder))) return { failure: undefined }
+      const placed = await inFolder(fullCall, folder, workspace)
+      if (await within(() => when(placed, mod))) return { failure: undefined }
     } catch (error) {
       return { failure: messageOf(error) }
     }
@@ -56,7 +58,7 @@ async function ruleOutcome<Mod>(rule: Rule<Mod>, use: ToolCall, effects: CallEff
   return undefined
 }
 
-async function unparsedMatches(target: Target, use: ToolCall, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
+async function unparsedMatches(target: Target, use: Call, effects: CallEffects, workspace: Workspace): Promise<MatchedCall[]> {
   const shell = effects.shell
   if (shell === undefined || shell.isFullyParsed) return []
   const { key, patterns } = targetOf(target)

package/src/jobs/permissions/find-project-scope.ts

@@ -1,4 +1,4 @@
-import type { FileSystem } from '../../utils/paths.js'
+import { ifMissing, type FileSystem } from '../../utils/paths.js'
 import { basename, dirname, resolve } from '../../vendor.js'
 
 export type ProjectScope = { workTreeOf: (path: string) => Promise<string | undefined> }
@@ -33,19 +33,13 @@ export async function findProjectScope(pluginRoot: string, home: string, fs: Fil
 
 async function readRepository(workTree: string, fs: FileSystem): Promise<string | undefined> {
   const gitPath = resolve(workTree, '.git')
-  const git = await fs.stat(gitPath).catch(() => undefined)
+  const git = await fs.stat(gitPath).catch(ifMissing(undefined))
   if (git === undefined) return undefined
   if (git.kind === 'dir') return git.realPath ?? gitPath
-  try {
-    const gitDirectory = /^gitdir:\s*(.+)$/m.exec(await fs.read(gitPath))?.[1]?.trim()
-    if (gitDirectory === undefined) throw new Error(`${gitPath} has no gitdir line.`)
-    const linkedDirectory = resolve(workTree, gitDirectory)
-    const commonDirectory = await fs.read(resolve(linkedDirectory, 'commondir')).then(
-      (text) => resolve(linkedDirectory, text.trim()),
-      () => linkedDirectory,
-    )
-    return (await fs.stat(commonDirectory)).realPath ?? commonDirectory
-  } catch {
-    return workTree
-  }
+  const gitDirectory = /^gitdir:\s*(.+)$/m.exec(await fs.read(gitPath))?.[1]?.trim()
+  if (gitDirectory === undefined) return workTree
+  const linkedDirectory = resolve(workTree, gitDirectory)
+  const commonDirectory = await fs.read(resolve(linkedDirectory, 'commondir')).then((text) => resolve(linkedDirectory, text.trim()), ifMissing(linkedDirectory))
+  const common = await fs.stat(commonDirectory).catch(ifMissing(undefined))
+  return common === undefined ? workTree : (common.realPath ?? commonDirectory)
 }

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,12 @@ 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)
+      report({ id: `program:${executable}`, message: `The ${executable} program stopped`, description: reason })
       for (const waiter of waiting.splice(0)) waiter.reject(failure)
     }
 
@@ -52,12 +54,14 @@ 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]

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 []