@cmodjs/core 2.0.0 → 2.0.1

package/session/context/turn/message/message.js

@@ -13,7 +13,10 @@ export const Message = 'message';
 export const messageTypes = [Prompt, Note, Reply, ToolCall, ToolResult, Skill, InstructionFile, Notice];
 export const skillPrefix = 'Base directory for this skill:';
 const rowTypes = ['user', 'assistant', 'attachment', 'system'];
-const memoryPath = /^Contents of (.+?) \(/;
+const memoryPath = /^Contents of (.+?)(?: \([^)\n]*\))?:\r?$/m;
+export function instructionPathOf(text) {
+    return memoryPath.exec(text)?.[1] ?? '';
+}
 export function rowOfLine(row) {
     const { uuid, timestamp, type } = row;
     if (typeof uuid !== 'string' || typeof timestamp !== 'string' || typeof type !== 'string' || !rowTypes.includes(type))
@@ -39,7 +42,7 @@ export function rowOfLine(row) {
 export function rowOfAppend(append, at, cwd) {
     const { message, origin } = append;
     const text = textOf(message.content);
-    const path = message.type === 'attachment' ? memoryPath.exec(text)?.[1] : undefined;
+    const path = message.type === 'attachment' ? instructionPathOf(text) || undefined : undefined;
     const model = isObject(origin) && origin['kind'] === 'model' && typeof origin['model'] === 'string' ? origin['model'] : undefined;
     return {
         id: append.uuid,

package/src/records.ts

@@ -259,7 +259,7 @@ function readKeys(keys: unknown): Steps {
   return { keys: commands }
 }
 
-export const coreVersion = '2.0.0'
+export const coreVersion = '2.0.1'
 
 export function oldestCmodFor(steps: Steps): string {
   if (steps.permissions?.some((item) => item.startsWith('config:')) === true) return '1.6.0'

package/src/register.ts

@@ -5,10 +5,11 @@ import type { Claude } from './runtime/claude.js'
 import type { RoutedEvent } from './runtime/hooks.js'
 import { cmodPluginName } from './runtime/dependencies.js'
 import { createLifecycle, readPlugin, type Lifecycle } from './runtime/lifecycle.js'
+import { permissionRoutes, type PermissionRoutes } from './runtime/permission-check.js'
 
 let lifecycle: Lifecycle<object>
 
-let checksPermissions = false
+let permissionCheck: PermissionRoutes | undefined
 
 let registered: ModDefinition<object> | undefined
 
@@ -99,9 +100,9 @@ function routeCallToMod(_$: EngineInterface, eventInput: Frozen<Args<'cmod.call'
 }
 
 export function registerMod<State extends object, Declared extends Options>(addHook: On, definition: ModDefinition<State, string, Declared>, options: PluginOptions): void {
-  checksPermissions = false
+  permissionCheck = undefined
   registered = definition as ModDefinition<object>
-  lifecycle = createLifecycle(definition, () => checksPermissions, options)
+  lifecycle = createLifecycle(definition, () => permissionCheck, options)
   addHook('session.start', startMod)
   addHook('classic.Setup', routeToMod)
   addHook('classic.SessionStart', routeToMod)
@@ -154,7 +155,7 @@ export function registerMod<State extends object, Declared extends Options>(addH
 }
 
 export function registerPermissionCheck(addHook: On): void {
-  checksPermissions = true
+  permissionCheck = permissionRoutes
   addHook('tool.check', routeToMod)
   addHook('classic.PermissionRequest', routeToMod)
 }

package/src/runtime/before.ts

@@ -2,7 +2,7 @@ import type { Args, Frozen } from 'claude-code'
 import type { Disposable } from '../mod.js'
 import { ContextEnd } from '../session/context/context.js'
 import { InstructionFile, isRulePath } from '../session/context/turn/message/instruction-file.js'
-import { Message, messagesOf, noFiles, rowOfAppend, withTexts, type Unplaced } from '../session/context/turn/message/message.js'
+import { instructionPathOf, Message, messagesOf, noFiles, rowOfAppend, withTexts, type Unplaced } from '../session/context/turn/message/message.js'
 import { Note } from '../session/context/turn/message/note.js'
 import { Notice } from '../session/context/turn/message/notice.js'
 import { Prompt } from '../session/context/turn/message/prompt.js'
@@ -14,11 +14,12 @@ import { ToolResult } from '../session/context/turn/message/tool-result.js'
 import { TurnEnd } from '../session/context/turn/turn.js'
 import type { ConversationState, SessionChange, TaskData } from '../session/conversation.js'
 import { Task, TaskStart } from '../session/goal/task.js'
-import type { BeforeEvent } from '../session/session.js'
+import { sessionEvents, type BeforeEvent, type SessionEvent } from '../session/session.js'
 import type { Claude } from './claude.js'
 import { cmodPluginName } from './dependencies.js'
 import type { Router } from './router.js'
 import { toolInputOf } from './tool-calls.js'
+import { resolve } from '../vendor.js'
 
 export type Place = Pick<ConversationState, 'session' | 'context' | 'contextOpenedAt' | 'turn' | 'tasks' | 'taskTurns' | 'openCalls'>
 
@@ -66,6 +67,7 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
   }
   const titles = new Map<string, string>()
   const spawned = new Map<string, string>()
+  const agentFolders = new Map<string, string>()
   const toolResultHook = (isFailure: boolean) => async (e: Readonly<Record<string, unknown>>, next: (e: never) => Promise<unknown>) => {
     if (!(await wants(ToolResult))) return next(e as never)
     const where = await place()
@@ -121,7 +123,7 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
     router.add('prompt.attachment', async (e, next) => {
       if (!(await wants(InstructionFile)) || e.type !== 'nested_memory') return next(e)
       const where = await place()
-      const path = /^Contents of (.+?) \(/.exec(e.text)?.[1] ?? ''
+      const path = instructionPathOf(e.text)
       const answer = await asked(InstructionFile, message(where, { id: '', at: now(), type: InstructionFile, path, text: e.text, isRule: isRulePath(path) }, e.agentId))
       if (answer.refuse !== undefined) return { text: null }
       return answer.text === undefined ? next(e) : { text: answer.text }
@@ -145,7 +147,8 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
       if (!(await wants(ToolCall))) return next(e)
       const where = await place()
       const input = toolInputOf(e)
-      const answer = await asked(ToolCall, message(where, { id: e.tool_use_id, at: now(), type: ToolCall, callId: e.tool_use_id, name: e.tool, input, cwd: await claude.session.cwd(), files: noFiles }, e.agentId))
+      const cwd = (e.agentId === undefined ? undefined : agentFolders.get(e.agentId)) ?? (await claude.session.cwd())
+      const answer = await asked(ToolCall, message(where, { id: e.tool_use_id, at: now(), type: ToolCall, callId: e.tool_use_id, name: e.tool, input, cwd, files: noFiles }, e.agentId))
       if (answer.refuse !== undefined) return { deny: answer.refuse }
       if (answer.result !== undefined) return { result: answer.result }
       if (answer.input === undefined) return next(e)
@@ -154,7 +157,13 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
     }),
     router.add('agent.spawn', async (e, next) => {
       spawned.set(e.tool_use_id, e.prompt)
-      if (!(await wants(TaskStart))) return next(e)
+      const start = async (args: typeof e) => {
+        const started = await next(args)
+        const folder = args.isTeammate === true ? undefined : (args.cwd ?? (args.parentAgentId === undefined ? undefined : agentFolders.get(args.parentAgentId)))
+        if (started.agentId !== undefined && folder !== undefined) agentFolders.set(started.agentId, resolve(await claude.session.cwd(), folder))
+        return started
+      }
+      if (!(await wants(TaskStart))) return start(e)
       const where = await place()
       const task: TaskData = { id: '', title: e.description, agentType: e.subagentType, model: e.model ?? e.parentModel, openedBy: e.tool_use_id, openedAt: now(), ...(e.parentAgentId === undefined ? {} : { parent: e.parentAgentId }) }
       const answer = await asked(TaskStart, { type: TaskStart, task: { ...task, context: where.context } })
@@ -162,7 +171,7 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
         spawned.delete(e.tool_use_id)
         return { deny: answer.refuse }
       }
-      return next(answer.owner === undefined ? e : { ...e, model: answer.owner.model })
+      return start(answer.owner === undefined ? e : { ...e, model: answer.owner.model })
     }),
     router.add('classic.SubagentStart', async (e, next) => {
       const where = await place()
@@ -177,12 +186,16 @@ export function installBefore({ claude, router, hooks }: { readonly claude: Clau
       return withNote(await next(e), answer.note)
     }),
     router.add('classic.SubagentStop', async (e, next) => {
-      if (!(await wants(TurnEnd))) return next(e)
+      const stopped = <Answer extends { readonly block?: string }>(answer: Answer) => {
+        if (answer.block === undefined) agentFolders.delete(e.agent_id)
+        return answer
+      }
+      if (!(await wants(TurnEnd))) return stopped(await next(e))
       const turn = (await place()).taskTurns[e.agent_id]
-      if (turn === undefined) return next(e)
+      if (turn === undefined) return stopped(await next(e))
       const answer = await asked(TurnEnd, { type: TurnEnd, turn: { ...turn, closedAt: now() } })
       const below = await next(e)
-      return answer.refuse === undefined ? below : { ...below, block: answer.refuse }
+      return stopped(answer.refuse === undefined ? below : { ...below, block: answer.refuse })
     }),
     router.add('classic.Stop', async (e, next) => {
       if (!(await wants(TurnEnd))) return next(e)
@@ -213,41 +226,49 @@ export function withAnswer(change: SessionChange, answer: Partial<Answers>): Ses
   return change
 }
 
-export async function foldAnswers(event: BeforeEvent, change: SessionChange, askers: readonly ((change: SessionChange) => Promise<unknown>)[], report: (error: unknown) => void): Promise<Partial<Answers> | undefined> {
+export const methodOf = (prefix: 'on' | 'before', event: SessionEvent): string => `${prefix}${Object.entries(sessionEvents).find(([, each]) => each === event)?.[0] ?? event}`
+
+export const beforeAnswerKeys: Readonly<Record<BeforeEvent, readonly (keyof Answers)[]>> = {
+  prompt: ['text', 'note', 'title', 'refuse'],
+  note: ['text'],
+  skill: ['text'],
+  instructionFile: ['text', 'refuse'],
+  reply: ['text'],
+  toolCall: ['input', 'result', 'refuse'],
+  toolResult: ['output', 'isError', 'note'],
+  notice: ['text'],
+  taskStart: ['owner', 'refuse'],
+  turnEnd: ['refuse'],
+  contextEnd: ['refuse'],
+}
+
+export function foldBefore(event: BeforeEvent, change: SessionChange, askers: readonly ((change: SessionChange) => Promise<unknown>)[], report: (error: unknown) => void): Promise<Partial<Answers> | undefined> {
+  return foldAnswers(methodOf('before', event), beforeAnswerKeys[event], ['refuse', 'result'], change, askers, report, withAnswer)
+}
+
+export function takenAnswer(method: string, takes: readonly string[], answer: unknown): unknown {
+  if (answer === undefined || answer === null || answer === false) return undefined
+  if (typeof answer !== 'object' || Array.isArray(answer)) throw new Error(`it answered ${JSON.stringify(answer)}, but ${method} takes an object or nothing: ${takes.map((key) => `{ ${key} }`).join(', ') || 'no answer'}.`)
+  const unread = Object.keys(answer).filter((key) => !takes.includes(key))
+  if (unread.length > 0) throw new Error(`it answered ${unread.join(' and ')}, which ${method} does not take. It takes ${takes.map((key) => `{ ${key} }`).join(', ') || 'no answer'}.`)
+  return answer
+}
+
+export async function foldAnswers<Change, Answer extends object>(method: string, takes: readonly string[], ends: readonly string[], change: Change, askers: readonly ((change: Change) => Promise<unknown>)[], report: (error: unknown) => void, applied: (change: Change, answer: Answer) => Change = (same) => same): Promise<Answer | undefined> {
   let latest = change
-  let result: Partial<Answers> | undefined
+  let result: Record<string, unknown> | undefined
   for (const ask of askers) {
     try {
-      const answer = answerOf(event, await ask(latest))
-      if (answer === undefined) continue
-      const notes = [result?.note, answer.note].filter((note) => note !== undefined)
-      result = { ...result, ...answer, ...(notes.length === 0 ? {} : { note: notes.join('\n\n') }) }
-      if (answer.refuse !== undefined || answer.result !== undefined) return result
-      latest = withAnswer(latest, answer)
+      const answer = takenAnswer(method, takes, await ask(latest))
+      if (typeof answer !== 'object' || answer === null) continue
+      const given = answer as Record<string, unknown>
+      const notes = [result?.['note'], given['note']].filter((note) => typeof note === 'string')
+      result = { ...result, ...given, ...(notes.length === 0 ? {} : { note: notes.join('\n\n') }) }
+      if (ends.some((key) => given[key] !== undefined)) return result as Answer
+      latest = applied(latest, answer as Answer)
     } catch (error) {
       report(error)
     }
   }
-  return result
-}
-
-export function answerOf(event: BeforeEvent, answer: unknown): Partial<Answers> | undefined {
-  if (typeof answer !== 'object' || answer === null) return undefined
-  const given = answer as Partial<Answers>
-  const allowed: Readonly<Record<BeforeEvent, readonly (keyof Answers)[]>> = {
-    prompt: ['text', 'note', 'title', 'refuse'],
-    note: ['text'],
-    skill: ['text'],
-    instructionFile: ['text', 'refuse'],
-    reply: ['text'],
-    toolCall: ['input', 'result', 'refuse'],
-    toolResult: ['output', 'isError', 'note'],
-    notice: ['text'],
-    taskStart: ['owner', 'refuse'],
-    turnEnd: ['refuse'],
-    contextEnd: ['refuse'],
-  }
-  const unread = Object.keys(given).filter((key) => !allowed[event].includes(key as keyof Answers))
-  if (unread.length > 0) throw new Error(`a before(${event}) listener answered ${unread.join(' and ')}, which ${event} does not take. It takes ${allowed[event].map((key) => `{ ${key} }`).join(', ')}.`)
-  return given
+  return result as Answer | undefined
 }

package/src/runtime/conversations.ts

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

package/src/runtime/hooks.ts

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